Thu Nov 8 14:57:11 PST 2007

Added: llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JFileChooser.java
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JFileChooser.java?rev=43913&view=auto

==============================================================================

--- llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JFileChooser.java (added)
+++ llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JFileChooser.java Thu Nov  8 16:56:19 2007
@@ -0,0 +1,1624 @@
+/* JFileChooser.java --
+   Copyright (C) 2002, 2004, 2005, 2006,  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;
+
+import java.awt.Component;
+import java.awt.Frame;
+import java.awt.GraphicsEnvironment;
+import java.awt.HeadlessException;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.awt.event.WindowEvent;
+import java.awt.event.WindowAdapter;
+import java.beans.PropertyChangeEvent;
+import java.io.File;
+import java.util.ArrayList;
+
+import javax.accessibility.Accessible;
+import javax.accessibility.AccessibleContext;
+import javax.accessibility.AccessibleRole;
+import javax.swing.filechooser.FileFilter;
+import javax.swing.filechooser.FileSystemView;
+import javax.swing.filechooser.FileView;
+import javax.swing.plaf.FileChooserUI;
+
+
+/**
+ * A component that provides the user a dialog box to browse through a
+ * filesystem and choose one or more files or directories.
+ *
+ * A JFileChooser can be configured to filter the displayed file list
+ * by adding a {@link FileFilter} instance using
+ * {@link #addChoosableFileFilter(FileFilter)}. Additional components can
+ * be embedded in the file chooser using {@link #setAccessory(JComponent)}.
+ * The JFileChooser properties also provide mechanisms to customize the
+ * behaviour of the file chooser.
+ *
+ * @author Kim Ho (kho at luxsci.net)
+ */
+public class JFileChooser extends JComponent implements Accessible
+{
+  private static final long serialVersionUID = 3162921138695327837L;
+
+  /** 
+   * A dialog type for selecting a file to open. 
+   * @see #setDialogType(int)
+   */
+  public static final int OPEN_DIALOG = 0;
+
+  /** 
+   * A dialog type for selecting a file to save.  
+   * @see #setDialogType(int)
+   */
+  public static final int SAVE_DIALOG = 1;
+
+  /** 
+   * A dialog type for some custom purpose.
+   * @see #setDialogType(int)
+   */
+  public static final int CUSTOM_DIALOG = 2;
+
+  /** 
+   * A return value indicating the file chooser has been closed by cancelling.
+   * 
+   * @see #showOpenDialog(Component)
+   * @see #showSaveDialog(Component) 
+   */
+  public static final int CANCEL_OPTION = 1;
+
+  /** 
+   * A return value indicating the file chooser has been closed by approving
+   * the selection.
+   * @see #showOpenDialog(Component)
+   * @see #showSaveDialog(Component) 
+   */
+  public static final int APPROVE_OPTION = 0;
+
+  /** 
+   * A return value indicating the file chooser has been closed by some error.
+   * @see #showOpenDialog(Component)
+   * @see #showSaveDialog(Component) 
+   */
+  public static final int ERROR_OPTION = -1;
+
+  /** 
+   * A selection mode constant indicating acceptance of files only.
+   * @see #setFileSelectionMode(int)
+   */
+  public static final int FILES_ONLY = 0;
+
+  /** 
+   * A selection mode constant indicating acceptance of directories only. 
+   * @see #setFileSelectionMode(int)
+   */
+  public static final int DIRECTORIES_ONLY = 1;
+
+  /** 
+   * A selection mode constant indicating acceptance of files and directories.
+   * @see #setFileSelectionMode(int)
+   */
+  public static final int FILES_AND_DIRECTORIES = 2;
+
+  /** 
+   * Action command string for cancelling the current selection.
+   * @see #cancelSelection()
+   */
+  public static final String CANCEL_SELECTION = "CancelSelection";
+
+  /** 
+   * Action command string for approving the current selection.
+   * @see #cancelSelection()
+   */
+  public static final String APPROVE_SELECTION = "ApproveSelection";
+
+  /**
+   * The name of the property for the approve button text.
+   * @see #setApproveButtonText(String) 
+   */
+  public static final String APPROVE_BUTTON_TEXT_CHANGED_PROPERTY =
+    "ApproveButtonTextChangedProperty";
+
+  /**
+   * The name of the property for the approve button tool tip text.
+   * @see #setApproveButtonToolTipText(String)
+   */
+  public static final String APPROVE_BUTTON_TOOL_TIP_TEXT_CHANGED_PROPERTY =
+    "ApproveButtonToolTipTextChangedProperty";
+
+  /**
+   * The name of the property for the approve button mnemonic.
+   * @see #setApproveButtonMnemonic(int)
+   */
+  public static final String APPROVE_BUTTON_MNEMONIC_CHANGED_PROPERTY =
+    "ApproveButtonMnemonicChangedProperty";
+
+  /**
+   * The name of the property for control button visibility.
+   * @see #setControlButtonsAreShown(boolean)
+   */
+  public static final String CONTROL_BUTTONS_ARE_SHOWN_CHANGED_PROPERTY =
+    "ControlButtonsAreShownChangedProperty";
+
+  /**
+   * The name of the property for the current directory.
+   * @see #setCurrentDirectory(File)  
+   */
+  public static final String DIRECTORY_CHANGED_PROPERTY = "directoryChanged";
+
+  /**
+   * The name of the property for the selected file.
+   * @see #setSelectedFile(File)
+   */
+  public static final String SELECTED_FILE_CHANGED_PROPERTY =
+    "SelectedFileChangedProperty";
+
+  /**
+   * The name of the property for the selected files.
+   * @see #setSelectedFiles(File[])
+   */
+  public static final String SELECTED_FILES_CHANGED_PROPERTY =
+    "SelectedFilesChangedProperty";
+
+  /** 
+   * The name of the property for multi-selection.
+   * @see #setMultiSelectionEnabled(boolean) 
+   */
+  public static final String MULTI_SELECTION_ENABLED_CHANGED_PROPERTY =
+    "MultiSelectionEnabledChangedProperty";
+
+  /**
+   * The name of the 'file system view' property.
+   * @see #setFileSystemView(FileSystemView) 
+   */
+  public static final String FILE_SYSTEM_VIEW_CHANGED_PROPERTY =
+    "FileSystemViewChanged";
+
+  /**
+   * The name of the 'file view' property.
+   * @see #setFileView(FileView) 
+   */
+  public static final String FILE_VIEW_CHANGED_PROPERTY = "fileViewChanged";
+
+  /**
+   * The name of the 'file hiding enabled' property.
+   * @see #setFileHidingEnabled(boolean)
+   */
+  public static final String FILE_HIDING_CHANGED_PROPERTY =
+    "FileHidingChanged";
+
+  /**
+   * The name of the 'file filter' property.
+   * @see #setFileFilter(FileFilter)
+   */
+  public static final String FILE_FILTER_CHANGED_PROPERTY =
+    "fileFilterChanged";
+
+  /**
+   * The name of the 'file selection mode' property.
+   * @see #setFileSelectionMode(int)
+   */
+  public static final String FILE_SELECTION_MODE_CHANGED_PROPERTY =
+    "fileSelectionChanged";
+
+  /**
+   * The name of the 'accessory' property.
+   * @see #setAccessory(JComponent)
+   */
+  public static final String ACCESSORY_CHANGED_PROPERTY =
+    "AccessoryChangedProperty";
+
+  /**
+   * The name of the 'accept all file filter used' property.
+   * @see #setAcceptAllFileFilterUsed(boolean)
+   */
+  public static final String ACCEPT_ALL_FILE_FILTER_USED_CHANGED_PROPERTY =
+    "acceptAllFileFilterUsedChanged";
+
+  /**
+   * The name of the 'dialog title' property.
+   * @see #setDialogTitle(String)
+   */
+  public static final String DIALOG_TITLE_CHANGED_PROPERTY =
+    "DialogTitleChangedProperty";
+
+  /**
+   * The name of the 'dialog type' property.
+   * @see #setDialogType(int)
+   */
+  public static final String DIALOG_TYPE_CHANGED_PROPERTY =
+    "DialogTypeChangedProperty";
+
+  /**
+   * The name of the 'choosable file filters' property.
+   * @see #addChoosableFileFilter(FileFilter)
+   */
+  public static final String CHOOSABLE_FILE_FILTER_CHANGED_PROPERTY =
+    "ChoosableFileFilterChangedProperty";
+
+  /** 
+   * The accessible context. 
+   * @see #getAccessibleContext()
+   */
+  protected AccessibleContext accessibleContext;
+
+  /** 
+   * The file system view.
+   * @see #setFileSystemView(FileSystemView)
+   */
+  private FileSystemView fsv;
+
+  /**
+   * The accessory component.
+   * @see #setAccessory(JComponent)
+   */
+  private JComponent accessory;
+
+  /**
+   * The approve button mnemonic.
+   * @see #setApproveButtonMnemonic(int)
+   */
+  private int approveButtonMnemonic = 0;
+
+  /**
+   * The approve button text.
+   * @see #setApproveButtonText(String)
+   */
+  private String approveButtonText;
+
+  /**
+   * The approve button tool tip text.
+   * @see #setApproveButtonToolTipText(String)
+   */
+  private String approveButtonToolTipText;
+
+  /**
+   * The choosable file filters.
+   * @see #addChoosableFileFilter(FileFilter)
+   */
+  private ArrayList choosableFilters = new ArrayList();
+
+  /**
+   * A flag controlling whether the accept all file filter is used.
+   * @see #setAcceptAllFileFilterUsed(boolean)
+   */
+  private boolean isAcceptAll = true;
+
+  /**
+   * The dialog title.
+   * @see #setDialogTitle(String)
+   */
+  private String dialogTitle;
+
+  /**
+   * The dialog type.
+   * @see #setDialogType(int)
+   */
+  private int dialogType = OPEN_DIALOG;
+
+  /**
+   * The return value for the dialog.
+   * @see #showOpenDialog(Component)
+   * @see #showSaveDialog(Component)
+   */
+  private int retval = ERROR_OPTION;
+
+  /**
+   * A flag indicating whether the file chooser allows multiple selection.
+   * @see #isMultiSelectionEnabled()
+   */
+  private boolean multiSelection = false;
+
+  /**
+   * A flag indicating whether file hiding is enabled.
+   * @see #isFileHidingEnabled()
+   */
+  private boolean fileHiding = true;
+
+  /**
+   * The file selection mode.
+   * @see #setFileSelectionMode(int) 
+   */
+  private int fileSelectionMode = FILES_ONLY;
+
+  /** 
+   * The file view.
+   * @see #setFileView(FileView)
+   */
+  private FileView fv = null;
+
+  /** 
+   * A flag controlling whether or not the control buttons are visible. 
+   * @see #setControlButtonsAreShown(boolean) 
+   */
+  private boolean controlButtonsShown = true;
+
+  /** 
+   * The current directory. 
+   * @see #setCurrentDirectory(File)
+   */
+  private File currentDir = null;
+
+  /** 
+   * The current file filter.
+   * @see #setFileFilter(FileFilter)
+   */
+  private FileFilter currentFilter = null;
+
+  /** 
+   * An array of selected files.
+   * @see #setSelectedFiles(File[]) 
+   */
+  private File[] selectedFiles;
+
+  /** 
+   * The selected file. 
+   * @see #setSelectedFile(File)
+   */
+  private File selectedFile;
+  
+  /**
+   * The drag enabled property.
+   * @see #setDragEnabled(boolean)
+   * @see #getDragEnabled()
+   */
+  private boolean dragEnabled;
+
+  /**
+   * Creates a new <code>JFileChooser</code> object.
+   */
+  public JFileChooser()
+  {
+    setup(null);
+    setCurrentDirectory(null);
+  }
+
+  /**
+   * Creates a new <code>JFileChooser</code> object.
+   *
+   * @param currentDirectoryPath the directory that should initially be
+   *        shown in the filechooser (if <code>null</code>, the user's home 
+   *        directory is used).
+   */
+  public JFileChooser(String currentDirectoryPath)
+  {
+    this(currentDirectoryPath, null);
+  }
+
+  /**
+   * Creates a new <code>JFileChooser</code> object with the specified 
+   * directory and {@link FileSystemView}.
+   *
+   * @param currentDirectoryPath  the directory that should initially be
+   *        shown in the filechooser (if <code>null</code>, the user's home 
+   *        directory is used).
+   * @param fsv  the file system view (if <code>null</code>, the default file
+   *             system view is used).
+   */
+  public JFileChooser(String currentDirectoryPath, FileSystemView fsv)
+  {
+    setup(fsv);
+    File dir = null;
+    if (currentDirectoryPath != null)
+      dir = getFileSystemView().createFileObject(currentDirectoryPath);
+    setCurrentDirectory(dir);
+  }
+
+  /**
+   * Creates a new <code>JFileChooser</code> object.
+   *
+   * @param currentDirectory  the directory that should initially be
+   *        shown in the filechooser (if <code>null</code>, the user's home 
+   *        directory is used).
+   */
+  public JFileChooser(File currentDirectory)
+  {
+    setup(null);
+    setCurrentDirectory(currentDirectory);
+  }
+
+  /**
+   * Creates a new <code>JFileChooser</code> object.
+   *
+   * @param fsv  the file system view (if <code>null</code>, the default file
+   *             system view is used).
+   */
+  public JFileChooser(FileSystemView fsv)
+  {
+    setup(fsv);
+    setCurrentDirectory(null);
+  }
+
+  /**
+   * Creates a new <code>JFileChooser</code> object.
+   *
+   * @param currentDirectory  the directory that should initially be
+   *        shown in the filechooser (if <code>null</code>, the user's home 
+   *        directory is used).
+   * @param fsv  the file system view (if <code>null</code>, the default file
+   *             system view is used).
+   */
+  public JFileChooser(File currentDirectory, FileSystemView fsv)
+  {
+    setup(fsv);
+    setCurrentDirectory(currentDirectory);
+  }
+
+  /**
+   * Sets up the file chooser.  This method is called by all the constructors.
+   *
+   * @param view  the file system view (if <code>null</code>, the default file
+   *              system view is used).
+   * 
+   * @see FileSystemView#getFileSystemView()
+   */
+  protected void setup(FileSystemView view)
+  {
+    if (view == null)
+      view = FileSystemView.getFileSystemView();
+    setFileSystemView(view);
+    updateUI();
+  }
+
+  /**
+   * Sets the dragEnabled property, this disables/enables automatic drag
+   * handling (drag and drop) on this component. The default value of the
+   * dragEnabled property is false. 
+   * 
+   * Some look and feels might not support automatic drag and drop; they
+   * will ignore this property.
+   * 
+   * @param b - the new dragEnabled value
+   */
+  public void setDragEnabled(boolean b)
+  {
+    if (b && GraphicsEnvironment.isHeadless())
+      throw new HeadlessException();
+    
+    dragEnabled = b;
+  }
+
+  /**
+   * Returns true if dragging is enabled.
+   *
+   * @return true if dragging is enabled.
+   */
+  public boolean getDragEnabled()
+  {
+    return dragEnabled;
+  }
+
+  /**
+   * Returns the selected file, if there is one.
+   *
+   * @return The selected file (possibly <code>null</code>).
+   * 
+   * @see #setSelectedFile(File)
+   */
+  public File getSelectedFile()
+  {
+    return selectedFile;
+  }
+
+  /**
+   * Sets the selected file and sends a {@link PropertyChangeEvent} to all
+   * registered listeners.  The property name is 
+   * {@link #SELECTED_FILE_CHANGED_PROPERTY}.
+   *
+   * @param file  the file (<code>null</code> permitted).
+   */
+  public void setSelectedFile(File file)
+  {
+    if (selectedFile == null || !selectedFile.equals(file))
+      {
+	File old = selectedFile;
+	selectedFile = file;
+	firePropertyChange(SELECTED_FILE_CHANGED_PROPERTY, old, selectedFile);
+      }
+  }
+
+  /**
+   * Returns the selected file or files in an array.  If no files are selected,
+   * an empty array is returned.
+   *
+   * @return An array of the selected files (possibly empty).
+   */
+  public File[] getSelectedFiles()
+  {
+    if (selectedFiles != null)
+      return selectedFiles;
+    if (selectedFile != null)
+      return new File[] { selectedFile };
+    return new File[0];
+  }
+
+  /**
+   * Sets the selected files and sends a {@link PropertyChangeEvent} (with the 
+   * name {@link #SELECTED_FILES_CHANGED_PROPERTY}) to all registered 
+   * listeners.  
+   *
+   * @param selectedFiles  the selected files (<code>null</code> permitted).
+   */
+  public void setSelectedFiles(File[] selectedFiles)
+  {
+    if (selectedFiles == null)
+      selectedFiles = new File[0];
+    if (selectedFiles.length > 0)
+      setSelectedFile(selectedFiles[0]);
+    else
+      setSelectedFile(null);
+    if (this.selectedFiles != selectedFiles)
+      {
+	File[] old = this.selectedFiles;
+	this.selectedFiles = selectedFiles;
+	firePropertyChange(SELECTED_FILES_CHANGED_PROPERTY, old, selectedFiles);
+      }
+
+  }
+
+  /**
+   * Returns the current directory.
+   *
+   * @return The current directory.
+   */
+  public File getCurrentDirectory()
+  {
+    return currentDir;
+  }
+
+  /**
+   * Sets the current directory and fires a {@link PropertyChangeEvent} (with 
+   * the property name {@link #DIRECTORY_CHANGED_PROPERTY}) to all registered 
+   * listeners.  If <code>dir</code> is <code>null</code>, the current 
+   * directory is set to the default directory returned by the file system
+   * view.
+   *
+   * @param dir  the new directory (<code>null</code> permitted).
+   * 
+   * @see FileSystemView#getDefaultDirectory()
+   */
+  public void setCurrentDirectory(File dir)
+  {
+    if (currentDir != dir || dir == null)
+      {
+	if (dir == null)
+	  dir = fsv.getDefaultDirectory();
+
+	File old = currentDir;
+	currentDir = dir;
+	firePropertyChange(DIRECTORY_CHANGED_PROPERTY, old, currentDir);
+      }
+  }
+
+  /**
+   * Called by the UI delegate when the parent directory is changed.
+   */
+  public void changeToParentDirectory()
+  {
+    setCurrentDirectory(fsv.getParentDirectory(currentDir));
+  }
+
+  /**
+   * Rescans the current directory (this is handled by the UI delegate).
+   */
+  public void rescanCurrentDirectory()
+  {
+    getUI().rescanCurrentDirectory(this);
+  }
+
+  /**
+   * Ensures the the specified file is visible (this is handled by the 
+   * UI delegate).
+   *
+   * @param f  the file.
+   */
+  public void ensureFileIsVisible(File f)
+  {
+    getUI().ensureFileIsVisible(this, f);
+  }
+
+  /**
+   * Displays the file chooser in a modal dialog using the 
+   * {@link #OPEN_DIALOG} type.
+   *
+   * @param parent  the parent component.
+   *
+   * @return A return value indicating how the dialog was closed (one of 
+   *         {@link #APPROVE_OPTION}, {@link #CANCEL_OPTION} and 
+   *         {@link #ERROR_OPTION}).
+   *
+   * @throws HeadlessException DOCUMENT ME!
+   */
+  public int showOpenDialog(Component parent) throws HeadlessException
+  {
+    JDialog d = createDialog(parent);
+
+    // FIXME: Remove when we get ancestor property
+    d.setTitle("Open");
+    setDialogType(OPEN_DIALOG);
+
+    retval = ERROR_OPTION;
+
+    d.pack();
+    d.show();
+    return retval;
+  }
+
+  /**
+   * Displays the file chooser in a modal dialog using the 
+   * {@link #SAVE_DIALOG} type.
+   *
+   * @param parent  the parent component.
+   *
+   * @return A return value indicating how the dialog was closed (one of 
+   *         {@link #APPROVE_OPTION}, {@link #CANCEL_OPTION} and 
+   *         {@link #ERROR_OPTION}).
+   *
+   * @throws HeadlessException DOCUMENT ME!
+   */
+  public int showSaveDialog(Component parent) throws HeadlessException
+  {
+    JDialog d = createDialog(parent);
+    setDialogType(SAVE_DIALOG);
+
+    retval = ERROR_OPTION;
+
+    d.pack();
+    d.show();
+    return retval;
+  }
+
+  /**
+   * Displays the file chooser in a modal dialog using the 
+   * {@link #CUSTOM_DIALOG} type.
+   *
+   * @param parent  the parent component.
+   *
+   * @return A return value indicating how the dialog was closed (one of 
+   *         {@link #APPROVE_OPTION}, {@link #CANCEL_OPTION} and 
+   *         {@link #ERROR_OPTION}).
+   *
+   * @throws HeadlessException DOCUMENT ME!
+   */
+  public int showDialog(Component parent, String approveButtonText)
+                 throws HeadlessException
+  {
+    JDialog d = createDialog(parent);
+    setApproveButtonText(approveButtonText);
+    setDialogType(CUSTOM_DIALOG);
+
+    retval = ERROR_OPTION;
+
+    d.pack();
+    d.show();
+    return retval;
+  }
+
+  /**
+   * Creates a modal dialog in which to display the file chooser.
+   *
+   * @param parent  the parent component.
+   *
+   * @return The dialog.
+   *
+   * @throws HeadlessException DOCUMENT ME!
+   */
+  protected JDialog createDialog(Component parent) throws HeadlessException
+  {
+    Frame toUse = (Frame) SwingUtilities.getAncestorOfClass(Frame.class, parent);
+    if (toUse == null)
+      toUse = (Frame) SwingUtilities.getOwnerFrame(null);
+
+    JDialog dialog = new JDialog(toUse);
+    setSelectedFile(null);
+    dialog.getContentPane().add(this);
+    dialog.addWindowListener( new WindowAdapter()
+      {
+	public void windowClosing(WindowEvent e)
+	{
+	  cancelSelection();
+	}
+      });
+    dialog.setModal(true);
+    dialog.invalidate();
+    dialog.repaint();
+    return dialog;
+  }
+
+  /**
+   * Returns the flag that controls whether or not the control buttons are
+   * shown on the file chooser.
+   *
+   * @return A boolean.
+   * 
+   * @see #setControlButtonsAreShown(boolean)
+   */
+  public boolean getControlButtonsAreShown()
+  {
+    return controlButtonsShown;
+  }
+
+  /**
+   * Sets the flag that controls whether or not the control buttons are
+   * shown and, if it changes, sends a {@link PropertyChangeEvent} (with the
+   * property name {@link #CONTROL_BUTTONS_ARE_SHOWN_CHANGED_PROPERTY}) to
+   * all registered listeners.
+   *
+   * @param b  the new value for the flag.
+   */
+  public void setControlButtonsAreShown(boolean b)
+  {
+    if (controlButtonsShown != b)
+      {
+	controlButtonsShown = b;
+	firePropertyChange(CONTROL_BUTTONS_ARE_SHOWN_CHANGED_PROPERTY,
+	                   ! controlButtonsShown, controlButtonsShown);
+      }
+  }
+
+  /**
+   * Returns the type of file chooser.
+   *
+   * @return {@link #OPEN_DIALOG}, {@link #SAVE_DIALOG} or 
+   * {@link #CUSTOM_DIALOG}.
+   * 
+   * @see #setDialogType(int)
+   */
+  public int getDialogType()
+  {
+    return dialogType;
+  }
+
+  /**
+   * Sets the dialog type and fires a {@link PropertyChangeEvent} (with the
+   * property name {@link #DIALOG_TYPE_CHANGED_PROPERTY}) to all 
+   * registered listeners.
+   *
+   * @param dialogType  the dialog type (one of: {@link #OPEN_DIALOG},
+   * {@link #SAVE_DIALOG}, {@link #CUSTOM_DIALOG}).
+   * 
+   * @throws IllegalArgumentException if <code>dialogType</code> is not valid.
+   */
+  public void setDialogType(int dialogType)
+  {
+    if (dialogType != OPEN_DIALOG && dialogType != SAVE_DIALOG
+        && dialogType != CUSTOM_DIALOG)
+      throw new IllegalArgumentException("Choose allowable dialogType.");
+
+    if (this.dialogType != dialogType)
+      {
+	int old = this.dialogType;
+	this.dialogType = dialogType;
+	firePropertyChange(DIALOG_TYPE_CHANGED_PROPERTY, old, this.dialogType);
+      }
+  }
+
+  /**
+   * Sets the dialog title and sends a {@link PropertyChangeEvent} (with the 
+   * property name {@link #DIALOG_TITLE_CHANGED_PROPERTY}) to all 
+   * registered listeners.
+   *
+   * @param dialogTitle  the dialog title (<code>null</code> permitted).
+   * 
+   * @see #getDialogTitle()
+   */
+  public void setDialogTitle(String dialogTitle)
+  {
+    if (this.dialogTitle != dialogTitle)
+      {
+	String old = this.dialogTitle;
+	this.dialogTitle = dialogTitle;
+	firePropertyChange(DIALOG_TITLE_CHANGED_PROPERTY, old, this.dialogTitle);
+      }
+  }
+
+  /**
+   * Returns the dialog title.
+   *
+   * @return The dialog title (possibly <code>null</code>).
+   * 
+   * @see #setDialogTitle(String)
+   */
+  public String getDialogTitle()
+  {
+    return dialogTitle;
+  }
+
+  /**
+   * Sets the tool tip text for the approve button and sends a 
+   * {@link PropertyChangeEvent} (with the property name
+   * {@link #APPROVE_BUTTON_TOOL_TIP_TEXT_CHANGED_PROPERTY}) to all 
+   * registered listeners.
+   *
+   * @param toolTipText  the text.
+   */
+  public void setApproveButtonToolTipText(String toolTipText)
+  {
+    if (approveButtonToolTipText != toolTipText)
+      {
+	String oldText = approveButtonToolTipText;
+	approveButtonToolTipText = toolTipText;
+	firePropertyChange(APPROVE_BUTTON_TOOL_TIP_TEXT_CHANGED_PROPERTY,
+	                   oldText, approveButtonToolTipText);
+      }
+  }
+
+  /**
+   * Returns the tool tip text for the approve button.
+   *
+   * @return The tool tip text for the approve button.
+   * 
+   * @see #setApproveButtonToolTipText(String)
+   */
+  public String getApproveButtonToolTipText()
+  {
+    return approveButtonToolTipText;
+  }
+
+  /**
+   * Returns the approve button mnemonic, or zero if no mnemonic has been set.
+   *
+   * @return The approve button mnemonic.
+   * 
+   * @see #setApproveButtonMnemonic(int)
+   */
+  public int getApproveButtonMnemonic()
+  {
+    return approveButtonMnemonic;
+  }
+
+  /**
+   * Sets the mnemonic for the approve button and sends a 
+   * {@link PropertyChangeEvent} (with the property name 
+   * {@link #APPROVE_BUTTON_MNEMONIC_CHANGED_PROPERTY}) to all registered 
+   * listeners.
+   *
+   * @param mnemonic  the mnemonic.
+   * 
+   * @see #setApproveButtonMnemonic(char)
+   */
+  public void setApproveButtonMnemonic(int mnemonic)
+  {
+    if (approveButtonMnemonic != mnemonic)
+      {
+	int oldMnemonic = approveButtonMnemonic;
+	approveButtonMnemonic = mnemonic;
+	firePropertyChange(APPROVE_BUTTON_MNEMONIC_CHANGED_PROPERTY,
+	                   oldMnemonic, approveButtonMnemonic);
+      }
+  }
+
+  /**
+   * Sets the mnemonic for the approve button and sends a 
+   * {@link PropertyChangeEvent} (with the property name 
+   * {@link #APPROVE_BUTTON_MNEMONIC_CHANGED_PROPERTY}) to all registered 
+   * listeners.
+   *
+   * @param mnemonic  the mnemonic.
+   * 
+   * @see #setApproveButtonMnemonic(int)
+   */
+  public void setApproveButtonMnemonic(char mnemonic)
+  {
+    setApproveButtonMnemonic((int) Character.toUpperCase(mnemonic));
+  }
+
+  /**
+   * Sets the approve button text and fires a {@link PropertyChangeEvent} 
+   * (with the property name {@link #APPROVE_BUTTON_TEXT_CHANGED_PROPERTY}) to 
+   * all registered listeners.
+   *
+   * @param approveButtonText  the text (<code>null</code> permitted).
+   * 
+   * @see #getApproveButtonText()
+   */
+  public void setApproveButtonText(String approveButtonText)
+  {
+    if (this.approveButtonText != approveButtonText)
+      {
+	String oldText = this.approveButtonText;
+	this.approveButtonText = approveButtonText;
+	firePropertyChange(APPROVE_BUTTON_TEXT_CHANGED_PROPERTY, oldText,
+	                   this.approveButtonText);
+      }
+  }
+
+  /**
+   * Returns the approve button text.
+   *
+   * @return The approve button text (possibly <code>null</code>).
+   * 
+   * @see #setApproveButtonText(String)
+   */
+  public String getApproveButtonText()
+  {
+    return approveButtonText;
+  }
+
+  /**
+   * Returns the available file filters for this file chooser.
+   *
+   * @return The available file filters.
+   */
+  public FileFilter[] getChoosableFileFilters()
+  {
+    return (FileFilter[]) choosableFilters.toArray(new FileFilter[choosableFilters.size()]);
+  }
+
+  /**
+   * Adds a file filter to the list of available filters and sends a 
+   * {@link PropertyChangeEvent} (with the property name 
+   * {@link #CHOOSABLE_FILE_FILTER_CHANGED_PROPERTY}) to all registered 
+   * listeners.
+   *
+   * @param filter  the filter (<code>null</code> permitted).
+   */
+  public void addChoosableFileFilter(FileFilter filter)
+  {
+    if (filter != null)
+      {
+        FileFilter[] old = getChoosableFileFilters();
+        choosableFilters.add(filter);
+        FileFilter[] newFilters = getChoosableFileFilters();
+        firePropertyChange(CHOOSABLE_FILE_FILTER_CHANGED_PROPERTY, old, 
+              newFilters);
+      }
+    setFileFilter(filter);
+  }
+
+  /**
+   * Removes a file filter from the list of available filters and sends a 
+   * {@link PropertyChangeEvent} (with the property name 
+   * {@link #CHOOSABLE_FILE_FILTER_CHANGED_PROPERTY}) to all registered 
+   * listeners.
+   *
+   * @param f  the file filter.
+   *
+   * @return <code>true</code> if the filter was removed and 
+   *         <code>false</code> otherwise.
+   */
+  public boolean removeChoosableFileFilter(FileFilter f)
+  {
+    if (f == currentFilter)
+      setFileFilter(null);
+    FileFilter[] old = getChoosableFileFilters();
+    if (! choosableFilters.remove(f))
+      return false;
+    FileFilter[] newFilters = getChoosableFileFilters();
+    firePropertyChange(CHOOSABLE_FILE_FILTER_CHANGED_PROPERTY, old, newFilters);
+    return true;
+  }
+
+  /**
+   * Clears the list of choosable file filters and installs the 'accept all'
+   * filter from the UI delegate.
+   */
+  public void resetChoosableFileFilters()
+  {
+    choosableFilters.clear();
+    choosableFilters.add(getUI().getAcceptAllFileFilter(this));
+    setFileFilter((FileFilter) choosableFilters.get(0));
+  }
+
+  /**
+   * Returns the 'accept all' file filter from the UI delegate.
+   *
+   * @return The 'accept all' file filter.
+   */
+  public FileFilter getAcceptAllFileFilter()
+  {
+    return getUI().getAcceptAllFileFilter(this);
+  }
+
+  /**
+   * Returns the flag that controls whether or not the 'accept all' file 
+   * filter is included in the list of filters.
+   *
+   * @return A boolean.
+   * 
+   * @see #setAcceptAllFileFilterUsed(boolean)
+   */
+  public boolean isAcceptAllFileFilterUsed()
+  {
+    return isAcceptAll;
+  }
+
+  /**
+   * Sets the flag that controls whether or not the 'accept all' file filter
+   * is included in the list of filters, and sends a 
+   * {@link PropertyChangeEvent} (with the property name 
+   * {@link #ACCEPT_ALL_FILE_FILTER_USED_CHANGED_PROPERTY}) to all registered 
+   * listeners.
+   *
+   * @param b  the new value of the flag.
+   */
+  public void setAcceptAllFileFilterUsed(boolean b)
+  {
+    if (isAcceptAll != b)
+      {
+	isAcceptAll = b;
+        if (b)
+          addChoosableFileFilter(getAcceptAllFileFilter());
+        else 
+          removeChoosableFileFilter(getAcceptAllFileFilter());
+	firePropertyChange(ACCEPT_ALL_FILE_FILTER_USED_CHANGED_PROPERTY,
+	                   ! isAcceptAll, isAcceptAll);
+      }
+  }
+
+  /**
+   * Returns the accessory component for the file chooser.  The default
+   * value is <code>null</code>.
+   *
+   * @return The accessory component (possibly <code>null</code>).
+   * 
+   * @see #setAccessory(JComponent)
+   */
+  public JComponent getAccessory()
+  {
+    return accessory;
+  }
+
+  /**
+   * Sets the accessory component for the file chooser and sends a 
+   * {@link PropertyChangeEvent} to all registered listeners.  The property
+   * name is {@link #ACCESSORY_CHANGED_PROPERTY}.
+   *
+   * @param newAccessory  the accessory component.
+   */
+  public void setAccessory(JComponent newAccessory)
+  {
+    if (accessory != newAccessory)
+      {
+	JComponent old = accessory;
+	accessory = newAccessory;
+	firePropertyChange(ACCESSORY_CHANGED_PROPERTY, old, accessory);
+      }
+  }
+
+  /**
+   * Sets the file selection mode and sends a {@link PropertyChangeEvent}
+   * to all registered listeners.  The property name is 
+   * {@link #FILE_SELECTION_MODE_CHANGED_PROPERTY}.
+   *
+   * @param mode  the mode ({@link #FILES_ONLY}, {@link #DIRECTORIES_ONLY} or
+   *              {@link #FILES_AND_DIRECTORIES}).
+   * 
+   * @throws IllegalArgumentException if the mode is invalid.
+   */
+  public void setFileSelectionMode(int mode)
+  {
+    if (mode != FILES_ONLY && mode != DIRECTORIES_ONLY
+        && mode != FILES_AND_DIRECTORIES)
+      throw new IllegalArgumentException("Choose a correct file selection mode.");
+    if (fileSelectionMode != mode)
+      {
+	int old = fileSelectionMode;
+	fileSelectionMode = mode;
+	firePropertyChange(FILE_SELECTION_MODE_CHANGED_PROPERTY, old,
+	                   fileSelectionMode);
+      }
+  }
+
+  /**
+   * Returns the file selection mode, one of: {@link #FILES_ONLY}, 
+   * {@link #DIRECTORIES_ONLY} or {@link #FILES_AND_DIRECTORIES}.  The
+   * default is {@link #FILES_ONLY}.
+   *
+   * @return The file selection mode.
+   * 
+   * @see #setFileSelectionMode(int)
+   */
+  public int getFileSelectionMode()
+  {
+    return fileSelectionMode;
+  }
+
+  /**
+   * Returns <code>true</code> if file selection is enabled, and 
+   * <code>false</code> otherwise.  File selection is enabled when the
+   * file selection mode is {@link #FILES_ONLY} or 
+   * {@link #FILES_AND_DIRECTORIES}.
+   *
+   * @return <code>true</code> if file selection is enabled.
+   * 
+   * @see #getFileSelectionMode()
+   */
+  public boolean isFileSelectionEnabled()
+  {
+    return (fileSelectionMode == FILES_ONLY
+           || fileSelectionMode == FILES_AND_DIRECTORIES);
+  }
+
+  /**
+   * Returns <code>true</code> if directory selection is enabled, and 
+   * <code>false</code> otherwise.  Directory selection is enabled when the
+   * file selection mode is {@link #DIRECTORIES_ONLY} or 
+   * {@link #FILES_AND_DIRECTORIES}.
+   *
+   * @return <code>true</code> if file selection is enabled.
+   * 
+   * @see #getFileSelectionMode()
+   */
+  public boolean isDirectorySelectionEnabled()
+  {
+    return (fileSelectionMode == DIRECTORIES_ONLY
+           || fileSelectionMode == FILES_AND_DIRECTORIES);
+  }
+
+  /**
+   * Sets the flag that controls whether multiple selections are allowed in 
+   * this filechooser and sends a {@link PropertyChangeEvent} (with the 
+   * property name {@link #MULTI_SELECTION_ENABLED_CHANGED_PROPERTY}) to all 
+   * registered listeners.
+   *
+   * @param b  the new value of the flag.
+   */
+  public void setMultiSelectionEnabled(boolean b)
+  {
+    if (multiSelection != b)
+      {
+	multiSelection = b;
+	firePropertyChange(MULTI_SELECTION_ENABLED_CHANGED_PROPERTY,
+	                   ! multiSelection, multiSelection);
+      }
+  }
+
+  /**
+   * Returns <code>true</code> if multiple selections are allowed within this
+   * file chooser, and <code>false</code> otherwise.
+   *
+   * @return A boolean.
+   * 
+   * @see #setMultiSelectionEnabled(boolean)
+   */
+  public boolean isMultiSelectionEnabled()
+  {
+    return multiSelection;
+  }
+
+  /**
+   * Returns <code>true</code> if hidden files are to be hidden, and 
+   * <code>false</code> otherwise.
+   *
+   * @return A boolean.
+   * 
+   * @see #setFileHidingEnabled(boolean)
+   */
+  public boolean isFileHidingEnabled()
+  {
+    return fileHiding;
+  }
+
+  /**
+   * Sets the flag that controls whether or not hidden files are displayed,
+   * and sends a {@link PropertyChangeEvent} (with the property name
+   * {@link #FILE_HIDING_CHANGED_PROPERTY}) to all registered listeners.
+   *
+   * @param b  the new value of the flag.
+   */
+  public void setFileHidingEnabled(boolean b)
+  {
+    if (fileHiding != b)
+      {
+	fileHiding = b;
+	firePropertyChange(FILE_HIDING_CHANGED_PROPERTY, ! fileHiding,
+	                   fileHiding);
+      }
+  }
+
+  /**
+   * Sets the file filter and sends a {@link PropertyChangeEvent} (with the
+   * property name {@link #FILE_FILTER_CHANGED_PROPERTY}) to all registered 
+   * listeners.
+   *
+   * @param filter  the filter (<code>null</code> permitted).
+   */
+  public void setFileFilter(FileFilter filter)
+  {
+    if (currentFilter != filter)
+      {
+        if (filter != null && !choosableFilters.contains(filter))
+          addChoosableFileFilter(filter);
+        FileFilter old = currentFilter;
+        currentFilter = filter;
+        firePropertyChange(FILE_FILTER_CHANGED_PROPERTY, old, currentFilter);
+      }
+  }
+
+  /**
+   * Returns the file filter.
+   *
+   * @return The file filter.
+   * 
+   * @see #setFileFilter(FileFilter)
+   */
+  public FileFilter getFileFilter()
+  {
+    return currentFilter;
+  }
+
+  /**
+   * Sets a custom {@link FileView} for the file chooser and sends a 
+   * {@link PropertyChangeEvent} to all registered listeners.  The property
+   * name is {@link #FILE_VIEW_CHANGED_PROPERTY}.
+   *
+   * @param fileView  the file view (<code>null</code> permitted).
+   *
+   * @see #getFileView()
+   */
+  public void setFileView(FileView fileView)
+  {
+    if (fv != fileView)
+      {
+	FileView old = fv;
+	fv = fileView;
+	firePropertyChange(FILE_VIEW_CHANGED_PROPERTY, old, fv);
+      }
+  }
+
+  /**
+   * Returns the custom {@link FileView} for the file chooser.
+   *
+   * @return The file view (possibly <code>null</code>).
+   */
+  public FileView getFileView()
+  {
+    return fv;
+  }
+
+  /**
+   * Returns the name of the file, generated by the current (or default)
+   * {@link FileView}.
+   *
+   * @param f  the file.
+   *
+   * @return The file name.
+   */
+  public String getName(File f)
+  {
+    String name = null;
+    if (fv != null)
+      name = fv.getName(f);
+    if (name == null)
+      name = getUI().getFileView(this).getName(f);
+    return name;
+  }
+
+  /**
+   * Returns the description of the file, generated by the current (or default)
+   * {@link FileView}.
+   *
+   * @param f  the file.
+   *
+   * @return The file description.
+   */
+  public String getDescription(File f)
+  {
+    String result = null;
+    if (fv != null)
+      result = fv.getDescription(f);
+    if (result == null)
+      result = getUI().getFileView(this).getDescription(f);
+    return result;
+  }
+
+  /**
+   * Returns the type description for the file, generated by the current (or 
+   * default) {@link FileView}.
+   *
+   * @param f  the file.
+   *
+   * @return The file type description.
+   */
+  public String getTypeDescription(File f)
+  {
+    String result = null;
+    if (fv != null)
+      result = getFileView().getTypeDescription(f);
+    if (result == null)
+      result = getUI().getFileView(this).getTypeDescription(f);
+    return result;
+  }
+
+  /**
+   * Returns the icon provided by the current (or default) {@link FileView}.
+   *
+   * @param f  the file.
+   *
+   * @return An icon representing the file.
+   */
+  public Icon getIcon(File f)
+  {
+    Icon result = null;
+    if (fv != null)
+      result = fv.getIcon(f);
+    if (result == null)
+      result = getUI().getFileView(this).getIcon(f);
+    return result;
+  }
+
+  /**
+   * Returns <code>true</code> if the file is traversable, and 
+   * <code>false</code> otherwise.
+   *
+   * @param f  the file or directory.
+   *
+   * @return A boolean.
+   */
+  public boolean isTraversable(File f)
+  {
+    return getFileSystemView().isTraversable(f).booleanValue();
+  }
+
+  /**
+   * Returns <code>true</code> if the file is accepted by the current
+   * file filter.
+   *
+   * @param f  the file.
+   *
+   * @return A boolean.
+   */
+  public boolean accept(File f)
+  {
+    if (f == null)
+      return true;
+    FileFilter ff = getFileFilter();
+    if (ff != null) 
+      return ff.accept(f);
+    else
+      return true;
+  }
+
+  /**
+   * Sets the file system view for the file chooser and sends a 
+   * {@link PropertyChangeEvent} to all registered listeners.
+   *
+   * @param fsv  the file system view.
+   */
+  public void setFileSystemView(FileSystemView fsv)
+  {
+    if (this.fsv != fsv)
+      {
+	FileSystemView old = this.fsv;
+	this.fsv = fsv;
+	firePropertyChange(FILE_SYSTEM_VIEW_CHANGED_PROPERTY, old, this.fsv);
+      }
+  }
+
+  /**
+   * Returns the file system view being used by this file chooser.
+   *
+   * @return The file system view.
+   * 
+   * @see #setFileSystemView(FileSystemView)
+   */
+  public FileSystemView getFileSystemView()
+  {
+    return fsv;
+  }
+
+  /**
+   * Approves the selection.  An {@link ActionEvent} is sent to all registered
+   * listeners.
+   */
+  public void approveSelection()
+  {
+    retval = APPROVE_OPTION;
+    fireActionPerformed(APPROVE_SELECTION);
+  }
+
+  /**
+   * Cancels the selection. An {@link ActionEvent} is sent to all registered
+   * listeners.
+   */
+  public void cancelSelection()
+  {
+    retval = CANCEL_OPTION;
+    fireActionPerformed(CANCEL_SELECTION);
+  }
+
+  /**
+   * Adds an {@link ActionListener} to the file chooser.
+   *
+   * @param l  the listener.
+   */
+  public void addActionListener(ActionListener l)
+  {
+    listenerList.add(ActionListener.class, l);
+  }
+
+  /**
+   * Removes an {@link ActionListener} from this file chooser.
+   *
+   * @param l  the listener.
+   */
+  public void removeActionListener(ActionListener l)
+  {
+    try
+      {
+	listenerList.remove(ActionListener.class, l);
+      }
+    catch (IllegalArgumentException e)
+      {
+	e.printStackTrace();
+      }
+  }
+
+  /**
+   * Returns the action listeners registered with this file chooser.
+   *
+   * @return An array of listeners.
+   */
+  public ActionListener[] getActionListeners()
+  {
+    return (ActionListener[]) getListeners(ActionListener.class);
+  }
+
+  /**
+   * Sends an @link {ActionEvent} to all registered listeners.
+   *
+   * @param command  the action command.
+   */
+  protected void fireActionPerformed(String command)
+  {
+    ActionListener[] list = getActionListeners();
+    ActionEvent event = new ActionEvent(this, ActionEvent.ACTION_PERFORMED,
+                                        command);
+
+    for (int i = 0; i < list.length; i++)
+      list[i].actionPerformed(event);
+  }
+
+  /**
+   * Installs the UI delegate for the current look and feel.
+   */
+  public void updateUI()
+  {
+    setUI((FileChooserUI) UIManager.getUI(this));
+  }
+
+  /**
+   * Returns the UI delegate class identifier.
+   *
+   * @return <code>FileChooserUI</code>.
+   */
+  public String getUIClassID()
+  {
+    return "FileChooserUI";
+  }
+
+  /**
+   * Returns the UI delegate for the component.
+   *
+   * @return The UI delegate.
+   */
+  public FileChooserUI getUI()
+  {
+    return (FileChooserUI) ui;
+  }
+
+  /**
+   * Returns a string describing the attributes for the 
+   * <code>JFileChooser</code> component, for use in debugging.  The return 
+   * value is guaranteed to be non-<code>null</code>, but the format of the 
+   * string may vary between implementations.
+   *
+   * @return A string describing the attributes of the 
+   *     <code>JFileChooser</code>.
+   */
+  protected String paramString()
+  {
+    StringBuffer sb = new StringBuffer(super.paramString());
+    sb.append(",approveButtonText=");
+    if (approveButtonText != null)
+      sb.append(approveButtonText);
+    sb.append(",currentDirectory=");
+    if (currentDir != null)
+      sb.append(currentDir);
+    sb.append(",dialogTitle=");
+    if (dialogTitle != null)
+      sb.append(dialogTitle);
+    sb.append(",dialogType=");
+    if (dialogType == OPEN_DIALOG)
+      sb.append("OPEN_DIALOG");
+    if (dialogType == SAVE_DIALOG)
+      sb.append("SAVE_DIALOG");
+    if (dialogType == CUSTOM_DIALOG)
+      sb.append("CUSTOM_DIALOG");
+    sb.append(",fileSelectionMode=");
+    if (fileSelectionMode == FILES_ONLY)
+      sb.append("FILES_ONLY");
+    if (fileSelectionMode == DIRECTORIES_ONLY)
+      sb.append("DIRECTORIES_ONLY");
+    if (fileSelectionMode == FILES_AND_DIRECTORIES)
+      sb.append("FILES_AND_DIRECTORIES");
+    sb.append(",returnValue=");
+    if (retval == APPROVE_OPTION)
+      sb.append("APPROVE_OPTION");
+    if (retval == CANCEL_OPTION)
+      sb.append("CANCEL_OPTION");
+    if (retval == ERROR_OPTION)
+      sb.append("ERROR_OPTION");
+    sb.append(",selectedFile=");
+    if (selectedFile != null)
+      sb.append(selectedFile);
+    sb.append(",useFileHiding=").append(fileHiding);
+    return sb.toString();
+  }
+
+  /**
+   * Returns the object that provides accessibility features for this
+   * <code>JFileChooser</code> component.
+   *
+   * @return The accessible context (an instance of 
+   *     {@link AccessibleJFileChooser}).
+   */
+  public AccessibleContext getAccessibleContext()
+  {
+    if (accessibleContext == null)
+      accessibleContext = new AccessibleJFileChooser();
+    return accessibleContext;
+  }
+
+  /**
+   * Provides the accessibility features for the <code>JFileChooser</code>
+   * component.
+   */
+  protected class AccessibleJFileChooser 
+    extends JComponent.AccessibleJComponent
+  {
+    /**
+     * Creates a new instance of <code>AccessibleJFileChooser</code>.
+     */
+    protected AccessibleJFileChooser()
+    {
+      // Nothing to do here.
+    }
+    
+    /**
+     * Returns the accessible role for the <code>JFileChooser</code> 
+     * component.
+     *
+     * @return {@link AccessibleRole#FILE_CHOOSER}.
+     */
+    public AccessibleRole getAccessibleRole()
+    {
+      return AccessibleRole.FILE_CHOOSER;
+    }
+  }
+}

Added: llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JFormattedTextField.java
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JFormattedTextField.java?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JFormattedTextField.java (added)
+++ llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JFormattedTextField.java Thu Nov  8 16:56:19 2007
@@ -0,0 +1,648 @@
+/* JFormattedTextField.java --
+   Copyright (C) 2003, 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., 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;
+
+import java.awt.event.FocusEvent;
+import java.io.Serializable;
+import java.text.DateFormat;
+import java.text.Format;
+import java.text.NumberFormat;
+import java.text.ParseException;
+import java.util.Date;
+
+import javax.swing.text.AbstractDocument;
+import javax.swing.text.DateFormatter;
+import javax.swing.text.DefaultFormatter;
+import javax.swing.text.DefaultFormatterFactory;
+import javax.swing.text.Document;
+import javax.swing.text.DocumentFilter;
+import javax.swing.text.InternationalFormatter;
+import javax.swing.text.NavigationFilter;
+import javax.swing.text.NumberFormatter;
+
+/**
+ * A text field that makes use of a formatter to display and edit a specific
+ * type of data. The value that is displayed can be an arbitrary object. The
+ * formatter is responsible for displaying the value in a textual form and
+ * it may allow editing of the value.
+ *
+ * Formatters are usually obtained using an instance of
+ * {@link AbstractFormatterFactory}. This factory is responsible for providing
+ * an instance of {@link AbstractFormatter} that is able to handle the
+ * formatting of the value of the JFormattedTextField.
+ *
+ * @author Michael Koch
+ * @author Anthony Balkissoon abalkiss at redhat dot com
+ *
+ * @since 1.4
+ */
+public class JFormattedTextField extends JTextField
+{
+  private static final long serialVersionUID = 5464657870110180632L;
+
+  /**
+   * An abstract base implementation for a formatter that can be used by
+   * a JTextField. A formatter can display a specific type of object and
+   * may provide a way to edit this value.
+   */
+  public abstract static class AbstractFormatter implements Serializable
+  {
+    private static final long serialVersionUID = -5193212041738979680L;
+    
+    private JFormattedTextField textField;
+    
+    public AbstractFormatter ()
+    {
+      //Do nothing here.
+    }
+
+    /**
+     * Clones the AbstractFormatter and removes the association to any 
+     * particular JFormattedTextField.
+     * 
+     * @return a clone of this formatter with no association to any particular
+     * JFormattedTextField
+     * @throws CloneNotSupportedException if the Object's class doesn't support
+     * the {@link Cloneable} interface
+     */
+    protected Object clone()
+      throws CloneNotSupportedException
+    {
+      // Clone this formatter.
+      AbstractFormatter newFormatter = (AbstractFormatter) super.clone();
+      
+      // And remove the association to the JFormattedTextField.
+      newFormatter.textField = null;
+      return newFormatter;
+    }
+
+    /**
+     * Returns a custom set of Actions that this formatter supports.  Should
+     * be subclassed by formatters that have a custom set of Actions.
+     * 
+     * @return <code>null</code>.  Should be subclassed by formatters that want
+     * to install custom Actions on the JFormattedTextField.
+     */
+    protected Action[] getActions()
+    {
+      return null;
+    }
+
+    /**
+     * Gets the DocumentFilter for this formatter.  Should be subclassed
+     * by formatters wishing to install a filter that oversees Document
+     * mutations.
+     * 
+     * @return <code>null</code>.  Should be subclassed by formatters
+     * that want to restrict Document mutations.
+     */
+    protected DocumentFilter getDocumentFilter()
+    {
+      // Subclasses should override this if they want to install a 
+      // DocumentFilter.
+      return null;
+    }
+
+    /**
+     * Returns the JFormattedTextField on which this formatter is
+     * currently installed.
+     * 
+     * @return the JFormattedTextField on which this formatter is currently
+     * installed
+     */
+    protected JFormattedTextField getFormattedTextField()
+    {
+      return textField;
+    }
+
+    /**
+     * Gets the NavigationFilter for this formatter.  Should be subclassed
+     * by formatters (such as {@link DefaultFormatter}) that wish to 
+     * restrict where the cursor can be placed within the text field.
+     * 
+     * @return <code>null</code>.  Subclassed by formatters that want to restrict
+     * cursor location within the JFormattedTextField.
+     */
+    protected NavigationFilter getNavigationFilter()
+    {
+      // This should be subclassed if the formatter wants to install 
+      // a NavigationFilter on the JFormattedTextField.
+      return null;
+    }
+
+    /**
+     * Installs this formatter on the specified JFormattedTextField.  This 
+     * converts the current value to a displayable String and displays it, 
+     * and installs formatter specific Actions from <code>getActions</code>.
+     * It also installs a DocumentFilter and NavigationFilter on the 
+     * JFormattedTextField.  
+     * <p>
+     * If there is a <code>ParseException</code> this sets the text to an 
+     * empty String and marks the text field in an invalid state.
+     * 
+     * @param textField the JFormattedTextField on which to install this
+     * formatter
+     */
+    public void install(JFormattedTextField textField)
+    {
+      // Uninstall the current textfield.
+      if (this.textField != null)
+        uninstall();
+      
+      this.textField = textField;
+      
+      // Install some state on the text field, including display text, 
+      // DocumentFilter, NavigationFilter, and formatter specific Actions.
+      if (textField != null)
+        {
+          try
+          {
+            // Set the text of the field.
+            textField.setText(valueToString(textField.getValue()));
+            Document doc = textField.getDocument();
+            
+            // Set the DocumentFilter for the field's Document.
+            if (doc instanceof AbstractDocument)
+              ((AbstractDocument) doc).setDocumentFilter(getDocumentFilter());
+            
+            // Set the NavigationFilter.
+            textField.setNavigationFilter(getNavigationFilter());
+            
+            // Set the Formatter Actions
+            // FIXME: Have to add the actions from getActions()            
+          }
+          catch (ParseException pe)
+          {
+            // Set the text to an empty String and mark the field as invalid.
+            textField.setText("");
+            setEditValid(false);
+          }
+        }
+    }
+
+    /**
+     * Clears the state installed on the JFormattedTextField by the formatter.
+     * This resets the DocumentFilter, NavigationFilter, and any additional 
+     * Actions (returned by <code>getActions()</code>).     
+     */
+    public void uninstall()
+    {
+      // Set the DocumentFilter for the field's Document.
+      Document doc = textField.getDocument();
+      if (doc instanceof AbstractDocument)
+        ((AbstractDocument) doc).setDocumentFilter(null);
+      textField.setNavigationFilter(null);
+      // FIXME: Have to remove the Actions from getActions()
+      this.textField = null;
+    }
+
+    /**
+     * Invoke this method when invalid values are entered.  This forwards the
+     * call to the JFormattedTextField.     
+     */
+    protected void invalidEdit()
+    {
+      textField.invalidEdit();
+    }
+
+    /**
+     * This method updates the <code>editValid</code> property of 
+     * JFormattedTextField.
+     * 
+     * @param valid the new state for the <code>editValid</code> property
+     */
+    protected void setEditValid(boolean valid)
+    {
+      textField.editValid = valid;
+    }
+
+    /**
+     * Parses <code>text</code> to return a corresponding Object.
+     * 
+     * @param text the String to parse
+     * @return an Object that <code>text</code> represented
+     * @throws ParseException if there is an error in the conversion
+     */
+    public abstract Object stringToValue(String text)
+      throws ParseException;
+
+    /**
+     * Returns a String to be displayed, based on the Object
+     * <code>value</code>.
+     * 
+     * @param value the Object from which to generate a String
+     * @return a String to be displayed
+     * @throws ParseException if there is an error in the conversion
+     */
+    public abstract String valueToString(Object value)
+      throws ParseException;
+  }
+
+  /**
+   * Delivers instances of an {@link AbstractFormatter} for
+   * a specific value type for a JFormattedTextField. 
+   */
+  public abstract static class AbstractFormatterFactory
+  {
+    public AbstractFormatterFactory()
+    {
+      // Do nothing here.
+    }
+
+    public abstract AbstractFormatter getFormatter(JFormattedTextField tf);
+  }
+
+  /** The possible focusLostBehavior options **/
+  public static final int COMMIT = 0;
+  public static final int COMMIT_OR_REVERT = 1;
+  public static final int REVERT = 2;
+  public static final int PERSIST = 3;
+
+  /** The most recent valid and committed value **/
+  private Object value;
+  
+  /** The behaviour for when this text field loses focus **/
+  private int focusLostBehavior = COMMIT_OR_REVERT;
+  
+  /** The formatter factory currently being used **/
+  private AbstractFormatterFactory formatterFactory;
+  
+  /** The formatter currently being used **/
+  private AbstractFormatter formatter;
+  
+  // Package-private to avoid an accessor method.
+  boolean editValid = true;
+  
+  /**
+   * Creates a JFormattedTextField with no formatter factory.  
+   * <code>setValue</code> or <code>setFormatterFactory</code> will 
+   * properly configure this text field to edit a particular type
+   * of value.
+   */
+  public JFormattedTextField()
+  {
+    this((AbstractFormatterFactory) null, null);
+  }
+
+  /**
+   * Creates a JFormattedTextField that can handle the specified Format.  
+   * An appopriate AbstractFormatter and AbstractFormatterFactory will 
+   * be created for the specified Format.
+   * 
+   * @param format the Format that this JFormattedTextField should be able
+   * to handle
+   */
+  public JFormattedTextField(Format format)
+  {
+    this ();
+    setFormatterFactory(getAppropriateFormatterFactory(format));
+  }
+
+  /**
+   * Creates a JFormattedTextField with the specified formatter.  This will 
+   * create a {@link DefaultFormatterFactory} with this formatter as the default
+   * formatter.
+   * 
+   * @param formatter the formatter to use for this JFormattedTextField
+   */
+  public JFormattedTextField(AbstractFormatter formatter)
+  {
+    this(new DefaultFormatterFactory(formatter));
+  }
+
+  /**
+   * Creates a JFormattedTextField with the specified formatter factory.
+   * 
+   * @param factory the formatter factory to use for this JFormattedTextField
+   */
+  public JFormattedTextField(AbstractFormatterFactory factory)
+  {
+    setFormatterFactory(factory);
+  }
+
+  /**
+   * Creates a JFormattedTextField with the specified formatter factory and
+   * initial value.
+   * 
+   * @param factory the initial formatter factory for this JFormattedTextField
+   * @param value the initial value for the text field
+   */
+  public JFormattedTextField(AbstractFormatterFactory factory, Object value)
+  {    
+    setFormatterFactory(factory);
+    setValue(value);
+  }
+
+  /**
+   * Creates a JFormattedTextField with the specified value.  This creates a
+   * formatter and formatterFactory that are appropriate for the value.
+   * 
+   * @param value the initial value for this JFormattedTextField
+   */
+  public JFormattedTextField(Object value)
+  {
+    setValue(value);
+  }
+  
+  /**
+   * Returns an AbstractFormatterFactory that will give an appropriate
+   * AbstractFormatter for the given Format.
+   * @param format the Format to match with an AbstractFormatter.
+   * @return a DefaultFormatterFactory whose defaultFormatter is appropriate
+   * for the given Format.
+   */
+  private AbstractFormatterFactory getAppropriateFormatterFactory(Format format)
+  {
+    AbstractFormatter newFormatter;
+    if (format instanceof DateFormat)
+      newFormatter = new DateFormatter((DateFormat) format);
+    else if (format instanceof NumberFormat)
+      newFormatter = new NumberFormatter ((NumberFormat) format);
+    else
+      newFormatter = new InternationalFormatter(format);
+    
+    return new DefaultFormatterFactory(newFormatter);
+  }
+
+  /**
+   * Forces the current value from the editor to be set as the current
+   * value.  If there is no current formatted this has no effect.
+   * 
+   * @throws ParseException if the formatter cannot format the current value
+   */
+  public void commitEdit()
+    throws ParseException
+  {
+    if (formatter == null)
+      return;
+    // Note: this code is a lot like setValue except that we don't want
+    // to create a new formatter.
+    Object oldValue = this.value;
+    
+    this.value = formatter.stringToValue(getText());;
+    editValid = true;
+    
+    firePropertyChange("value", oldValue, this.value); 
+  }
+
+  /**
+   * Gets the command list supplied by the UI augmented by the specific
+   * Actions for JFormattedTextField.
+   * 
+   * @return an array of Actions that this text field supports
+   */
+  public Action[] getActions()
+  {
+    // FIXME: Add JFormattedTextField specific actions
+    // These are related to committing or cancelling edits.
+    return super.getActions();
+  }
+
+  /**
+   * Returns the behaviour of this JFormattedTextField upon losing focus.  This
+   * is one of <code>COMMIT</code>, <code>COMMIT_OR_REVERT</code>, 
+   * <code>PERSIST</code>, or <code>REVERT</code>.  
+   * @return the behaviour upon losing focus
+   */
+  public int getFocusLostBehavior()
+  {
+    return focusLostBehavior;
+  }
+
+  /**
+   * Returns the current formatter used for this JFormattedTextField.
+   * @return the current formatter used for this JFormattedTextField
+   */
+  public AbstractFormatter getFormatter()
+  {
+    return formatter;
+  }
+  
+  /**
+   * Returns the factory currently used to generate formatters for this
+   * JFormattedTextField.
+   * @return the factory currently used to generate formatters
+   */
+  public AbstractFormatterFactory getFormatterFactory()
+  {
+    return formatterFactory;
+  }
+
+  public String getUIClassID()
+  {
+    return "FormattedTextFieldUI";
+  }
+
+  /**
+   * Returns the last valid value.  This may not be the value currently shown 
+   * in the text field depending on whether or not the formatter commits on 
+   * valid edits and allows invalid input to be temporarily displayed.  
+   * @return the last committed valid value
+   */
+  public Object getValue()
+  {
+    return value;
+  }
+
+  /**
+   * This method is used to provide feedback to the user when an invalid value
+   * is input during editing.   
+   */
+  protected void invalidEdit()
+  {
+    UIManager.getLookAndFeel().provideErrorFeedback(this);
+  }
+
+  /**
+   * Returns true if the current value being edited is valid.  This property is
+   * managed by the current formatted.
+   * @return true if the value being edited is valid.
+   */
+  public boolean isEditValid()
+  {
+    return editValid;
+  }
+
+  /**
+   * Processes focus events.  This is overridden because we may want to 
+   * change the formatted depending on whether or not this field has 
+   * focus.
+   * 
+   * @param evt the FocusEvent
+   */
+  protected void processFocusEvent(FocusEvent evt)
+  {
+    super.processFocusEvent(evt);
+    // Let the formatterFactory change the formatter for this text field
+    // based on whether or not it has focus.
+    setFormatter (formatterFactory.getFormatter(this));
+  }
+  
+  /**
+   * Associates this JFormattedTextField with a Document and propagates
+   * a PropertyChange event to each listener.
+   * 
+   * @param newDocument the Document to associate with this text field
+   */
+  public void setDocument(Document newDocument)
+  {
+    // FIXME: This method should do more than this.  Must do some handling
+    // of the DocumentListeners.
+    Document oldDocument = getDocument();
+
+    if (oldDocument == newDocument)
+      return;
+    
+    super.setDocument(newDocument);
+  }
+
+  /**
+   * Sets the behaviour of this JFormattedTextField upon losing focus.
+   * This must be <code>COMMIT</code>, <code>COMMIT_OR_REVERT</code>, 
+   * <code>PERSIST</code>, or <code>REVERT</code> or an 
+   * IllegalArgumentException will be thrown.
+   * 
+   * @param behavior
+   * @throws IllegalArgumentException if <code>behaviour</code> is not 
+   * one of the above
+   */
+  public void setFocusLostBehavior(int behavior)
+  {
+    if (behavior != COMMIT
+	&& behavior != COMMIT_OR_REVERT
+	&& behavior != PERSIST
+	&& behavior != REVERT)
+      throw new IllegalArgumentException("invalid behavior");
+
+    this.focusLostBehavior = behavior;
+  }
+
+  /**
+   * Sets the formatter for this JFormattedTextField.  Normally the formatter
+   * factory will take care of this, or calls to setValue will also make sure
+   * that the formatter is set appropriately.  
+   * 
+   * @param formatter the AbstractFormatter to use for formatting the value for
+   * this JFormattedTextField
+   */
+  protected void setFormatter(AbstractFormatter formatter)
+  {
+    AbstractFormatter oldFormatter = null;
+    
+    oldFormatter = this.formatter;
+
+    if (oldFormatter != null)
+      oldFormatter.uninstall();
+    
+    this.formatter = formatter;
+    
+    if (formatter != null)
+      formatter.install(this);
+
+    firePropertyChange("formatter", oldFormatter, formatter);
+  }
+
+  /**
+   * Sets the factory from which this JFormattedTextField should obtain 
+   * its formatters.  
+   * 
+   * @param factory the AbstractFormatterFactory that will be used to generate
+   * formatters for this JFormattedTextField
+   */
+  public void setFormatterFactory(AbstractFormatterFactory factory)
+  {
+    if (formatterFactory == factory)
+      return;
+    
+    AbstractFormatterFactory oldFactory = formatterFactory;
+    formatterFactory = factory;
+    firePropertyChange("formatterFactory", oldFactory, factory);
+    
+    // Now set the formatter according to our new factory.
+    if (formatterFactory != null)
+      setFormatter(formatterFactory.getFormatter(this));
+    else
+      setFormatter(null);
+  }
+
+  /**
+   * Sets the value that will be formatted and displayed.
+   *   
+   * @param newValue the value to be formatted and displayed
+   */
+  public void setValue(Object newValue)
+  {
+    if (value == newValue)
+      return;
+
+    Object oldValue = value;
+    value = newValue;
+    
+    // If there is no formatterFactory then make one.
+    if (formatterFactory == null)
+      setFormatterFactory(createFormatterFactory(newValue));
+    
+    // Set the formatter appropriately.  This is because there may be a new
+    // formatterFactory from the line above, or we may want a new formatter
+    // depending on the type of newValue (or if newValue is null).
+    setFormatter (formatterFactory.getFormatter(this));
+    firePropertyChange("value", oldValue, newValue);
+  }
+
+  /**
+   * A helper method that attempts to create a formatter factory that is 
+   * suitable to format objects of the type like <code>value</code>.
+   *
+   * @param value an object which should be formatted by the formatter factory.
+   *
+   * @return a formatter factory able to format objects of the class of
+   *     <code>value</code>
+   */
+  AbstractFormatterFactory createFormatterFactory(Object value)
+  {
+    AbstractFormatter formatter = null;
+    if (value instanceof Date)
+      formatter = new DateFormatter();
+    else if (value instanceof Number)
+      formatter = new NumberFormatter();
+    else
+      formatter = new DefaultFormatter();        
+    return new DefaultFormatterFactory(formatter);
+  }
+}

Added: llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JFrame.java
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JFrame.java?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JFrame.java (added)
+++ llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JFrame.java Thu Nov  8 16:56:19 2007
@@ -0,0 +1,421 @@
+/* JFrame.java --
+   Copyright (C) 2002, 2004, 2005, 2006,  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;
+
+import java.awt.AWTEvent;
+import java.awt.BorderLayout;
+import java.awt.Component;
+import java.awt.Container;
+import java.awt.Dimension;
+import java.awt.Frame;
+import java.awt.Graphics;
+import java.awt.GraphicsConfiguration;
+import java.awt.LayoutManager;
+import java.awt.event.KeyEvent;
+import java.awt.event.WindowEvent;
+
+import javax.accessibility.Accessible;
+import javax.accessibility.AccessibleContext;
+
+/**
+ * A window that supports window decorations (titlebar and borders).
+ * This is an extension of {@link java.awt.Frame} that provides support
+ * for the Swing architecture. Most importantly it contains a {@link JRootPane}
+ * as it's only top-level child, that manages the content pane, the menu and
+ * a glass pane.
+ *
+ * Also, unlike <code>java.awt.Frame</code>s, JFrames support the
+ * Swing Pluggable Look & Feel architecture.
+ * 
+ * @author Ronald Veldema (rveldema at cs.vu.nl)
+ */
+public class JFrame extends Frame
+  implements WindowConstants, RootPaneContainer, Accessible
+{
+  /**
+   * Provides accessibility support for <code>JFrame</code>s.
+   */
+  protected class AccessibleJFrame extends Frame.AccessibleAWTFrame
+  {
+    /**
+     * Creates a new instance of <code>AccessibleJFrame</code>.
+     */
+    protected AccessibleJFrame()
+    {
+      super();
+      // Nothing to do here.
+    }
+  }
+
+  /**
+   * A flag for {@link #setDefaultCloseOperation(int)}, indicating that the
+   * application should be exited, when this <code>JFrame</code> is closed.
+   * Note that in version 1.4, the equivalent constant has been added to
+   * {@link WindowConstants}.
+   *
+   * @since 1.3
+   */
+  public static final int EXIT_ON_CLOSE = 3;
+
+  private static final long serialVersionUID = -3362141868504252139L;
+  private static boolean defaultLookAndFeelDecorated;
+  private int closeAction = HIDE_ON_CLOSE;
+  protected AccessibleContext accessibleContext;
+  protected JRootPane rootPane;
+  
+  /**
+   * @specnote rootPaneCheckingEnabled is false to comply with J2SE 5.0
+   */
+  protected boolean rootPaneCheckingEnabled = false;
+
+  /**
+   * Creates a new frame with an empty string for the title.
+   */
+  public JFrame()
+  {
+    super("");
+    frameInit();
+  }
+
+  /**
+   * Creates a new <code>JFrame</code> with the specified title.
+   * 
+   * @param title  the frame title (<code>null</code> permitted).
+   */
+  public JFrame(String title)
+  {
+    super(title);
+    frameInit();
+  }
+
+  /**
+   * Creates a new JFrame in the specified {@link GraphicsConfiguration}
+   * and with an empty title.
+   *
+   * @param gc the <code>GraphicsConfiguration</code> that is used for
+   *     the new <code>JFrame</code>
+   *
+   * @see Frame#Frame(GraphicsConfiguration)
+   */
+  public JFrame(GraphicsConfiguration gc)
+  {
+    super(gc);
+    frameInit();
+  }
+
+  /**
+   * Creates a new JFrame in the specified {@link GraphicsConfiguration}
+   * and with the specified title.
+   *
+   * @param title the title for the new <code>JFrame</code>
+   * @param gc the <code>GraphicsConfiguration</code> that is used for
+   *     the new <code>JFrame</code>
+   *
+   * @see Frame#Frame(String, GraphicsConfiguration)
+   */
+  public JFrame(String title, GraphicsConfiguration gc)
+  {
+    super(title, gc);
+    frameInit();
+  }
+
+  protected void frameInit()
+  {
+    super.setLayout(new BorderLayout());
+    setBackground(UIManager.getDefaults().getColor("control"));
+    enableEvents(AWTEvent.WINDOW_EVENT_MASK);
+    getRootPane(); // will do set/create
+
+    // Setup the defaultLookAndFeelDecoration if requested.
+    if (isDefaultLookAndFeelDecorated()
+        && UIManager.getLookAndFeel().getSupportsWindowDecorations())
+      {
+        setUndecorated(true);
+        getRootPane().setWindowDecorationStyle(JRootPane.FRAME);
+      }
+
+    // We're now done the init stage.
+    setRootPaneCheckingEnabled(true);
+  }
+
+  public Dimension getPreferredSize()
+  {
+    return super.getPreferredSize();
+  }
+
+  public JMenuBar getJMenuBar()
+  {
+    return getRootPane().getJMenuBar();
+  }
+
+  public void setJMenuBar(JMenuBar menubar)
+  {
+    getRootPane().setJMenuBar(menubar);
+  }
+
+  public void setLayout(LayoutManager manager)
+  {
+    // Check if we're in initialization stage.  If so, call super.setLayout
+    // otherwise, valid calls go to the content pane.
+    if (isRootPaneCheckingEnabled())
+      getContentPane().setLayout(manager);
+    else
+      super.setLayout(manager);
+  }
+
+  public void setLayeredPane(JLayeredPane layeredPane)
+  {
+    getRootPane().setLayeredPane(layeredPane);
+  }
+
+  public JLayeredPane getLayeredPane()
+  {
+    return getRootPane().getLayeredPane();
+  }
+
+  public JRootPane getRootPane()
+  {
+    if (rootPane == null)
+      setRootPane(createRootPane());
+    return rootPane;
+  }
+
+  protected void setRootPane(JRootPane root)
+  {
+    if (rootPane != null)
+      remove(rootPane);
+
+    rootPane = root;
+    add(rootPane, BorderLayout.CENTER);
+  }
+
+  protected JRootPane createRootPane()
+  {
+    return new JRootPane();
+  }
+
+  public Container getContentPane()
+  {
+    return getRootPane().getContentPane();
+  }
+
+  public void setContentPane(Container contentPane)
+  {
+    getRootPane().setContentPane(contentPane);
+  }
+
+  public Component getGlassPane()
+  {
+    return getRootPane().getGlassPane();
+  }
+
+  public void setGlassPane(Component glassPane)
+  {
+    getRootPane().setGlassPane(glassPane);
+  }
+
+  protected void addImpl(Component comp, Object constraints, int index)
+  {
+    // If we're adding in the initialization stage use super.add.
+    // Otherwise pass the add onto the content pane.
+    if (isRootPaneCheckingEnabled())
+      getContentPane().add(comp,constraints,index);
+    else
+      super.addImpl(comp, constraints, index);
+  }
+
+  public void remove(Component comp)
+  {
+    // If we're removing the root pane, use super.remove. Otherwise
+    // pass it on to the content pane instead.
+    if (comp==rootPane)
+      super.remove(rootPane);
+    else
+      getContentPane().remove(comp);
+  }
+
+  protected boolean isRootPaneCheckingEnabled()
+  {
+    return rootPaneCheckingEnabled;
+  }
+
+  protected void setRootPaneCheckingEnabled(boolean enabled)
+  {
+    rootPaneCheckingEnabled = enabled;
+  }
+
+  public void update(Graphics g)
+  {
+    paint(g);
+  }
+
+  protected void processKeyEvent(KeyEvent e)
+  {
+    super.processKeyEvent(e);
+  }
+
+  public static void setDefaultLookAndFeelDecorated(boolean decorated)
+  {
+    defaultLookAndFeelDecorated = decorated;
+  }
+
+  public static boolean isDefaultLookAndFeelDecorated()
+  {
+    return defaultLookAndFeelDecorated;
+  }
+
+  /**
+   * Returns the object that provides accessibility features for this 
+   * <code>JFrame</code>.
+   *
+   * @return The accessible context (an instance of {@link AccessibleJFrame}).
+   */
+  public AccessibleContext getAccessibleContext()
+  {
+    if (accessibleContext == null)
+      accessibleContext = new AccessibleJFrame();
+    return accessibleContext;
+  }
+
+  /**
+   * Returns a code for the default operation when the frame is closed.  The
+   * default value is {@link WindowConstants#HIDE_ON_CLOSE}.
+   * 
+   * @return One of: {@link WindowConstants#DO_NOTHING_ON_CLOSE},
+   *     {@link WindowConstants#HIDE_ON_CLOSE}, 
+   *     {@link WindowConstants#DISPOSE_ON_CLOSE}, {@link #EXIT_ON_CLOSE}.
+   * 
+   * @see #setDefaultCloseOperation(int)
+   */
+  public int getDefaultCloseOperation()
+  {
+    return closeAction;
+  }
+
+  /**
+   * Returns a string describing the attributes for the <code>JFrame</code>,
+   * for use in debugging.  The return value is guaranteed to be 
+   * non-<code>null</code>, but the format may vary between implementations.
+   * 
+   * @return A string describing the attributes of the <code>JFrame</code>.
+   */
+  protected String paramString()
+  {
+    StringBuffer sb = new StringBuffer(super.paramString());
+    sb.append(",defaultCloseOperation=");
+    sb.append(SwingUtilities.convertWindowConstantToString(
+        getDefaultCloseOperation()));
+    sb.append(",rootPane=");
+    if (rootPane != null)
+      sb.append(rootPane);
+    sb.append(",rootPaneCheckingEnabled=").append(rootPaneCheckingEnabled);
+    return sb.toString();
+  }
+
+  protected void processWindowEvent(WindowEvent e)
+  {
+    super.processWindowEvent(e);
+    switch (e.getID())
+      {
+      case WindowEvent.WINDOW_CLOSING:
+        {
+	  switch (closeAction)
+	    {
+	    case EXIT_ON_CLOSE:
+	      {
+		System.exit(0);
+		break;
+	      }
+	    case DISPOSE_ON_CLOSE:
+	      {
+		dispose();
+		break;
+	      }
+	    case HIDE_ON_CLOSE:
+	      {
+		setVisible(false);
+		break;
+	      }
+	    case DO_NOTHING_ON_CLOSE:
+	      break;
+	    }
+	  break;
+        }
+      case WindowEvent.WINDOW_CLOSED:
+      case WindowEvent.WINDOW_OPENED:
+      case WindowEvent.WINDOW_ICONIFIED:
+      case WindowEvent.WINDOW_DEICONIFIED:
+      case WindowEvent.WINDOW_ACTIVATED:
+      case WindowEvent.WINDOW_DEACTIVATED:
+	break;
+      }
+  }
+
+  /**
+   * Sets the default operation that is performed when this frame is closed.
+   * The default is <code>HIDE_ON_CLOSE</code>.  When 
+   * <code>EXIT_ON_CLOSE</code> is specified this method calls
+   * <code>SecurityManager.checkExit(0)</code> which might throw a
+   * <code>SecurityException</code>.
+   * 
+   * @param operation  a code for the operation (one of: 
+   *     {@link WindowConstants#DO_NOTHING_ON_CLOSE}, 
+   *     {@link WindowConstants#HIDE_ON_CLOSE}, 
+   *     {@link WindowConstants#DISPOSE_ON_CLOSE} and 
+   *     {@link WindowConstants#EXIT_ON_CLOSE}).
+   * 
+   * @throws IllegalArgumentException if <code>operation</code> is not one of
+   *     the specified codes.
+   * 
+   * @see #getDefaultCloseOperation()
+   */
+  public void setDefaultCloseOperation(int operation)
+  {
+    SecurityManager sm = System.getSecurityManager();
+    if (sm != null && operation == EXIT_ON_CLOSE)
+      sm.checkExit(0);
+
+    if (operation != EXIT_ON_CLOSE && operation != DISPOSE_ON_CLOSE
+        && operation != HIDE_ON_CLOSE && operation != DO_NOTHING_ON_CLOSE)
+      throw new IllegalArgumentException("operation must be EXIT_ON_CLOSE, " 
+          + "HIDE_ON_CLOSE, DISPOSE_ON_CLOSE, or DO_NOTHING_ON_CLOSE");
+
+    closeAction = operation;
+  }
+}

Added: llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JInternalFrame.java
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JInternalFrame.java?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JInternalFrame.java (added)
+++ llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JInternalFrame.java Thu Nov  8 16:56:19 2007
@@ -0,0 +1,1820 @@
+/* JInternalFrame.java --
+   Copyright (C) 2002, 2004, 2005, 2006,  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;
+
+import java.awt.BorderLayout;
+import java.awt.Component;
+import java.awt.Container;
+import java.awt.Graphics;
+import java.awt.IllegalComponentStateException;
+import java.awt.KeyboardFocusManager;
+import java.awt.LayoutManager;
+import java.awt.Rectangle;
+import java.beans.PropertyChangeEvent;
+import java.beans.PropertyVetoException;
+
+import javax.accessibility.Accessible;
+import javax.accessibility.AccessibleContext;
+import javax.accessibility.AccessibleRole;
+import javax.accessibility.AccessibleValue;
+import javax.swing.event.InternalFrameEvent;
+import javax.swing.event.InternalFrameListener;
+import javax.swing.plaf.DesktopIconUI;
+import javax.swing.plaf.InternalFrameUI;
+
+/**
+ * This class implements a Swing widget that looks and acts like a native
+ * frame. The frame can be dragged, resized, closed, etc. Typically,
+ * JInternalFrames are placed in JDesktopPanes. The actions that the
+ * JInternalFrame performs (maximizing, minimizing, etc.) are performed by a
+ * DesktopManager. As with regular frames, components are added by calling
+ * frame.getContentPane().add.
+ */
+public class JInternalFrame extends JComponent implements Accessible,
+                                                          WindowConstants,
+                                                          RootPaneContainer
+{
+
+  private static final long serialVersionUID = -5425177187760785402L;
+
+  /**
+   * Provides the accessibility features for the <code>JInternalFrame</code>
+   * component.
+   */
+  protected class AccessibleJInternalFrame extends AccessibleJComponent
+    implements AccessibleValue
+  {
+    private static final long serialVersionUID = 5931936924175476797L;
+
+    /**
+     * Creates a new <code>AccessibleJInternalFrame</code> instance.
+     */
+    protected AccessibleJInternalFrame()
+    {
+      super();
+    }
+
+    /**
+     * Returns the frame title.
+     *
+     * @return The frame title.
+     */
+    public String getAccessibleName()
+    {
+      return getTitle();
+    }
+
+    /**
+     * Returns the accessible role for the <code>JInternalFrame</code> 
+     * component.
+     *
+     * @return {@link AccessibleRole#INTERNAL_FRAME}.
+     */
+    public AccessibleRole getAccessibleRole()
+    {
+      return AccessibleRole.INTERNAL_FRAME;
+    }
+
+    /**
+     * Returns an object that provides access to the current, minimum and 
+     * maximum values for the {@link JInternalFrame}.  Since this class 
+     * implements {@link AccessibleValue}, it returns itself.
+     *
+     * @return The accessible value.
+     */
+    public AccessibleValue getAccessibleValue()
+    {
+      return this;
+    }
+
+    /**
+     * Returns the current layer for the {@link JInternalFrame} component, 
+     * as an {@link Integer}.
+     *
+     * @return The layer for the {@link JInternalFrame} component.
+     */
+    public Number getCurrentAccessibleValue()
+    {
+      return new Integer(getLayer());
+    }
+
+    /**
+     * Returns the maximum permitted accessible value.
+     *
+     * @return <code>Integer(Integer.MAX_VALUE)</code>.
+     */
+    public Number getMaximumAccessibleValue()
+    {
+      return new Integer(Integer.MAX_VALUE);
+    }
+
+    /**
+     * Returns the minimum permitted accessible value.
+     *
+     * @return <code>Integer(Integer.MIN_VALUE)</code>.
+     */
+    public Number getMinimumAccessibleValue()
+    {
+      return new Integer(Integer.MIN_VALUE);
+    }
+
+    /**
+     * Sets the layer for the internal frame.
+     *
+     * @param n  the layer (see the constants defined in {@link JLayeredPane}).
+     *
+     * @return <code>true</code> if the value is set, and <code>false</code>
+     *         if it was not set.
+     */
+    public boolean setCurrentAccessibleValue(Number n)
+    {
+      if (n == null)
+        return false;
+      setLayer(n.intValue());
+      return true;
+    }
+  }
+
+  /**
+   * This class represents the JInternalFrame while it is iconified.
+   */
+  public static class JDesktopIcon extends JComponent implements Accessible
+  {
+    /**
+     * Provides the accessibility features for the <code>JDesktopIcon</code>
+     * component.
+     */
+    protected class AccessibleJDesktopIcon extends AccessibleJComponent
+      implements AccessibleValue
+    {
+      private static final long serialVersionUID = 5035560458941637802L;
+
+      /**
+       * Creates a new <code>AccessibleJDesktopIcon</code> instance.
+       */
+      protected AccessibleJDesktopIcon()
+      {
+        super();
+      }
+
+      /**
+       * Returns the accessible role for the <code>JDesktopIcon</code> 
+       * component.
+       *
+       * @return {@link AccessibleRole#DESKTOP_ICON}.
+       */
+      public AccessibleRole getAccessibleRole()
+      {
+        return AccessibleRole.DESKTOP_ICON;
+      }
+
+      /**
+       * Returns an object that provides access to the current, minimum and 
+       * maximum values for the {@link JDesktopIcon}.  Since this class 
+       * implements {@link AccessibleValue}, it returns itself.
+       *
+       * @return The accessible value.
+       */
+      public AccessibleValue getAccessibleValue()
+      {
+        return this;
+      }
+
+      /**
+       * Returns the current layer for the {@link JInternalFrame} component
+       * represented by this <code>JDesktopIcon</code>, as an {@link Integer}.
+       *
+       * @return The layer.
+       */
+      public Number getCurrentAccessibleValue()
+      {
+        return new Integer(frame.getLayer());
+      }
+
+      /**
+       * Returns the maximum permitted accessible value.
+       *
+       * @return <code>Integer(Integer.MAX_VALUE)</code>.
+       */
+      public Number getMaximumAccessibleValue()
+      {
+        return new Integer(Integer.MAX_VALUE);
+      }
+
+      /**
+       * Returns the minimum permitted accessible value.
+       *
+       * @return <code>Integer(Integer.MIN_VALUE)</code>.
+       */
+      public Number getMinimumAccessibleValue()
+      {
+        return new Integer(Integer.MIN_VALUE);
+      }
+
+      /**
+       * Sets the layer for the internal frame represented by this 
+       * <code>JDesktopIcon</code> component.
+       *
+       * @param n  the layer (see the constants defined in 
+       *           {@link JLayeredPane}).
+       *
+       * @return <code>true</code> if the value is set, and <code>false</code>
+       *         if it was not set.
+       */
+      public boolean setCurrentAccessibleValue(Number n)
+      {
+        if (n == null)
+          return false;
+        frame.setLayer(n.intValue());
+        return true;
+      }
+    }
+
+    private static final long serialVersionUID = 4672973344731387687L;
+
+    /** The JInternalFrame this DesktopIcon represents. */
+    JInternalFrame frame;
+
+    /**
+     * Creates a new JDesktopIcon object for representing the given frame.
+     *
+     * @param f The JInternalFrame to represent.
+     */
+    public JDesktopIcon(JInternalFrame f)
+    {
+      frame = f;
+      updateUI();
+    }
+
+  /**
+   * Returns the object that provides accessibility features for this
+   * <code>JDesktopIcon</code> component.
+   *
+   * @return The accessible context (an instance of 
+   *         {@link AccessibleJDesktopIcon}).
+   */
+    public AccessibleContext getAccessibleContext()
+    {
+      if (accessibleContext == null)
+        accessibleContext = new AccessibleJDesktopIcon();
+      return accessibleContext;
+    }
+
+    /**
+     * This method returns the JDesktopPane this JDesktopIcon is in.
+     *
+     * @return The JDesktopPane this JDesktopIcon is in.
+     */
+    public JDesktopPane getDesktopPane()
+    {
+      JDesktopPane p = (JDesktopPane) SwingUtilities.getAncestorOfClass(JDesktopPane.class,
+                                                                        this);
+      return p;
+    }
+
+    /**
+     * This method returns the JInternalFrame this JDesktopIcon represents.
+     *
+     * @return The JInternalFrame this JDesktopIcon represents.
+     */
+    public JInternalFrame getInternalFrame()
+    {
+      return frame;
+    }
+
+    /**
+     * This method returns the UI that is responsible for the JDesktopIcon.
+     *
+     * @return The UI that is responsible for the JDesktopIcon.
+     */
+    public DesktopIconUI getUI()
+    {
+      return (DesktopIconUI) ui;
+    }
+
+    /**
+     * This method returns the String identifier that is used to determine
+     * which class is used for JDesktopIcon's UI.
+     *
+     * @return A String identifier for the UI class.
+     */
+    public String getUIClassID()
+    {
+      return "DesktopIconUI";
+    }
+
+    /**
+     * This method sets the JInternalFrame that this JDesktopIcon represents.
+     *
+     * @param f The JInternalFrame that this JDesktopIcon represents.
+     */
+    public void setInternalFrame(JInternalFrame f)
+    {
+      frame = f;
+    }
+
+    /**
+     * This method sets the UI used for this JDesktopIcon.
+     *
+     * @param ui The UI to use.
+     */
+    public void setUI(DesktopIconUI ui)
+    {
+      super.setUI(ui);
+    }
+
+    /**
+     * This method restores the UI property to the defaults.
+     */
+    public void updateUI()
+    {
+      setUI((DesktopIconUI) UIManager.getUI(this));
+    }
+  }
+
+  /**
+   * The property fired in a PropertyChangeEvent when the contentPane property
+   * changes.
+   */
+  public static final String CONTENT_PANE_PROPERTY = "contentPane";
+
+  /**
+   * The property fired in a PropertyChangeEvent when the frameIcon property
+   * changes.
+   */
+  public static final String FRAME_ICON_PROPERTY = "frameIcon";
+
+  /**
+   * The property fired in a PropertyChangeEvent when the glassPane property
+   * changes.
+   */
+  public static final String GLASS_PANE_PROPERTY = "glassPane";
+
+  /**
+   * The property fired in a PropertyChangeEvent when the closed property
+   * changes.
+   */
+  public static final String IS_CLOSED_PROPERTY = "closed";
+
+  /**
+   * The property fired in a PropertyChangeEvent when the icon property
+   * changes.
+   */
+  public static final String IS_ICON_PROPERTY = "icon";
+
+  /**
+   * The property fired in a PropertyChangeEvent when the maximum property
+   * changes.
+   */
+  public static final String IS_MAXIMUM_PROPERTY = "maximum";
+
+  /**
+   * The property fired in a PropertyChangeEvent when the selected property
+   * changes.
+   */
+  public static final String IS_SELECTED_PROPERTY = "selected";
+
+  /**
+   * The property fired in a PropertyChangeEvent when the layeredPane property
+   * changes.
+   */
+  public static final String LAYERED_PANE_PROPERTY = "layeredPane";
+
+  /**
+   * The property fired in a PropertyChangeEvent when the jMenuBar property
+   * changes.
+   */
+  public static final String MENU_BAR_PROPERTY = "JMenuBar";
+
+  /**
+   * The property fired in a PropertyChangeEvent when the rootPane property
+   * changes.
+   */
+  public static final String ROOT_PANE_PROPERTY = "rootPane";
+
+  /**
+   * The property fired in a PropertyChangeEvent when the title property
+   * changes.
+   */
+  public static final String TITLE_PROPERTY = "title";
+
+  /** Whether the JInternalFrame is closable. */
+  protected boolean closable;
+
+  /** Whether the JInternalFrame can be iconified. */
+  protected boolean iconable;
+
+  /** Whether the JInternalFrame is closed. */
+  protected boolean isClosed;
+
+  /** Whether the JInternalFrame has been iconified. */
+  protected boolean isIcon;
+
+  /** Whether the JInternalFrame has been maximized. */
+  protected boolean isMaximum;
+
+  /** Whether the JInternalFrame is the active frame. */
+  protected boolean isSelected;
+
+  /** Whether the JInternalFrame can be maximized. */
+  protected boolean maximizable;
+
+  /**
+   * Whether the JInternalFrame has rootPaneChecking enabled.
+   *
+   * @specnote Should be false to comply with J2SE 5.0
+   */
+  protected boolean rootPaneCheckingEnabled = false;
+
+  /** Whether the JInternalFrame is resizable. */
+  protected boolean resizable;
+
+  /**
+   * The JDesktopIcon that represents the JInternalFrame while it is
+   * iconified.
+   */
+  protected JDesktopIcon desktopIcon;
+
+  /** The icon used in the JMenuBar in the TitlePane. */
+  protected Icon frameIcon;
+
+  /** The rootPane of the JInternalFrame. */
+  protected JRootPane rootPane;
+
+  /** The title on the TitlePane of the JInternalFrame. */
+  protected String title;
+
+  /** The bounds of the JInternalFrame before it was maximized. */
+  private transient Rectangle storedBounds;
+
+  /** The Component that receives focus by default. */
+  private transient Component defaultFocus;
+
+  /** The default close action taken, */
+  private transient int defaultCloseOperation = DISPOSE_ON_CLOSE;
+
+  /** Whether the JInternalFrame has become visible for the very first time. */
+  private transient boolean isFirstTimeVisible = true;
+
+  /** DOCUMENT ME! */
+  private transient boolean wasIcon = false;
+
+  /**
+   * Creates a new JInternalFrame object that has an empty string for its 
+   * title, and is non-resizable, non-maximizable, non-iconifiable, and 
+   * non-closable.
+   */
+  public JInternalFrame()
+  {
+    this("", false, false, false, false);
+  }
+
+  /**
+   * Creates a new JInternalFrame object with the given title and is
+   * non-resizable, non-maximizable, non-iconifiable, and non-closable.
+   *
+   * @param title The title displayed in the JInternalFrame.
+   */
+  public JInternalFrame(String title)
+  {
+    this(title, false, false, false, false);
+  }
+
+  /**
+   * Creates a new JInternalFrame object with the given title and resizable
+   * properties. The JInternalFrame is non-maximizable, non-iconifiable, and
+   * non-closable.
+   *
+   * @param title The title displayed in the JInternalFrame.
+   * @param resizable Whether the JInternalFrame is resizable.
+   */
+  public JInternalFrame(String title, boolean resizable)
+  {
+    this(title, resizable, false, false, false);
+  }
+
+  /**
+   * Creates a new JInternalFrame object with the given title, resizable, and
+   * closable properties. The JInternalFrame is non-maximizable and
+   * non-iconifiable.
+   *
+   * @param title The title displayed in the JInternalFrame.
+   * @param resizable Whether the JInternalFrame is resizable.
+   * @param closable Whether the JInternalFrame is closable.
+   */
+  public JInternalFrame(String title, boolean resizable, boolean closable)
+  {
+    this(title, resizable, closable, false, false);
+  }
+
+  /**
+   * Creates a new JInternalFrame object with the given title, resizable,
+   * closable and maximizable properties. The JInternalFrame is
+   * non-iconifiable.
+   *
+   * @param title The title displayed in the JInternalFrame.
+   * @param resizable Whether the JInternalFrame is resizable.
+   * @param closable Whether the JInternalFrame is closable.
+   * @param maximizable Whether the JInternalFrame is maximizable.
+   */
+  public JInternalFrame(String title, boolean resizable, boolean closable,
+                        boolean maximizable)
+  {
+    this(title, resizable, closable, maximizable, false);
+  }
+
+  /**
+   * Creates a new JInternalFrame object with the given title, resizable,
+   * closable, maximizable and iconifiable properties.
+   *
+   * @param title The title displayed in the JInternalFrame.
+   * @param resizable Whether the JInternalFrame is resizable.
+   * @param closable Whether the JInternalFrame is closable.
+   * @param maximizable Whether the JInternalFrame is maximizable.
+   * @param iconifiable Whether the JInternalFrame is iconifiable.
+   */
+  public JInternalFrame(String title, boolean resizable, boolean closable,
+                        boolean maximizable, boolean iconifiable)
+  {
+    this.title = title;
+    this.resizable = resizable;
+    this.closable = closable;
+    this.maximizable = maximizable;
+    this.iconable = iconifiable;
+    isMaximum = false;
+    setRootPane(createRootPane());
+    // JInternalFrames are invisible and opaque by default.
+    setVisible(false);
+    setOpaque(true);
+    desktopIcon = new JDesktopIcon(this);
+    updateUI();
+    setRootPaneCheckingEnabled(true); // Done the init stage, now adds go to content pane.
+  }
+
+  /**
+   * This method adds Components to this Container. For JInternalFrames,
+   * instead of calling add directly on the JInternalFrame, it should be
+   * called with JInternalFrame.getContentPane().add. If root pane checking
+   * is enabled, calling this method will cause an exception to be thrown.
+   *
+   * @param comp The Component to add.
+   * @param constraints The constraints on the Component added.
+   * @param index The position to place the Component.
+   *
+   * @throws Error DOCUMENT ME!
+   */
+  protected void addImpl(Component comp, Object constraints, int index)
+  {
+    // If we're in the initialization stage use super.add. Here we add the
+    // rootPane as well as the title bar and other stuff.
+    // Otherwise pass the add onto the content pane.
+    if (isRootPaneCheckingEnabled())
+      getContentPane().add(comp, constraints, index);
+    else
+      super.addImpl(comp,constraints, index);
+  }
+
+  /**
+   * This method adds an InternalFrameListener to this JInternalFrame.
+   *
+   * @param l The listener to add.
+   */
+  public void addInternalFrameListener(InternalFrameListener l)
+  {
+    listenerList.add(InternalFrameListener.class, l);
+  }
+
+  /**
+   * This method is used to create a root pane for the JInternalFrame. This
+   * method is called by the constructors.
+   *
+   * @return A root pane for the JInternalFrame to use.
+   */
+  protected JRootPane createRootPane()
+  {
+    return new JRootPane();
+  }
+
+  /**
+   * This method makes this JInternalFrame invisible, unselected and closed.
+   * If this JInternalFrame is not closed already, it will fire an
+   * INTERNAL_FRAME_CLoSED event. This method is similar to setClosed but it
+   * doesn't give vetoable listeners a chance to veto and it will not fire an
+   * INTERNAL_FRAME_CLOSING event.
+   */
+  public void dispose()
+  {
+    if (isVisible())
+      setVisible(false);
+    if (isSelected())
+      {
+        try
+          {
+            setSelected(false);
+          }
+        catch (PropertyVetoException e)
+          {
+            // Do nothing if they don't want to be unselected.
+          }
+      }
+    if (! isClosed)
+      {
+        firePropertyChange(IS_CLOSED_PROPERTY, Boolean.FALSE, Boolean.TRUE);
+        isClosed = true;
+      }
+    fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_CLOSED);
+  }
+
+  /**
+   * This method is used for closing this JInternalFrame. It fires an
+   * INTERNAL_FRAME_CLOSING event and then performs the action specified by
+   * the default close operation.
+   */
+  public void doDefaultCloseAction()
+  {
+    fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_CLOSING);
+    switch (getDefaultCloseOperation())
+      {
+      case HIDE_ON_CLOSE:
+	    setVisible(false);
+	    break;
+      case DISPOSE_ON_CLOSE:
+	    dispose();
+	    break;
+      }
+  }
+
+  /**
+   * This method fires an InternalFrameEvent to the listeners.
+   *
+   * @param id The type of event being fired. See InternalFrameEvent.
+   */
+  protected void fireInternalFrameEvent(int id)
+  {
+    Object[] ifListeners = listenerList.getListenerList();
+    InternalFrameEvent evt = new InternalFrameEvent(this, id);
+    switch (id)
+      {
+      case InternalFrameEvent.INTERNAL_FRAME_CLOSING:
+	for (int i = ifListeners.length - 2; i >= 0; i -= 2)
+	  {
+	    if (ifListeners[i] == InternalFrameListener.class)
+	      ((InternalFrameListener) ifListeners[i + 1])
+	      .internalFrameClosing(evt);
+	  }
+	break;
+      case InternalFrameEvent.INTERNAL_FRAME_ACTIVATED:
+	for (int i = ifListeners.length - 2; i >= 0; i -= 2)
+	  {
+	    if (ifListeners[i] == InternalFrameListener.class)
+	      ((InternalFrameListener) ifListeners[i + 1])
+	      .internalFrameActivated(evt);
+	  }
+	break;
+      case InternalFrameEvent.INTERNAL_FRAME_CLOSED:
+	for (int i = ifListeners.length - 2; i >= 0; i -= 2)
+	  {
+	    if (ifListeners[i] == InternalFrameListener.class)
+	      ((InternalFrameListener) ifListeners[i + 1]).internalFrameClosed(evt);
+	  }
+	break;
+      case InternalFrameEvent.INTERNAL_FRAME_DEACTIVATED:
+	for (int i = ifListeners.length - 2; i >= 0; i -= 2)
+	  {
+	    if (ifListeners[i] == InternalFrameListener.class)
+	      ((InternalFrameListener) ifListeners[i + 1])
+	      .internalFrameDeactivated(evt);
+	  }
+	break;
+      case InternalFrameEvent.INTERNAL_FRAME_DEICONIFIED:
+	for (int i = ifListeners.length - 2; i >= 0; i -= 2)
+	  {
+	    if (ifListeners[i] == InternalFrameListener.class)
+	      ((InternalFrameListener) ifListeners[i + 1])
+	      .internalFrameDeiconified(evt);
+	  }
+	break;
+      case InternalFrameEvent.INTERNAL_FRAME_ICONIFIED:
+	for (int i = ifListeners.length - 2; i >= 0; i -= 2)
+	  {
+	    if (ifListeners[i] == InternalFrameListener.class)
+	      ((InternalFrameListener) ifListeners[i + 1])
+	      .internalFrameIconified(evt);
+	  }
+	break;
+      case InternalFrameEvent.INTERNAL_FRAME_OPENED:
+	for (int i = ifListeners.length - 2; i >= 0; i -= 2)
+	  {
+	    if (ifListeners[i] == InternalFrameListener.class)
+	      ((InternalFrameListener) ifListeners[i + 1]).internalFrameOpened(evt);
+	  }
+	break;
+      }
+  }
+
+  /**
+   * Returns the object that provides accessibility features for this
+   * <code>JInternalFrame</code> component.
+   *
+   * @return The accessible context (an instance of 
+   *     {@link AccessibleJInternalFrame}).
+   */
+  public AccessibleContext getAccessibleContext()
+  {
+    if (accessibleContext == null)
+      accessibleContext = new AccessibleJInternalFrame();
+    return accessibleContext;
+  }
+
+  /**
+   * This method returns the Content Pane for this JInternalFrame.
+   *
+   * @return The Content Pane for this JInternalFrame.
+   */
+  public Container getContentPane()
+  {
+    return getRootPane().getContentPane();
+  }
+
+  /**
+   * Returns a code for the default action taken when this 
+   * <code>JInternalFrame</code> is closed.
+   *
+   * @return The action code (usually one of 
+   *     {@link WindowConstants#DO_NOTHING_ON_CLOSE}, 
+   *     {@link WindowConstants#HIDE_ON_CLOSE}, or 
+   *     {@link WindowConstants#DISPOSE_ON_CLOSE}).
+   * 
+   * @see #setDefaultCloseOperation(int)
+   * @see #doDefaultCloseAction()
+   */
+  public int getDefaultCloseOperation()
+  {
+    return defaultCloseOperation;
+  }
+
+  /**
+   * Returns the <code>JDesktopIcon</code> that represents this 
+   * <code>JInternalFrame</code> while it is iconified.
+   *
+   * @return The desktop icon component.
+   */
+  public JDesktopIcon getDesktopIcon()
+  {
+    return desktopIcon;
+  }
+
+  /**
+   * This method searches this JInternalFrame ancestors for an instance of
+   * JDesktopPane. If one is found, it is returned. If none is found, then it
+   * will search the JDesktopIcon for a JDesktopPane.
+   *
+   * @return The JDesktopPane that this JInternalFrame belongs to.
+   */
+  public JDesktopPane getDesktopPane()
+  {
+    JDesktopPane value = (JDesktopPane) SwingUtilities.getAncestorOfClass(JDesktopPane.class,
+                                                                          this);
+    if (value == null && desktopIcon != null)
+      value = desktopIcon.getDesktopPane();
+    return value;
+  }
+
+  /**
+   * This method returns null because this must always be the root of a focus
+   * traversal.
+   *
+   * @return always null
+   *
+   * @since 1.4
+   */
+  public final Container getFocusCycleRootAncestor()
+  {
+    // as defined.
+    return null;
+  }
+
+  /**
+   * This method returns the child Component that will receive focus if this
+   * JInternalFrame is selected.
+   *
+   * @return The child Component that will receive focus.
+   */
+  public Component getFocusOwner()
+  {
+    if (isSelected())
+      {
+	Component focus = KeyboardFocusManager.getCurrentKeyboardFocusManager().getFocusOwner();
+	if (SwingUtilities.isDescendingFrom(focus, this))
+	  {
+	    defaultFocus = focus;
+	    return focus;
+	  }
+      }
+    return null;
+  }
+
+  /**
+   * This method returns the Frame Icon (the icon used in the JInternalFrame
+   * TitlePane and iconified frame).
+   *
+   * @return The Frame Icon.
+   */
+  public Icon getFrameIcon()
+  {
+    return frameIcon;
+  }
+
+  /**
+   * This method returns the Glass Pane used with this JInternalFrame.
+   *
+   * @return The Glass Pane used with this JInternalFrame.
+   */
+  public Component getGlassPane()
+  {
+    return getRootPane().getGlassPane();
+  }
+
+  /**
+   * This method returns an array of InternalFrameListeners that are listening
+   * to this JInternalFrame.
+   *
+   * @return An array of InternalFrameListeners that are listening to this
+   *         JInternalFrame.
+   */
+  public InternalFrameListener[] getInternalFrameListeners()
+  {
+    return (InternalFrameListener[]) listenerList.getListeners(InternalFrameListener.class);
+  }
+
+  /**
+   * This method returns the JMenuBar for this JInternalFrame.
+   *
+   * @return The JMenuBar for this JInternalFrame.
+   */
+  public JMenuBar getJMenuBar()
+  {
+    return getRootPane().getJMenuBar();
+  }
+
+  /**
+   * This method returns the layer that this JInternalFrame resides in.
+   *
+   * @return The layer that this JInternalFrame resides in.
+   */
+  public int getLayer()
+  {
+    return JLayeredPane.getLayer(this);
+  }
+
+  /**
+   * This method returns the LayeredPane for this JInternalFrame.
+   *
+   * @return The LayeredPane for this JInternalFrame.
+   */
+  public JLayeredPane getLayeredPane()
+  {
+    return getRootPane().getLayeredPane();
+  }
+
+  /**
+   * This method is deprecated. This method returns the JMenuBar for this
+   * JInternalFrame.
+   *
+   * @return The JMenuBar for this JInternalFrame.
+   *
+   * @deprecated 1.0.3
+   */
+  public JMenuBar getMenuBar()
+  {
+    return getJMenuBar();
+  }
+
+  /**
+   * This method returns the child Component that will receive focus when the
+   * JInternalFrame is selected. If the JInternalFrame is selected, this
+   * method returns getFocusOwner(). Otherwise, it will return the child
+   * Component that most recently requested focus. If that is null, then the
+   * initial focus Component is returned. If that is null, then the default
+   * focus component is returned.
+   *
+   * @return The most recent focus owner.
+   */
+  public Component getMostRecentFocusOwner()
+  {
+    if (isSelected())
+      return getFocusOwner();
+    else
+      return defaultFocus;
+  }
+
+  /**
+   * This method returns the bounds of the JInternalFrame if it is not
+   * maximized. If it is maximized, it returns the bounds of the
+   * JInternalFrame before it was maximized (the bounds that it will be
+   * restored to).
+   *
+   * @return A Rectangle that contains this JInternalFrame's normal bounds (or
+   *         just its bounds if it is not maximized).
+   */
+  public Rectangle getNormalBounds()
+  {
+    if (storedBounds == null)
+      return getBounds();
+    else
+      return storedBounds;
+  }
+
+  /**
+   * This method returns the Root Pane for this JInternalFrame.
+   *
+   * @return The Root Pane for this JInternalFrame.
+   */
+  public JRootPane getRootPane()
+  {
+    return rootPane;
+  }
+
+  /**
+   * Returns the frame's title.
+   *
+   * @return The frame's title (can be <code>null</code>).
+   * 
+   * @see #setTitle(String)
+   */
+  public String getTitle()
+  {
+    return title;
+  }
+
+  /**
+   * This method returns the UI used to represent the JInternalFrame.
+   *
+   * @return The UI used to represent the JInternalFrame.
+   */
+  public InternalFrameUI getUI()
+  {
+    return (InternalFrameUI) ui;
+  }
+
+  /**
+   * This method returns a String identifier that is used to determine which
+   * class acts as the JInternalFrame's UI.
+   *
+   * @return A String identifier to determine a UI class.
+   */
+  public String getUIClassID()
+  {
+    return "InternalFrameUI";
+  }
+
+  /**
+   * This method returns null.
+   *
+   * @return null.
+   */
+  public final String getWarningString()
+  {
+    // as defined.
+    return null;
+  }
+
+  /**
+   * This method deselects this JInternalFrame and hides it.
+   */
+  public void hide()
+  {
+    if (isIcon())
+      getDesktopIcon().hide();
+    super.hide();
+  }
+
+  /**
+   * This method returns whether this JInternalFrame is closable.
+   *
+   * @return Whether this JInternalFrame is closable.
+   */
+  public boolean isClosable()
+  {
+    return closable;
+  }
+
+  /**
+   * This method returns whether this JInternalFrame has been closed.
+   *
+   * @return Whether this JInternalFrame is closed.
+   */
+  public boolean isClosed()
+  {
+    return isClosed;
+  }
+
+  /**
+   * This must always return true.
+   *
+   * @return always true
+   *
+   * @since 1.4
+   */
+  public final boolean isFocusCycleRoot()
+  {
+    return true;
+  }
+
+  /**
+   * This method returns whether this JInternalFrame is currently iconified.
+   *
+   * @return Whether this JInternalFrame is currently iconified.
+   */
+  public boolean isIcon()
+  {
+    return isIcon;
+  }
+
+  /**
+   * This method returns whether the JInternalFrame can be iconified.
+   *
+   * @return Whether the JInternalFrame can be iconified.
+   */
+  public boolean isIconifiable()
+  {
+    return iconable;
+  }
+
+  /**
+   * This method returns whether this JInternalFrame can be maximized.
+   *
+   * @return Whether this JInternalFrame can be maximized.
+   */
+  public boolean isMaximizable()
+  {
+    return maximizable;
+  }
+
+  /**
+   * This method returns whether this JInternalFrame is currently maximized.
+   *
+   * @return Whether this JInternalFrame is maximized.
+   */
+  public boolean isMaximum()
+  {
+    return isMaximum;
+  }
+
+  /**
+   * This method returns whether this JInternalFrame is resizable.
+   *
+   * @return Whether this JInternalFrame is resizable.
+   */
+  public boolean isResizable()
+  {
+    return resizable;
+  }
+
+  /**
+   * This method returns whether root pane checking is enabled. If root pane
+   * checking is enabled, then calls to addImpl and setLayout will throw
+   * exceptions.
+   *
+   * @return Whether root pane checking is enabled.
+   */
+  protected boolean isRootPaneCheckingEnabled()
+  {
+    return rootPaneCheckingEnabled;
+  }
+
+  /**
+   * This method returns whether this JInternalFrame is selected.
+   *
+   * @return Whether this JInternalFrame is selected.
+   */
+  public boolean isSelected()
+  {
+    return isSelected;
+  }
+
+  /**
+   * A helper method that moves this JInternalFrame to the back if the parent
+   * is a JLayeredPane.
+   */
+  public void moveToBack()
+  {
+    Container p = getParent();
+    if (p instanceof JLayeredPane)
+      ((JLayeredPane) p).moveToBack(this);
+  }
+
+  /**
+   * A helper method that moves this JInternalFrame to the front if the parent
+   * is a JLayeredPane.
+   */
+  public void moveToFront()
+  {
+    Container p = getParent();
+    if (p != null && p instanceof JLayeredPane)
+      ((JLayeredPane) p).moveToFront(this);
+  }
+
+  /**
+   * This method causes the children of this JInternalFrame to be laid out.
+   * Before it begins, if this JInternalFrame is an icon, then it will be
+   * deiconified. If it is maximized, then it will be restored. If either
+   * operation fails, then this method will return.
+   */
+  public void pack()
+  {
+    try
+      {
+	if (isIcon())
+	  setIcon(false);
+	else if (isMaximum())
+	  setMaximum(false);
+      }
+    catch (PropertyVetoException e)
+      {
+	// Do nothing if they don't want to be restored first.
+      }
+    setSize(getPreferredSize());
+    validate();
+  }
+
+  /**
+   * This method is overridden to allow for speedier painting while this
+   * JInternalFramme is being dragged.
+   *
+   * @param g The Graphics object to paint with.
+   */
+  protected void paintComponent(Graphics g)
+  {
+    super.paintComponent(g);
+  }
+
+  /**
+   * An implementation dependent string describing the current state of this 
+   * <code>JInternalFrame</code> instance.
+   *
+   * @return A string describing the current state of this 
+   *     <code>JInternalFrame</code> instance.
+   */
+  protected String paramString()
+  {
+    return super.paramString() + ",title=" + getTitle();
+  }
+
+  /**
+   * This method removes the given Component from the Container.
+   *
+   * @param comp The Component to remove.
+   */
+  public void remove(Component comp)
+  {
+    // If we're removing the root pane, use super.remove.  Otherwise
+    // pass it on to the content pane instead.
+    if (comp==rootPane || ! isRootPaneCheckingEnabled())
+      super.remove(comp);
+    else
+      getContentPane().remove(comp);
+  }
+
+  /**
+   * This method removes an InternalFrameListener from this JInternalFrame.
+   *
+   * @param l The listener to remove.
+   */
+  public void removeInternalFrameListener(InternalFrameListener l)
+  {
+    listenerList.remove(InternalFrameListener.class, l);
+  }
+
+  /**
+   * This method resizes and positions this JInternalFrame. It also forces a
+   * relayout of the Container.
+   *
+   * @param x The x position of this JInternalFrame.
+   * @param y The y position of this JInternalFrame.
+   * @param width The width of this JInternalFrame.
+   * @param height The height of this JInternalFrame.
+   */
+  public void reshape(int x, int y, int width, int height)
+  {
+    super.reshape(x, y, width, height);
+    revalidate();
+  }
+
+  /**
+   * This method gives focus to the last child Component that had focus. This
+   * is used by the UI when this JInternalFrame is activated.
+   */
+  public void restoreSubcomponentFocus()
+  {
+    Component c = getMostRecentFocusOwner();
+    if (c != null)
+      c.requestFocus();
+  }
+
+  /**
+   * This method sets whether this JInternalFrame can be closed.
+   *
+   * @param b Whether this JInternalFrame can be closed.
+   */
+  public void setClosable(boolean b)
+  {
+    if (closable != b)
+      {
+        closable = b;
+        firePropertyChange("closable", ! closable, closable);
+      }
+  }
+
+  /**
+   * This method closes the JInternalFrame if the given boolean is true. If it
+   * is false, then the result of this method is unspecified. If the
+   * JInternalFrame is closed, this method does nothing. This method will
+   * first fire an INTERNAL_FRAME_CLOSING event and give a chance for veto
+   * listeners to cancel the close. If no listener vetoes the change, the
+   * closed property is set to true and the JInternalFrame is hidden and
+   * unselected. The method will finish by firing an INTERNAL_FRAME_CLOSED
+   * event.
+   *
+   * @param b Whether the JInternalFrame will be closed.
+   *
+   * @throws PropertyVetoException If a VetoableChangeListener vetoes the change.
+   */
+  public void setClosed(boolean b) throws PropertyVetoException
+  {
+    if (b && ! isClosed())
+      {
+        fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_CLOSING);
+        fireVetoableChange(IS_CLOSED_PROPERTY, false, true);
+
+        isClosed = b;
+        dispose();
+
+        firePropertyChange(IS_CLOSED_PROPERTY, false, true);
+      }
+  }
+
+  /**
+   * This method sets the Container to be used as a Content Pane for this
+   * JInternalFrame.
+   *
+   * @param c The Container to use as a Content Pane.
+   */
+  public void setContentPane(Container c)
+  {
+    if (c != getContentPane())
+      {
+	Container old = getContentPane();
+	getRootPane().setContentPane(c);
+	firePropertyChange(CONTENT_PANE_PROPERTY, old, c);
+      }
+  }
+
+  /**
+   * Sets a code for the action to be taken when this 
+   * <code>JInternalFrame</code> is closed.  Note that no validation is 
+   * performed on the <code>operation</code> code, any integer will be 
+   * accepted (nevertheless, you should pass in one of the listed values).
+   *
+   * @param operation  one of {@link WindowConstants#DO_NOTHING_ON_CLOSE}, 
+   *   {@link WindowConstants#HIDE_ON_CLOSE} or 
+   *   {@link WindowConstants#DISPOSE_ON_CLOSE}.
+   *   
+   * @see #getDefaultCloseOperation()
+   * @see #doDefaultCloseAction()
+   */
+  public void setDefaultCloseOperation(int operation)
+  {
+    /* Reference implementation allows invalid operations to be specified.
+       In that case, behaviour defaults to DO_NOTHING_ON_CLOSE.
+       processWindowEvent handles the behaviour. getDefaultCloseOperation
+       must return the invalid operator code. */
+    defaultCloseOperation = operation;
+  }
+
+  /**
+   * Sets the <code>JDesktopIcon</code> instance that represents this 
+   * <code>JInternalFrame</code> while it is iconified and, if the new icon is
+   * not the same instance as the existing icon, sends a 
+   * {@link PropertyChangeEvent} (with the property name 
+   * <code>"desktopIcon"</code>) to all registered listeners..
+   *
+   * @param d  the icon.
+   * 
+   * @see #getDesktopIcon()
+   */
+  public void setDesktopIcon(JDesktopIcon d)
+  {
+    if (desktopIcon != d)
+      {
+        JDesktopIcon oldIcon = desktopIcon;
+        desktopIcon = d;
+        firePropertyChange("desktopIcon", oldIcon, d);
+      }
+  }
+
+  /**
+   * This method does nothing because this must be the root of a focus
+   * traversal cycle.
+   *
+   * @param focusCycleRoot Not used.
+   */
+  public final void setFocusCycleRoot(boolean focusCycleRoot)
+  {
+    // Do nothing
+  }
+
+  /**
+   * This method sets the Icon to be used in two places. The first is icon
+   * that is painted at the top left corner of the JInternalFrame when it is
+   * not iconified (clicking on that icon will activate the TitlePane
+   * JMenuBar). When the JInternalFrame is iconified, it will be the icon
+   * displayed in the JDesktopIcon. If no icon is set, the JInternalFrame
+   * will use a Look and Feel default.
+   *
+   * @param icon The Icon used in the TitlePane JMenuBar and iconified frames.
+   */
+  public void setFrameIcon(Icon icon)
+  {
+    if (icon != frameIcon)
+      {
+	Icon old = frameIcon;
+	frameIcon = icon;
+	firePropertyChange(FRAME_ICON_PROPERTY, old, frameIcon);
+      }
+  }
+
+  /**
+   * This method sets the Glass Pane used with this JInternalFrame.
+   *
+   * @param glass The Glass Pane to use with this JInternalFrame.
+   */
+  public void setGlassPane(Component glass)
+  {
+    if (glass != getGlassPane())
+      {
+	Component old = getGlassPane();
+	getRootPane().setGlassPane(glass);
+	firePropertyChange(GLASS_PANE_PROPERTY, old, glass);
+      }
+  }
+
+  /**
+   * This method iconifies or deiconifies this JInternalFrame given the
+   * boolean argument. If the JInternalFrame becomes iconified, it will fire
+   * an INTERNAL_FRAME_ICONIFIED event. If the JInternalFrame becomes
+   * deiconified, it will fire anINTERNAL_FRAME_DEICONIFIED event.
+   *
+   * @param b Whether this JInternalFrame is to be iconified or deiconified.
+   *
+   * @throws PropertyVetoException DOCUMENT ME!
+   */
+  public void setIcon(boolean b) throws PropertyVetoException
+  {
+    if (b != isIcon())
+      {
+	fireVetoableChange(IS_ICON_PROPERTY, b, isIcon);
+
+	isIcon = b;
+
+	firePropertyChange(IS_ICON_PROPERTY, ! isIcon, isIcon);
+	if (b)
+	  fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_ICONIFIED);
+	else
+	  fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_DEICONIFIED);
+      }
+  }
+
+  /**
+   * This method sets whether the JInternalFrame can be iconified. (This means
+   * that the JInternalFrame can be turned into an icon if minimized).
+   *
+   * @param b Whether the JInternalFrame can be iconified.
+   */
+  public void setIconifiable(boolean b)
+  {
+    if (iconable != b)
+      {
+        iconable = b;
+        firePropertyChange("iconable", ! iconable, iconable);
+      }
+  }
+
+  /**
+   * This method sets the JMenuBar to be used with this JInternalFrame.
+   *
+   * @param b The JMenuBar to be used with this JInternalFrame.
+   */
+  public void setJMenuBar(JMenuBar b)
+  {
+    JMenuBar old = getJMenuBar();
+    getRootPane().setJMenuBar(b);
+    firePropertyChange(MENU_BAR_PROPERTY, old, b);
+  }
+
+  /**
+   * A helper method that set the layer that this JInternalFrame resides in.
+   * Using this version of the method means that the user should not set it
+   * to values that are already defined in JLayeredPane. If predefined values
+   * are to be used, the user should use the setLayer(Integer) version.
+   *
+   * @param layer The layer to place this JInternalFrame in.
+   */
+  public void setLayer(int layer)
+  {
+    setLayer(new Integer(layer));
+  }
+
+  /**
+   * A helper method that sets the layer that this JInternalFrame resides in.
+   * Calling this version of the method should use layer values that are
+   * already defined in JLayeredPane.
+   *
+   * @param layer The layer to place this JInternalFrame in.
+   */
+  public void setLayer(Integer layer)
+  {
+    Container p = getParent();
+    if (p instanceof JLayeredPane)
+      {
+        JLayeredPane lp = (JLayeredPane) p;
+        lp.setLayer(this, layer.intValue(), lp.getPosition(this));
+      }
+    else
+      {
+        JLayeredPane.putLayer(this, layer.intValue());
+        if (p != null)
+          p.repaint(getX(), getY(), getWidth(), getHeight());
+      }
+  }
+
+  /**
+   * This method sets the JLayeredPane to use with this JInternalFrame.
+   *
+   * @param layered The JLayeredPane to use as a layeredPane.
+   */
+  public void setLayeredPane(JLayeredPane layered)
+  {
+    if (layered == null)
+      throw new IllegalComponentStateException("LayeredPane must not be null");
+
+    if (layered != getLayeredPane())
+      {
+	JLayeredPane old = getLayeredPane();
+	getRootPane().setLayeredPane(layered);
+	firePropertyChange(LAYERED_PANE_PROPERTY, old, layered);
+      }
+  }
+
+  /**
+   * This method sets whether the JInternalFrame can be maximized.
+   *
+   * @param b Whether this JInternalFrame can be maximized.
+   */
+  public void setMaximizable(boolean b)
+  {
+    if (maximizable != b)
+      {
+        maximizable = b;
+        firePropertyChange("maximizable", ! maximizable, maximizable);
+      }
+  }
+
+  /**
+   * This method sets the Layout Manager used in the JInternalFrame. SetLayout
+   * should not be called on the JInternalFrame directly. Instead, it should
+   * be called with JInternalFrame.getContentPane().setLayout. Calls to this
+   * method with root pane checking enabled will cause exceptions to be
+   * thrown.
+   *
+   * @param manager The Layout Manager to be used with the JInternalFrame.
+   *
+   * @throws Error If rootPaneChecking is enabled.
+   */
+  public void setLayout(LayoutManager manager)
+  {
+    // Check if we're in initialization stage.  If so, call super.setLayout
+    // otherwise, valid calls go to the content pane.
+    if (isRootPaneCheckingEnabled())
+      getContentPane().setLayout(manager);
+    else
+      super.setLayout(manager);
+  }
+
+  /**
+   * This method sets the JInternalFrame to maximized (if the given argument
+   * is true) or restores the JInternalFrame to its normal bounds otherwise.
+   *
+   * @param b Whether this JInteralFrame will be maximized or restored.
+   *
+   * @throws PropertyVetoException If a VetoableChangeListener vetoes the change.
+   */
+  public void setMaximum(boolean b) throws PropertyVetoException
+  {
+    if (b != isMaximum)
+      {
+	fireVetoableChange(IS_MAXIMUM_PROPERTY, isMaximum, b);
+	isMaximum = b;
+	firePropertyChange(IS_MAXIMUM_PROPERTY, ! isMaximum, isMaximum);
+      }
+  }
+
+  /**
+   * This method is deprecated. This method sets the JMenuBar used with this
+   * JInternalFrame.
+   *
+   * @param m The JMenuBar to use with this JInternalFrame.
+   *
+   * @deprecated 1.0.3
+   */
+  public void setMenuBar(JMenuBar m)
+  {
+    setJMenuBar(m);
+  }
+
+  /**
+   * This method sets the bounds that this JInternalFrame will be restored to.
+   *
+   * @param r The bounds that this JInternalFrame will be restored to.
+   */
+  public void setNormalBounds(Rectangle r)
+  {
+    storedBounds = r;
+  }
+
+  /**
+   * This method sets whether the JInternalFrame can be resized by a user
+   * action (like dragging at the frame borders).
+   *
+   * @param b Whether this JInternalFramer can be resized.
+   */
+  public void setResizable(boolean b)
+  {
+    if (b != resizable)
+      {
+        resizable = b;
+        firePropertyChange("resizable", ! resizable, resizable);
+      }
+  }
+
+  /**
+   * This method sets the Root Pane for this JInternalFrame.
+   *
+   * @param root The Root Pane for this JInternalFrame.
+   */
+  protected void setRootPane(JRootPane root)
+  {
+    if (rootPane != null)
+      remove(rootPane);
+
+    JRootPane old = rootPane;
+    rootPane = root;
+
+    if (rootPane != null)
+      {
+        boolean checkingEnabled = isRootPaneCheckingEnabled();
+        try
+          {
+            setRootPaneCheckingEnabled(false);
+            add(rootPane, BorderLayout.CENTER);
+          }
+        finally
+          {
+            setRootPaneCheckingEnabled(checkingEnabled);
+          }
+      }
+    firePropertyChange(ROOT_PANE_PROPERTY, old, rootPane);
+  }
+
+  /**
+   * This method sets whether root pane checking is enabled. If root pane
+   * checking is enabled, then calls to addImpl and setLayout will throw
+   * exceptions.
+   *
+   * @param enabled Whether root pane checking is enabled.
+   */
+  protected void setRootPaneCheckingEnabled(boolean enabled)
+  {
+    rootPaneCheckingEnabled = enabled;
+  }
+
+  /**
+   * This method sets whether this JInternalFrame is the selected frame in the
+   * JDesktopPane (or other container). When selected, a JInternalFrame will
+   * have focus and paint its TitlePane differently (usually a different
+   * colour). If this method selects the frame, this JInternalFrame will fire
+   * an INTERNAL_FRAME_ACTIVATED event. If it deselects this frame, it will
+   * fire an INTERNAL_FRAME_DEACTIVATED event.
+   *
+   * @param selected Whether this JInternalFrame will become selected or
+   *        deselected.
+   *
+   * @throws PropertyVetoException If a VetoableChangeListener vetoes the change.
+   */
+  public void setSelected(boolean selected) throws PropertyVetoException
+  {
+    if (selected != isSelected
+        && (! selected || (isIcon ? desktopIcon.isShowing() : isShowing())))
+      {
+        fireVetoableChange(IS_SELECTED_PROPERTY, isSelected, selected);
+
+        if (! selected)
+          defaultFocus = getMostRecentFocusOwner();
+
+        isSelected = selected;
+        firePropertyChange(IS_SELECTED_PROPERTY, ! isSelected, isSelected);
+
+        if (isSelected)
+          fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_ACTIVATED);
+        else
+          fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_DEACTIVATED);
+
+        if (selected)
+          restoreSubcomponentFocus();
+
+        repaint();
+      }
+  }
+
+  /**
+   * Sets the title for the <code>JInternalFrame</code> and sends a 
+   * {@link PropertyChangeEvent} (with the property name 
+   * {@link #TITLE_PROPERTY}) to all registered listeners.
+   *
+   * @param title  the new title (<code>null</code> permitted).
+   * 
+   * @see #getTitle()
+   */
+  public void setTitle(String title)
+  {
+    String old = this.title;
+    this.title = title;
+    firePropertyChange(TITLE_PROPERTY, old, this.title);
+  }
+
+  /**
+   * This method displays the JInternalFrame. If it is not visible, this
+   * method will bring this JInternalFrame to the front, make it visible and
+   * select it. If this is the first time this JInternalFrame is made
+   * visible, an INTERNAL_FRAME_OPENED event will be fired.
+   */
+  public void show()
+  {
+    if (! isVisible())
+      {
+        if (isFirstTimeVisible)
+          {
+            isFirstTimeVisible = false;
+            fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_OPENED);
+          }
+
+        getDesktopIcon().setVisible(true);
+
+        toFront();
+        super.show();
+
+        if (isIcon())
+          return;
+
+        if (! isSelected())
+          {
+            try
+              {
+                setSelected(true);
+              }
+            catch (PropertyVetoException e)
+              {
+                // Do nothing. if they don't want to be selected.
+              }
+          }
+      }
+  }
+
+  /**
+   * This method is used to set the UI responsible for the JInternalFrame.
+   *
+   * @param ui The UI responsible for the JInternalFrame.
+   */
+  public void setUI(InternalFrameUI ui)
+  {
+    // We must temporarily go into init mode so that the UI can directly
+    // manipulate the JInternalFrame.
+    boolean old = isRootPaneCheckingEnabled();
+    setRootPaneCheckingEnabled(false);
+    super.setUI(ui);
+    setRootPaneCheckingEnabled(old);
+  }
+
+  /**
+   * This method causes the JInternalFrame to be brough to back in the
+   * z-order.
+   */
+  public void toBack()
+  {
+    moveToBack();
+  }
+
+  /**
+   * This method causes the JInternalFrame to be brought to front in the
+   * z-order.
+   */
+  public void toFront()
+  {
+    moveToFront();
+  }
+
+  /**
+   * This method resets the UI to the Look and Feel defaults.
+   */
+  public void updateUI()
+  {
+    // We must go into the init stage when updating the UI, so the UI can
+    // set layout and components directly on the internal frame, not its
+    // content pane.
+	boolean old = isRootPaneCheckingEnabled();
+    setRootPaneCheckingEnabled(false);
+    setUI((InternalFrameUI) UIManager.getUI(this));
+    setRootPaneCheckingEnabled(old);
+  }
+
+  /**
+   * This helper method allows JInternalFrames to signal that they were
+   * iconned for the first time.
+   *
+   * @param b Whether the JInternalFrame was iconned.
+   * @param ID The identifier of the property change event to fire if the
+   *        JInternalFrame is iconned for the first time.
+   */
+  void setWasIcon(boolean b, String ID)
+  {
+    if (b && ! wasIcon)
+      {
+	wasIcon = b;
+	firePropertyChange(ID, ! b, b);
+      }
+  }
+
+  /**
+   * This helper method returns whether the JInternalFrame has been iconned
+   * once already.
+   *
+   * @return Whether the JInternalFrame has been iconned once already.
+   */
+  boolean getWasIcon()
+  {
+    return wasIcon;
+  }
+
+  /**
+   * This method is a convenience method to fire vetoable property changes.
+   *
+   * @param name The identifier of the property change.
+   * @param oldValue The old value.
+   * @param newValue The new value.
+   *
+   * @throws PropertyVetoException Fired if a vetoable change listener vetoes
+   *         the change.
+   */
+  private void fireVetoableChange(String name, boolean oldValue,
+                                  boolean newValue)
+                           throws PropertyVetoException
+  {
+    super.fireVetoableChange(name, Boolean.valueOf(oldValue), Boolean.valueOf(newValue));
+  }
+}

Added: llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JLabel.java
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JLabel.java?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JLabel.java (added)
+++ llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JLabel.java Thu Nov  8 16:56:19 2007
@@ -0,0 +1,1055 @@
+/* JLabel.java --
+   Copyright (C) 2002, 2004, 2005, 2006,  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;
+
+import gnu.classpath.NotImplementedException;
+
+import java.awt.Component;
+import java.awt.Font;
+import java.awt.Image;
+import java.awt.Point;
+import java.awt.Rectangle;
+import java.awt.event.KeyEvent;
+import java.beans.PropertyChangeEvent;
+
+import javax.accessibility.Accessible;
+import javax.accessibility.AccessibleContext;
+import javax.accessibility.AccessibleExtendedComponent;
+import javax.accessibility.AccessibleRole;
+import javax.accessibility.AccessibleText;
+import javax.swing.plaf.LabelUI;
+import javax.swing.text.AttributeSet;
+import javax.swing.text.SimpleAttributeSet;
+
+/**
+ * A component that displays a static text message and/or an icon.
+ */
+public class JLabel extends JComponent implements Accessible, SwingConstants
+{
+
+  /**
+   * Provides the accessibility features for the <code>JLabel</code>
+   * component.
+   */
+  protected class AccessibleJLabel
+    extends JComponent.AccessibleJComponent
+    implements AccessibleText, AccessibleExtendedComponent
+  {
+    
+    /**
+     * Returns the accessible name.
+     * 
+     * @return The accessible name.
+     */
+    public String getAccessibleName()
+    {
+      if (accessibleName != null)
+        return accessibleName;
+      if (text != null)
+        return text;
+      else
+        return super.getAccessibleName();
+    }
+    
+    /**
+     * Returns the accessible role for the <code>JLabel</code> component.
+     *
+     * @return {@link AccessibleRole#LABEL}.
+     */
+    public AccessibleRole getAccessibleRole()
+    {
+      return AccessibleRole.LABEL;
+    }
+    
+    /**
+     * Returns the selected text. This is null since JLabels
+     * are not selectable.
+     *
+     * @return <code>null</code> because JLabels cannot have selected text
+     */
+    public String getSelectedText()
+    {
+      // We return null here since JLabel's text is not selectable.
+      return null;
+    }
+
+    /**
+     * Returns the start index of the selected text.
+     *
+     * @return the start index of the selected text
+     */
+    public int getSelectionStart()
+    {
+      // JLabel don't have selected text, so we return -1 here.
+      return -1;
+    }
+
+    /**
+     * Returns the end index of the selected text.
+     *
+     * @return the end index of the selected text
+     */
+    public int getSelectionEnd()
+    {
+      // JLabel don't have selected text, so we return -1 here.
+      return -1;
+    }
+
+    /**
+     * Returns an {@link AttributeSet} that reflects the text attributes of
+     * the specified character. We return an empty
+     * <code>AttributeSet</code> here, because JLabels don't support text
+     * attributes (at least not yet).
+     *
+     * @param index the index of the character
+     *
+     * @return an {@link AttributeSet} that reflects the text attributes of
+     *         the specified character
+     */
+    public AttributeSet getCharacterAttribute(int index)
+    {
+      // FIXME: Return null here for simple labels, and query the HTML
+      // view for HTML labels.
+      return new SimpleAttributeSet();
+    }
+
+    /**
+     * Returns the character, word or sentence at the specified index. The
+     * <code>part</code> parameter determines what is returned, the character,
+     * word or sentence after the index.
+     *
+     * @param part one of {@link AccessibleText#CHARACTER},
+     *             {@link AccessibleText#WORD} or
+     *             {@link AccessibleText#SENTENCE}, specifying what is returned
+     * @param index the index
+     *
+     * @return the character, word or sentence after <code>index</code>
+     */
+    public String getAtIndex(int part, int index)
+    {
+      String result = "";
+      int startIndex = -1;
+      int endIndex = -1;
+      switch(part)
+        {
+        case AccessibleText.CHARACTER:
+          result = String.valueOf(text.charAt(index));
+          break;
+        case AccessibleText.WORD:
+          startIndex = text.lastIndexOf(' ', index);
+          endIndex = text.indexOf(' ', startIndex + 1);
+          if (endIndex == -1)
+            endIndex = startIndex + 1;
+          result = text.substring(startIndex + 1, endIndex);
+          break;
+        case AccessibleText.SENTENCE:
+        default:
+          startIndex = text.lastIndexOf('.', index);
+          endIndex = text.indexOf('.', startIndex + 1);
+          if (endIndex == -1)
+            endIndex = startIndex + 1;
+          result = text.substring(startIndex + 1, endIndex);
+          break;
+        }
+      return result;
+    }
+
+    /**
+     * Returns the character, word or sentence after the specified index. The
+     * <code>part</code> parameter determines what is returned, the character,
+     * word or sentence after the index.
+     *
+     * @param part one of {@link AccessibleText#CHARACTER},
+     *             {@link AccessibleText#WORD} or
+     *             {@link AccessibleText#SENTENCE}, specifying what is returned
+     * @param index the index
+     *
+     * @return the character, word or sentence after <code>index</code>
+     */
+    public String getAfterIndex(int part, int index)
+    {
+      String result = "";
+      int startIndex = -1;
+      int endIndex = -1;
+      switch(part)
+        {
+        case AccessibleText.CHARACTER:
+          result = String.valueOf(text.charAt(index + 1));
+          break;
+        case AccessibleText.WORD:
+          startIndex = text.indexOf(' ', index);
+          endIndex = text.indexOf(' ', startIndex + 1);
+          if (endIndex == -1)
+            endIndex = startIndex + 1;
+          result = text.substring(startIndex + 1, endIndex);
+          break;
+        case AccessibleText.SENTENCE:
+        default:
+          startIndex = text.indexOf('.', index);
+          endIndex = text.indexOf('.', startIndex + 1);
+          if (endIndex == -1)
+            endIndex = startIndex + 1;
+          result = text.substring(startIndex + 1, endIndex);
+          break;
+        }
+      return result;
+    }
+
+    /**
+     * Returns the character, word or sentence before the specified index. The
+     * <code>part</code> parameter determines what is returned, the character,
+     * word or sentence before the index.
+     *
+     * @param part one of {@link AccessibleText#CHARACTER},
+     *             {@link AccessibleText#WORD} or
+     *             {@link AccessibleText#SENTENCE}, specifying what is returned
+     * @param index the index
+     *
+     * @return the character, word or sentence before <code>index</code>
+     */
+    public String getBeforeIndex(int part, int index)
+    {
+      String result = "";
+      int startIndex = -1;
+      int endIndex = -1;
+      switch(part)
+        {
+        case AccessibleText.CHARACTER:
+          result = String.valueOf(text.charAt(index - 1));
+          break;
+        case AccessibleText.WORD:
+          endIndex = text.lastIndexOf(' ', index);
+          if (endIndex == -1)
+            endIndex = 0;
+          startIndex = text.lastIndexOf(' ', endIndex - 1);
+          result = text.substring(startIndex + 1, endIndex);
+          break;
+        case AccessibleText.SENTENCE:
+        default:
+          endIndex = text.lastIndexOf('.', index);
+          if (endIndex == -1)
+            endIndex = 0;
+          startIndex = text.lastIndexOf('.', endIndex - 1);
+          result = text.substring(startIndex + 1, endIndex);
+          break;
+        }
+      return result;
+    }
+
+    /**
+     * Returns the caret position. This method returns -1 because JLabel don't
+     * have a caret.
+     *
+     * @return the caret position
+     */
+    public int getCaretPosition()
+    {
+      return -1;
+    }
+
+    /**
+     * Returns the number of characters that are displayed by the JLabel.
+     *
+     * @return the number of characters that are displayed by the JLabel
+     */
+    public int getCharCount()
+    {
+      // FIXME: Query HTML view for HTML labels.
+      return text.length();
+    }
+
+    /**
+     * Returns the bounding box of the character at the specified index.
+     *
+     * @param index the index of the character that we return the
+     *        bounds for
+     *
+     * @return the bounding box of the character at the specified index
+     */
+    public Rectangle getCharacterBounds(int index)
+      throws NotImplementedException
+    {
+      // FIXME: Implement this correctly.
+      return new Rectangle();
+    }
+
+    /**
+     * Returns the index of the character that is located at the specified
+     * point.
+     *
+     * @param point the location that we lookup the character for
+     *
+     * @return the index of the character that is located at the specified
+     *         point
+     */
+    public int getIndexAtPoint(Point point)
+      throws NotImplementedException
+    {
+      // FIXME: Implement this correctly.
+      return 0;
+    }
+  }
+
+  private static final long serialVersionUID = 5496508283662221534L;
+
+  static final String LABEL_PROPERTY = "labeledBy";
+
+  /**
+   * The Component the label will give focus to when its mnemonic is
+   * activated.
+   */
+  protected Component labelFor;
+
+  /** The label's text. */
+  transient String text;
+
+  /** Where the label will be positioned horizontally. */
+  private transient int horizontalAlignment = LEADING;
+
+  /** Where the label text will be placed horizontally relative to the icon. */
+  private transient int horizontalTextPosition = TRAILING;
+
+  /** Where the label will be positioned vertically. */
+  private transient int verticalAlignment = CENTER;
+
+  /** Where the label text will be place vertically relative to the icon. */
+  private transient int verticalTextPosition = CENTER;
+
+  /** The icon painted when the label is enabled. */
+  private transient Icon icon;
+
+  /** The icon painted when the label is disabled. */
+  private transient Icon disabledIcon;
+
+  /** The label's mnemnonic key. */
+  private transient int displayedMnemonic = KeyEvent.VK_UNDEFINED;
+
+  /** The index of the mnemonic character in the text. */
+  private transient int displayedMnemonicIndex = -1;
+
+  /** The gap between the icon and the text. */
+  private transient int iconTextGap = 4;
+
+  /**
+   * Creates a new vertically centered, horizontally on the leading edge
+   * JLabel object with text and no icon.
+   */
+  public JLabel()
+  {
+    this("", null, LEADING);
+  }
+
+  /**
+   * Creates a new vertically and horizontally centered
+   * JLabel object with no text and the given icon.
+   *
+   * @param image The icon to use with the label.
+   */
+  public JLabel(Icon image)
+  {
+    this("", image, CENTER);
+  }
+
+  /**
+   * Creates a new vertically centered JLabel object with no text and the
+   * given icon and horizontal alignment. By default, the text is TRAILING
+   * the image.
+   *
+   * @param image The icon to use with the label.
+   * @param horizontalAlignment The horizontal alignment of the label.
+   */
+  public JLabel(Icon image, int horizontalAlignment)
+  {
+    this("", image, horizontalAlignment);
+  }
+
+  /**
+   * Creates a new horizontally leading and vertically centered JLabel 
+   * object with no icon and the given text.
+   *
+   * @param text The text to use with the label.
+   */
+  public JLabel(String text)
+  {
+    this(text, null, LEADING);
+  }
+
+  /**
+   * Creates a new vertically centered JLabel object with no icon and the
+   * given text and horizontal alignment.
+   *
+   * @param text The text to use with the label.
+   * @param horizontalAlignment The horizontal alignment of the label.
+   */
+  public JLabel(String text, int horizontalAlignment)
+  {
+    this(text, null, horizontalAlignment);
+  }
+
+  /**
+   * Creates a new vertically centered JLabel object with the given text,
+   * icon, and horizontal alignment.
+   *
+   * @param text The text to use with the label.
+   * @param icon The icon to use with the label.
+   * @param horizontalAlignment The horizontal alignment of the label.
+   */
+  public JLabel(String text, Icon icon, int horizontalAlignment)
+  {
+    this.text = text;
+    this.icon = icon;
+    this.horizontalAlignment = horizontalAlignment;
+    setAlignmentX(0.0F);
+    setInheritsPopupMenu(true);
+    updateUI();
+  }
+
+  /**
+   * Returns the label's UI delegate.
+   *
+   * @return The label's UI delegate.
+   */
+  public LabelUI getUI()
+  {
+    return (LabelUI) ui;
+  }
+
+  /**
+   * Sets the label's UI delegate.
+   *
+   * @param ui The label's UI delegate (<code>null</code> not permitted).
+   */
+  public void setUI(LabelUI ui)
+  {
+    super.setUI(ui);
+  }
+
+  /**
+   * Resets the label's UI delegate to the default UI for the current look and 
+   * feel.
+   */
+  public void updateUI()
+  {
+    setUI((LabelUI) UIManager.getUI(this));
+  }
+
+  /**
+   * Returns a name to identify which look and feel class will be
+   * the UI delegate for this label.
+   *
+   * @return <code>"LabelUI"</code>
+   */
+  public String getUIClassID()
+  {
+    return "LabelUI";
+  }
+
+  /**
+   * Returns a string describing the attributes for the <code>JLabel</code>
+   * component, for use in debugging.  The return value is guaranteed to be 
+   * non-<code>null</code>, but the format of the string may vary between
+   * implementations.
+   *
+   * @return A string describing the attributes of the <code>JLabel</code>.
+   */
+  protected String paramString()
+  {
+    StringBuffer sb = new StringBuffer(super.paramString());
+    sb.append(",defaultIcon=");
+    if (icon != null)
+      sb.append(icon);
+    sb.append(",disabledIcon=");
+    if (disabledIcon != null)
+      sb.append(disabledIcon);
+    sb.append(",horizontalAlignment=");
+    sb.append(SwingUtilities.convertHorizontalAlignmentCodeToString(
+        horizontalAlignment));
+    sb.append(",horizontalTextPosition=");
+    sb.append(SwingUtilities.convertHorizontalAlignmentCodeToString(
+        horizontalTextPosition));
+    sb.append(",iconTextGap=").append(iconTextGap);
+    sb.append(",labelFor=");
+    if (labelFor != null)
+      sb.append(labelFor);
+    sb.append(",text=");
+    if (text != null)
+      sb.append(text);
+    sb.append(",verticalAlignment=");
+    sb.append(SwingUtilities.convertVerticalAlignmentCodeToString(
+        verticalAlignment));
+    sb.append(",verticalTextPosition=");
+    sb.append(SwingUtilities.convertVerticalAlignmentCodeToString(
+        verticalTextPosition));
+    return sb.toString();
+  }
+
+  /**
+   * Returns the text displayed by the label.
+   *
+   * @return The label text (possibly <code>null</code>).
+   * 
+   * @see #setText(String)
+   */
+  public String getText()
+  {
+    return text;
+  }
+
+  /**
+   * Sets the text for the label and sends a {@link PropertyChangeEvent} (with
+   * the name 'text') to all registered listeners.  This method will also 
+   * update the <code>displayedMnemonicIndex</code>, if necessary.
+   *
+   * @param newText The text (<code>null</code> permitted).
+   * 
+   * @see #getText()
+   * @see #getDisplayedMnemonicIndex()
+   */
+  public void setText(String newText)
+  {
+    if (text == null && newText == null)
+      return;
+    if (text != null && text.equals(newText))
+      return;
+
+    String oldText = text;
+    text = newText;
+    firePropertyChange("text", oldText, newText);
+
+    if (text != null)
+      setDisplayedMnemonicIndex(text.toUpperCase().indexOf(displayedMnemonic));
+    else
+      setDisplayedMnemonicIndex(-1);
+    revalidate();
+    repaint();
+  }
+
+  /**
+   * Returns the active icon. The active icon is painted when the label is 
+   * enabled.
+   *
+   * @return The active icon.
+   * 
+   * @see #setIcon(Icon)
+   * @see #getDisabledIcon()
+   */
+  public Icon getIcon()
+  {
+    return icon;
+  }
+
+  /**
+   * Sets the icon for the label (this is a bound property with the name 
+   * 'icon'). This icon will be displayed when the label is enabled.
+   *
+   * @param newIcon The icon (<code>null</code> permitted).
+   * 
+   * @see #getIcon()
+   * @see #setDisabledIcon(Icon)
+   */
+  public void setIcon(Icon newIcon)
+  {
+    if (icon != newIcon)
+      {
+        Icon oldIcon = icon;
+        icon = newIcon;
+        firePropertyChange("icon", oldIcon, newIcon);
+        repaint();
+      }
+  }
+
+  /**
+   * Returns the disabled icon. The disabled icon is painted when the label is 
+   * disabled. If the disabled icon is <code>null</code> and the active icon
+   * is an {@link ImageIcon}, this method returns a grayed version of the icon. 
+   * The grayed version of the icon becomes the <code>disabledIcon</code>.
+   *
+   * @return The disabled icon.
+   * 
+   * @see #setDisabledIcon(Icon)
+   */
+  public Icon getDisabledIcon()
+  {
+    if (disabledIcon == null && icon instanceof ImageIcon)
+      disabledIcon = new ImageIcon(
+          GrayFilter.createDisabledImage(((ImageIcon) icon).getImage()));
+
+    return disabledIcon;
+  }
+
+  /**
+   * Sets the icon displayed when the label is disabled (this is a bound
+   * property with the name 'disabledIcon').
+   *
+   * @param newIcon The disabled icon (<code>null</code> permitted).
+   * 
+   * @see #getDisabledIcon()
+   */
+  public void setDisabledIcon(Icon newIcon)
+  {
+    if (disabledIcon != newIcon)
+      {
+        Icon oldIcon = disabledIcon;
+        disabledIcon = newIcon;
+        firePropertyChange("disabledIcon", oldIcon, newIcon);
+      }
+  }
+
+  /**
+   * Sets the keycode that will be the label's mnemonic (this is a bound
+   * property with the name 'displayedMnemonic').  If the label is used as a 
+   * label for another component, the label will give focus to that component 
+   * when the mnemonic is activated.
+   *
+   * @param mnemonic The keycode to use for the mnemonic.
+   * 
+   * @see #getDisplayedMnemonic()
+   */
+  public void setDisplayedMnemonic(int mnemonic)
+  {
+    if (displayedMnemonic != mnemonic)
+      {
+        int old = displayedMnemonic;
+        displayedMnemonic = mnemonic;
+        firePropertyChange("displayedMnemonic", old, displayedMnemonic);
+        if (text != null)
+          setDisplayedMnemonicIndex(text.toUpperCase().indexOf(mnemonic));
+      }
+  }
+
+  /**
+   * Sets the character that will be the label's mnemonic. If the
+   * label is used as a label for another component, the label will give
+   * focus to that component when the mnemonic is activated via the keyboard.
+   *
+   * @param mnemonic The character to use for the mnemonic (this will be
+   *     converted to the equivalent upper case character).
+   *     
+   * @see #getDisplayedMnemonic()
+   */
+  public void setDisplayedMnemonic(char mnemonic)
+  {
+    setDisplayedMnemonic((int) Character.toUpperCase(mnemonic));
+  }
+
+  /**
+   * Returns the keycode that is used for the label's mnemonic.
+   *
+   * @return The keycode that is used for the label's mnemonic.
+   * 
+   * @see #setDisplayedMnemonic(int)
+   */
+  public int getDisplayedMnemonic()
+  {
+    return displayedMnemonic;
+  }
+
+  /**
+   * Sets the index of the character in the text that will be underlined to
+   * indicate that it is the mnemonic character for the label.  You only need
+   * to call this method if you wish to override the automatically calculated
+   * character index.  For instance, for a label "Find Next" with the mnemonic
+   * character 'n', you might wish to underline the second occurrence of 'n'
+   * rather than the first (which is the default).
+   * <br><br>
+   * Note that this method does not validate the character at the specified 
+   * index to ensure that it matches the key code returned by
+   * {@link #getDisplayedMnemonic()}.
+   *
+   * @param newIndex The index of the character to underline.
+   *
+   * @throws IllegalArgumentException If index less than -1 or index is greater
+   *         than or equal to the label length.
+   *         
+   * @see #getDisplayedMnemonicIndex()
+   * @since 1.4
+   */
+  public void setDisplayedMnemonicIndex(int newIndex)
+    throws IllegalArgumentException
+  {
+    int maxValid = -1;
+    if (text != null)
+      maxValid = text.length() - 1;
+    if (newIndex < -1 || newIndex > maxValid)
+      throw new IllegalArgumentException();
+
+    if (newIndex != displayedMnemonicIndex)
+      {
+        int oldIndex = displayedMnemonicIndex;
+        displayedMnemonicIndex = newIndex;
+        firePropertyChange("displayedMnemonicIndex", oldIndex, newIndex);
+      }
+  }
+
+  /**
+   * Returns the index of the character in the label's text that will be
+   * underlined (to indicate that it is the mnemonic character), or -1 if no
+   * character is to be underlined.
+   *
+   * @return The index of the character that will be underlined.
+   * 
+   * @see #setDisplayedMnemonicIndex(int)
+   * @since 1.4
+   */
+  public int getDisplayedMnemonicIndex()
+  {
+    return displayedMnemonicIndex;
+  }
+
+  /**
+   * Checks the specified key to ensure that it is valid as a horizontal 
+   * alignment, throwing an {@link IllegalArgumentException} if the key is
+   * invalid.  Valid keys are {@link #LEFT}, {@link #CENTER}, {@link #RIGHT}, 
+   * {@link #LEADING} and {@link #TRAILING}.
+   *
+   * @param key The key to check.
+   * @param message The message of the exception to be thrown if the key is
+   *        invalid.
+   *
+   * @return The key if it is valid.
+   *
+   * @throws IllegalArgumentException If the key is invalid.
+   */
+  protected int checkHorizontalKey(int key, String message)
+  {
+    if (key != LEFT && key != CENTER && key != RIGHT && key != LEADING
+        && key != TRAILING)
+      throw new IllegalArgumentException(message);
+    else
+      return key;
+  }
+
+  /**
+   * Checks the specified key to ensure that it is valid as a vertical 
+   * alignment, throwing an {@link IllegalArgumentException} if the key is
+   * invalid.  Valid keys are {@link #TOP}, {@link #CENTER} and {@link #BOTTOM}.
+   *
+   * @param key The key to check.
+   * @param message The message of the exception to be thrown if the key is
+   *        invalid.
+   *
+   * @return The key if it is valid.
+   *
+   * @throws IllegalArgumentException If the key is invalid.
+   */
+  protected int checkVerticalKey(int key, String message)
+  {
+    if (key != TOP && key != BOTTOM && key != CENTER)
+      throw new IllegalArgumentException(message);
+    else
+      return key;
+  }
+
+  /**
+   * Returns the gap between the icon and the text.
+   *
+   * @return The gap between the icon and the text.
+   * 
+   * @see #setIconTextGap(int)
+   */
+  public int getIconTextGap()
+  {
+    return iconTextGap;
+  }
+
+  /**
+   * Sets the gap between the icon and the text, in the case that both are 
+   * visible (this is a bound property with the name 'iconTextGap'). 
+   *
+   * @param newGap The gap (in pixels).
+   * 
+   * @see #getIconTextGap()
+   */
+  public void setIconTextGap(int newGap)
+  {
+    if (iconTextGap != newGap)
+      {
+	firePropertyChange("iconTextGap", iconTextGap, newGap);
+	iconTextGap = newGap;
+      }
+  }
+
+  /**
+   * Returns the vertical alignment of the label (one of
+   * {@link #TOP}, {@link #CENTER} and {@link #BOTTOM}).  The default value
+   * depends on the installed look and feel, but is usually {@link #CENTER}.
+   *
+   * @return The vertical alignment.
+   * 
+   * @see #setVerticalAlignment(int)
+   */
+  public int getVerticalAlignment()
+  {
+    return verticalAlignment;
+  }
+
+  /**
+   * Sets the vertical alignment for the label (this is a bound property with
+   * the name 'verticalAlignment').  The vertical alignment determines where 
+   * the label (icon and text) will be placed vertically within the component 
+   * bounds.  Valid alignment codes are {@link #TOP}, {@link #CENTER} and 
+   * {@link #BOTTOM}.
+   *
+   * @param alignment The vertical alignment of the label.
+   * 
+   * @throws IllegalArgumentException if <code>alignment</code> is not one of 
+   *     the specified values.
+   *     
+   * @see #getVerticalAlignment()
+   */
+  public void setVerticalAlignment(int alignment)
+  {
+    if (alignment == verticalAlignment)
+      return;
+
+    int oldAlignment = verticalAlignment;
+    verticalAlignment = checkVerticalKey(alignment, "verticalAlignment");
+    firePropertyChange("verticalAlignment", oldAlignment, verticalAlignment);
+  }
+
+  /**
+   * Returns the horizontal alignment of the label (one of {@link #LEFT}, 
+   * {@link #CENTER}, {@link #RIGHT}, {@link #LEADING} and {@link #TRAILING}).
+   * The default value depends on the installed look and feel, but is usually 
+   * {@link #LEFT}.
+   *
+   * @return The horizontal alignment.
+   * 
+   * @see #setHorizontalAlignment(int)
+   */
+  public int getHorizontalAlignment()
+  {
+    return horizontalAlignment;
+  }
+
+  /**
+   * Sets the horizontal alignment for the label (this is a bound property with
+   * the name 'horizontalAlignment').  The horizontal alignment determines where 
+   * the label (icon and text) will be placed horizontally within the 
+   * component bounds.  Valid alignment codes are {@link #LEFT}, 
+   * {@link #CENTER}, {@link #RIGHT}, {@link #LEADING} and {@link #TRAILING}.
+   *
+   * @param alignment The horizontal alignment of the label.
+   * 
+   * @throws IllegalArgumentException if <code>alignment</code> is not one of 
+   *     the specified values.
+   *     
+   * @see #getHorizontalAlignment()
+   */
+  public void setHorizontalAlignment(int alignment)
+  {
+    if (horizontalAlignment == alignment)
+      return;
+    
+    int oldAlignment = horizontalAlignment;
+    horizontalAlignment = checkHorizontalKey(alignment, "horizontalAlignment");
+    firePropertyChange("horizontalAlignment", oldAlignment,
+                       horizontalAlignment);
+  }
+
+  /**
+   * Returns the vertical position of the label's text relative to the icon. 
+   * This will be one of {@link #TOP}, {@link #CENTER} and {@link #BOTTOM}.
+   * 
+   * @return The vertical position of the label's text relative to the icon.
+   * 
+   * @see #setVerticalTextPosition(int)
+   */
+  public int getVerticalTextPosition()
+  {
+    return verticalTextPosition;
+  }
+
+  /**
+   * Sets the vertical position of the label's text relative to the icon (this
+   * is a bound property with the name 'verticalTextPosition').  Valid 
+   * positions are {@link #TOP}, {@link #CENTER} and {@link #BOTTOM}.
+   *
+   * @param textPosition The vertical text position.
+   * 
+   * @throws IllegalArgumentException if <code>textPosition</code> is not one
+   *     of the specified values.
+   */
+  public void setVerticalTextPosition(int textPosition)
+  {
+    if (textPosition != verticalTextPosition)
+      {
+        int oldPos = verticalTextPosition;
+        verticalTextPosition = checkVerticalKey(textPosition,
+	                                            "verticalTextPosition");
+        firePropertyChange("verticalTextPosition", oldPos, 
+                           verticalTextPosition);
+      }
+  }
+
+  /**
+   * Returns the horizontal position of the label's text relative to the icon. 
+   * This will be one of {@link #LEFT}, {@link #CENTER}, {@link #RIGHT}, 
+   * {@link #LEADING} and {@link #TRAILING}.
+   * 
+   * @return The horizontal position of the label's text relative to the icon.
+   * 
+   * @see #setHorizontalTextPosition(int)
+   */
+  public int getHorizontalTextPosition()
+  {
+    return horizontalTextPosition;
+  }
+
+  /**
+   * Sets the horizontal position of the label's text relative to the icon (this
+   * is a bound property with the name 'horizontalTextPosition').  Valid 
+   * positions are {@link #LEFT}, {@link #CENTER}, {@link #RIGHT}, 
+   * {@link #LEADING} and {@link #TRAILING}.
+   *
+   * @param textPosition The horizontal text position.
+   * 
+   * @throws IllegalArgumentException if <code>textPosition</code> is not one
+   *     of the specified values.
+   */
+  public void setHorizontalTextPosition(int textPosition)
+  {
+    if (textPosition != horizontalTextPosition)
+      {
+        int oldPos = horizontalTextPosition;
+        horizontalTextPosition = checkHorizontalKey(textPosition,
+                                                    "horizontalTextPosition");
+        firePropertyChange("horizontalTextPosition", oldPos, 
+                           horizontalTextPosition);
+      }
+  }
+
+  /**
+   * Returns false if the current icon image (current icon will depend on 
+   * whether the label is enabled) is not equal to the passed in image.
+   *
+   * @param img The image to check.
+   * @param infoflags The bitwise inclusive OR of ABORT, ALLBITS, ERROR,
+   *        FRAMEBITS, HEIGHT, PROPERTIES, SOMEBITS, and WIDTH
+   * @param x The x position
+   * @param y The y position
+   * @param w The width
+   * @param h The height
+   *
+   * @return Whether the current icon image is equal to the image given.
+   */
+  public boolean imageUpdate(Image img, int infoflags, int x, int y, int w,
+                             int h)
+  {
+    Icon currIcon = isEnabled() ? icon : disabledIcon;
+
+    // XXX: Is this the correct way to check for image equality?
+    if (currIcon != null && currIcon instanceof ImageIcon)
+      return (((ImageIcon) currIcon).getImage() == img);
+
+    return false;
+  }
+
+  /**
+   * Returns the component that this <code>JLabel</code> is providing the label
+   * for.  This component will typically receive the focus when the label's 
+   * mnemonic key is activated via the keyboard.
+   *
+   * @return The component (possibly <code>null</code>).
+   */
+  public Component getLabelFor()
+  {
+    return labelFor;
+  }
+
+  /**
+   * Sets the component that this <code>JLabel</code> is providing the label
+   * for (this is a bound property with the name 'labelFor').  This component
+   * will typically receive the focus when the label's mnemonic key is 
+   * activated via the keyboard.
+   *
+   * @param c  the component (<code>null</code> permitted).
+   * 
+   * @see #getLabelFor()
+   */
+  public void setLabelFor(Component c)
+  {
+    if (c != labelFor)
+      {
+        Component oldLabelFor = labelFor;
+        labelFor = c;
+        firePropertyChange("labelFor", oldLabelFor, labelFor);
+
+        // We put the label into the client properties for the labeled
+        // component so that it can be read by the AccessibleJComponent.
+        // The other option would be to reserve a default visible field
+        // in JComponent, but since this is relatively seldomly used, it
+        // would be unnecessary waste of memory to do so.
+        if (oldLabelFor instanceof JComponent)
+          {
+            ((JComponent) oldLabelFor).putClientProperty(LABEL_PROPERTY, null);
+          }
+
+        if (labelFor instanceof JComponent)
+          {
+            ((JComponent) labelFor).putClientProperty(LABEL_PROPERTY, this);
+          }
+
+      }
+  }
+
+  /**
+   * Sets the font for the label (this a bound property with the name 'font').
+   *
+   * @param f The font (<code>null</code> permitted).
+   */
+  public void setFont(Font f)
+  {
+    super.setFont(f);
+    repaint();
+  }
+
+  /**
+   * Returns the object that provides accessibility features for this
+   * <code>JLabel</code> component.
+   *
+   * @return The accessible context (an instance of {@link AccessibleJLabel}).
+   */
+  public AccessibleContext getAccessibleContext()
+  {
+    if (accessibleContext == null)
+      accessibleContext = new AccessibleJLabel();
+    return accessibleContext;
+  }
+}

Added: llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JLayeredPane.java
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JLayeredPane.java?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JLayeredPane.java (added)
+++ llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JLayeredPane.java Thu Nov  8 16:56:19 2007
@@ -0,0 +1,755 @@
+/* JLayeredPane.java -- 
+   Copyright (C) 2002, 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., 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;
+
+import java.awt.Color;
+import java.awt.Component;
+import java.awt.Container;
+import java.awt.Graphics;
+import java.awt.Rectangle;
+import java.util.ArrayList;
+import java.util.Hashtable;
+
+import javax.accessibility.Accessible;
+import javax.accessibility.AccessibleContext;
+import javax.accessibility.AccessibleRole;
+
+/**
+ * A container that adds depth to the usual <code>Container</code> semantics.
+ * Each child component of a <code>Layered Pane</code> is placed within one
+ * of several layers. <code>JLayeredPane</code> defines a set of standard
+ * layers. The pre-defined sets are (in the order from button to top):
+ *
+ *  <dl>
+ *    <dt>{@link #DEFAULT_LAYER}</dt>
+ *    <dd>The layer where most of the normal components are placed. This
+ *      is the bottommost layer.</dd>
+ *
+ *    <dt>{@link #PALETTE_LAYER}</dt>
+ *    <dd>Palette windows are placed in this layer.</dd>
+ *
+ *    <dt>{@link #MODAL_LAYER}</dt>
+ *    <dd>The layer where internal modal dialog windows are placed.</dd>
+ *
+ *    <dt>{@link #POPUP_LAYER}</dt>
+ *    <dd>The layer for popup menus</dd>
+ *
+ *    <dt>{@link #DRAG_LAYER}</dt>
+ *    <dd>Components that are beeing dragged are temporarily placed in
+ *       this layer.</dd>
+ *  </dl>
+ *
+ * <p>A child is in exactly one of these layers at any time, though there may
+ * be other layers if someone creates them.</p>
+ *
+ * <p>You can add a component to a specific layer using the
+ * {@link Container#add(Component, Object)} method. I.e.
+ * <code>layeredPane.add(comp, JLayeredPane.MODAL_LAYER)</code> will add the
+ * component <code>comp</code> to the modal layer of <code>layeredPane</code>.
+ * </p>
+ *
+ * <p>To change the layer of a component that is already a child of
+ * a <code>JLayeredPane</code>, use the {@link #setLayer(Component, int)} 
+ * method.</p>
+ *
+ * <p>The purpose of this class is to translate this view of "layers" into a
+ * contiguous array of components: the one held in our ancestor,
+ * {@link java.awt.Container}.</p>
+ *
+ * <p>There is a precise set of words we will use to refer to numbers within
+ * this class:</p>
+ * 
+ * <dl>
+ * <dt>Component Index:</dt> 
+ * <dd>An offset into the <code>component</code> array held in our ancestor,
+ * {@link java.awt.Container}, from <code>[0 .. component.length)</code>. The drawing
+ * rule with indices is that 0 is drawn last.</dd>
+ *
+ * <dt>Layer Number:</dt>
+ * <dd>A general <code>int</code> specifying a layer within this component.  Negative
+ * numbers are drawn first, then layer 0, then positive numbered layers, in
+ * ascending order.</dd>
+ *
+ * <dt>Position:</dt> 
+ * <dd>An offset into a layer's "logical drawing order". Layer position 0
+ * is drawn last. Layer position -1 is a synonym for the first layer
+ * position (the logical "bottom").</dd>
+ * </dl>
+ *
+ * <p><b>Note:</b> the layer numbering order is the <em>reverse</em> of the
+ * component indexing and position order</p>
+ *
+ * @author Graydon Hoare (graydon at redhat.com)
+ * @author Roman Kennke (kennke at aicas.com)
+ */
+public class JLayeredPane extends JComponent implements Accessible
+{
+  
+  /**
+   * Provides accessibility support for <code>JLayeredPane</code>.
+   */
+  protected class AccessibleJLayeredPane extends AccessibleJComponent
+  {
+    /**
+     * Creates a new instance of <code>AccessibleJLayeredPane</code>.
+     */
+    protected AccessibleJLayeredPane()
+    {
+      // Nothing to do here.
+    }
+
+    /**
+     * Returns the accessble role of <code>JLayeredPane</code>,
+     * {@link AccessibleRole#LAYERED_PANE}. 
+     */
+    public AccessibleRole getAccessibleRole()
+    {
+      return AccessibleRole.LAYERED_PANE;
+    }
+  }
+
+  private static final long serialVersionUID = 5534920399324590459L;
+  
+  public static final String LAYER_PROPERTY = "layeredContainerLayer";
+
+  public static final Integer FRAME_CONTENT_LAYER = new Integer(-30000);
+
+  public static final Integer DEFAULT_LAYER = new Integer(0);
+  public static final Integer PALETTE_LAYER = new Integer(100);
+  public static final Integer MODAL_LAYER   = new Integer(200);
+  public static final Integer POPUP_LAYER   = new Integer(300);
+  public static final Integer DRAG_LAYER    = new Integer(400);
+
+  private Hashtable componentToLayer;   // Component -> Layer Number (Integer)
+
+  public JLayeredPane()
+  {
+    componentToLayer = new Hashtable();
+    setLayout(null);
+  }
+
+  /** 
+   * Looks up the layer a child component is currently assigned to.
+   *
+   * If <code>c</code> is an instance of {@link JComponent}, then the layer
+   * is fetched from the client property with the key {@link #LAYER_PROPERTY}.
+   * Otherwise it is looked up in an internal hashtable that maps
+   * non-JComponent components to layers. If the components cannot be found
+   * in either way, the {@link #DEFAULT_LAYER} is returned.
+   *
+   * @param c the component to look up.
+   *
+   * @return the layer the component is currently assigned to; if the component
+   *         is not in this layered pane, then 0 (DEFAULT_LAYER) is returned
+   */
+  public int getLayer(Component c)
+  {
+    Integer layerObj;
+    if (c instanceof JComponent)
+      {
+        JComponent jc = (JComponent) c;
+        layerObj = (Integer) jc.getClientProperty(LAYER_PROPERTY);
+      }
+    else
+      layerObj = (Integer) componentToLayer.get(c);
+
+    if (layerObj == null)
+      layerObj = DEFAULT_LAYER;
+
+    return layerObj.intValue();
+  }
+
+  /**
+   * Looks up the layer in the client property with the key
+   * {@link #LAYER_PROPERTY} of <code>comp</code>. If no such property can be
+   * found, we return <code>0</code> ({@link #DEFAULT_LAYER}).
+   * 
+   * @param comp the component for which the layer is looked up
+   *
+   * @return the layer of <code>comp</code> as stored in the corresponding
+   *         client property, or <code>0</code> if there is no such property
+   */
+  public static int getLayer(JComponent comp)
+  {
+    Integer layerObj = (Integer) comp.getClientProperty(LAYER_PROPERTY);
+    if (layerObj == null)
+      layerObj = DEFAULT_LAYER;
+    return layerObj.intValue();
+  }
+
+  /**
+   * Returns the first JLayeredPane that contains the Component
+   * <code>comp</code> or <code>null</code> if <code>comp</code> is
+   * not contained in a JLayeredPane.
+   *
+   * @param comp the component for which we are searching the JLayeredPane
+   *     ancestor
+   *
+   * @return the first JLayeredPane that contains the Component
+   *     <code>comp</code> or <code>null</code> if <code>comp</code> is
+   *     not contained in a JLayeredPane
+   */
+  public static JLayeredPane getLayeredPaneAbove(Component comp)
+  {
+    JLayeredPane lp = (JLayeredPane) SwingUtilities.getAncestorOfClass
+      (JLayeredPane.class, comp);
+    return lp;
+  }
+
+  /**
+   * Return the greatest layer number currently in use, in this container.
+   * This number may legally be positive <em>or</em> negative.
+   *
+   * @return the highest layer number
+   *
+   * @see #lowestLayer()
+   */
+  public int highestLayer()
+  {
+    Component[] components = getComponents();
+    int highest;
+    if (components.length == 0)
+      highest = 0;
+    else
+      {
+        highest = Integer.MIN_VALUE;
+        for (int i = 0; i < components.length; i++)
+          highest = Math.max(highest, getLayer(components[i]));
+      }
+    return highest;
+  }
+
+  /**
+   * Return the least layer number currently in use, in this container.
+   * This number may legally be positive <em>or</em> negative.
+   *
+   * @return the least layer number
+   *
+   * @see #highestLayer()
+   */
+  public int lowestLayer()
+  {
+    Component[] components = getComponents();
+    int lowest;
+    if (components.length == 0)
+      lowest = 0;
+    else
+      {
+        lowest = Integer.MAX_VALUE;
+        for (int i = 0; i < components.length; i++)
+          lowest = Math.max(lowest, getLayer(components[i]));
+      }
+    return lowest;
+  }
+
+  /**
+   * Moves a component to the "front" of its layer. The "front" is a
+   * synonym for position 0, which is also the last position drawn in each
+   * layer, so is usually the component which occludes the most other
+   * components in its layer.
+   *
+   * @param c the component to move to the front of its layer
+   *
+   * @see #moveToBack
+   */
+  public void moveToFront(Component c)
+  {
+    setPosition (c, 0);
+  }
+
+  /**
+   * <p>Moves a component to the "back" of its layer. The "back" is a
+   * synonym for position N-1 (also known as position -1), where N is the
+   * size of the layer.</p>
+   *
+   * <p>The "back" of a layer is the first position drawn, so the component at
+   * the "back" is usually the component which is occluded by the most
+   * other components in its layer.</p>
+   *
+   * @param c the component to move to the back of its layer.
+   *
+   * @see #moveToFront
+   */
+  public void moveToBack(Component c)
+  {
+    setPosition (c, -1);
+  }
+
+  /**
+   * Return the position of a component within its layer. Positions are assigned
+   * from the "front" (position 0) to the "back" (position N-1), and drawn from 
+   * the back towards the front.
+   *
+   * @param c the component to get the position of
+   *
+   * @return the position of <code>c</code> within its layer or -1 if
+   *         <code>c</code> is not a child of this layered pane
+   *
+   * @see #setPosition
+   */
+  public int getPosition(Component c)
+  {
+    int pos = -1;
+    int index = getIndexOf(c);
+    if (index >= 0)
+      {
+        pos = 0;
+        int layer = getLayer(c);
+        for (int i = index - 1; i >= 0; --i)
+          {
+            if (layer == getLayer(getComponent(i)))
+              pos++;
+            else
+              break;
+          }
+      }
+    return pos;
+  }
+
+  /**
+   * Change the position of a component within its layer. Positions are assigned
+   * from the "front" (position 0) to the "back" (position N-1), and drawn from 
+   * the back towards the front.
+   *
+   * @param c the component to change the position of
+   * @param position the position to assign the component to
+   *
+   * @see #getPosition
+   */
+  public void setPosition(Component c, int position)
+  {
+    setLayer(c, getLayer(c), position);
+  }
+    
+  /**
+   * Return an array of all components within a layer of this
+   * container. Components are ordered front-to-back, with the "front"
+   * element (which draws last) at position 0 of the returned array.
+   *
+   * @param layer the layer to return components from
+   *
+   * @return the components in the layer
+   */
+  public Component[] getComponentsInLayer(int layer)
+  {
+    Component[] inLayer = new Component[getComponentCountInLayer(layer)];
+    Component[] components = getComponents();
+    int j = 0;
+    for (int i = 0; i < components.length; ++i)
+      {
+        if (layer == getLayer(components[i]))
+          {
+            inLayer[j] = components[i];
+            j++;
+          }
+      }
+    return inLayer;
+  }
+
+  /**
+   * Return the number of components within a layer of this
+   * container.
+   *
+   * @param layer the layer count components in
+   *
+   * @return the number of components in the layer
+   */
+  public int getComponentCountInLayer(int layer)
+  {
+    Component[] components = getComponents();
+    int count = 0;
+    for (int i = components.length - 1; i >= 0; --i)
+      {
+        if (getLayer(components[i]) == layer)
+          count++;
+      }
+    return count;
+  }
+
+  /**
+   * Return a hashtable mapping child components of this container to
+   * Integer objects representing the component's layer assignments.
+   */
+  protected Hashtable getComponentToLayer()
+  {
+    return componentToLayer;
+  }
+
+  /**
+   * Return the index of a component within the underlying (contiguous)
+   * array of children. This is a "raw" number which does not represent the
+   * child's position in a layer, but rather its position in the logical
+   * drawing order of all children of the container.
+   *
+   * @param c the component to look up.
+   *
+   * @return the external index of the component or <code>-1</code> if
+   *         <code>c</code> is not a child of this layered pane 
+   */
+  public int getIndexOf(Component c) 
+  {
+    return getComponentZOrder(c);
+  }
+
+  /**
+   * Return an Integer object which holds the same int value as the
+   * parameter. This is strictly an optimization to minimize the number of
+   * identical Integer objects which we allocate.
+   *
+   * @param layer the layer number as an int.
+   *
+   * @return the layer number as an Integer, possibly shared.
+   */
+  protected Integer getObjectForLayer(int layer)
+  {
+    switch (layer)
+	    {
+	    case -30000:
+        return FRAME_CONTENT_LAYER;
+
+	    case 0:
+        return DEFAULT_LAYER;
+
+	    case 100:
+        return PALETTE_LAYER;
+
+	    case 200:
+        return MODAL_LAYER;
+
+	    case 300:
+        return POPUP_LAYER;
+
+	    case 400:
+        return DRAG_LAYER;
+
+	    default:
+        break;
+	    }
+
+    return new Integer(layer);
+  }
+
+  /**
+   * Computes an index at which to request the superclass {@link
+   * java.awt.Container} inserts a component, given an abstract layer and
+   * position number.
+   *
+   * @param layer the layer in which to insert a component.
+   * @param position the position in the layer at which to insert a component.
+   *
+   * @return the index at which to insert the component.
+   */
+  protected int insertIndexForLayer(int layer, int position)
+  {
+    return insertIndexForLayer(null, layer, position);
+  }
+
+  /**
+   * Similar to {@link #insertIndexForLayer(int, int)}, only that it takes a
+   * component parameter, which should be ignored in the search. This is
+   * necessary to support {@link #setLayer(Component, int, int)} which uses
+   * Container.setComponentZOrder(), which doesn't remove the component.
+   *
+   * @param comp the component to ignore
+   * @param layer the layer
+   * @param position the position
+   *
+   * @return the insertion index
+   */
+  private int insertIndexForLayer(Component comp, int layer, int position)
+  {
+    // Create the component list to search through.
+    ArrayList l = new ArrayList();
+    int count = getComponentCount();
+    for (int i = 0; i < count; i++)
+      {
+        Component c = getComponent(i);
+        if (c != comp)
+          l.add(c);
+      }
+
+    count = l.size();
+    int layerStart = -1;
+    int layerEnd = -1;
+    for (int i = 0; i < count; i++)
+      {
+        int layerOfComponent = getLayer((Component) l.get(i));
+        if (layerStart == -1 && layerOfComponent == layer)
+          layerStart = i;
+        if (layerOfComponent < layer)
+          {
+            // We are beyond the layer that we are looking for. Update the
+            // layerStart and layerEnd and exit the loop.
+            if (i == 0)
+              {
+                layerStart = 0;
+                layerEnd = 0;
+              }
+            else
+              layerEnd = i;
+            break;
+          }
+      }
+
+    // No layer found. The requested layer is lower than any existing layer,
+    // put the component at the end.
+    int insertIndex;
+    if (layerStart == -1 && layerEnd == -1)
+      {
+        insertIndex = count;
+      }
+    else
+      {
+        // Corner cases.
+        if (layerStart != -1 && layerEnd == -1)
+          layerEnd = count;
+        if (layerStart == -1 && layerEnd != -1)
+          layerStart = layerEnd;
+
+        // Adding to the bottom of a layer returns the end index
+        // in the layer.
+        if (position == -1)
+          insertIndex = layerEnd;
+        else
+          {
+            // Insert into a layer.
+            if (position > -1 && layerStart + position <= layerEnd)
+              insertIndex = layerStart + position;
+            else
+              insertIndex = layerEnd;
+          }
+      }
+    return insertIndex;
+  }
+
+  /**
+   * Removes a child from this container. The child is specified by
+   * index. After removal, the child no longer occupies a layer.
+   *
+   * @param index the index of the child component to remove.
+   */
+  public void remove(int index)
+  {
+    Component c = getComponent(index);
+    if (! (c instanceof JComponent))
+      componentToLayer.remove(c);
+    super.remove(index);
+  }
+
+  /**
+   * Removes all components from this container.
+   *
+   * @since 1.5
+   */
+  public void removeAll()
+  {
+	componentToLayer.clear();
+	super.removeAll();
+  }
+
+  /**
+   * <p>Set the layer property for a component, within this container. The
+   * component will be implicitly mapped to the bottom-most position in the
+   * layer, but only if added <em>after</em> calling this method.</p>
+   *
+   * <p>Read that carefully: this method should be called <em>before</em> the
+   * component is added to the container.</p>
+   *
+   * @param c the component to set the layer property for.
+   * @param layer the layer number to assign to the component.
+   */
+  public void setLayer(Component c, int layer)
+  {
+    setLayer(c, layer, -1);
+  }
+
+  /**
+   * Set the layer and position of a component, within this container.
+   *
+   * @param c the child component to set the layer property for.
+   * @param layer the layer number to assign to the component.
+   * @param position the position number to assign to the component.
+   */
+  public void setLayer(Component c, int layer, int position)
+  {
+    Integer layerObj = getObjectForLayer(layer);
+
+    // Nothing to do if neither the layer nor the position is
+    // changed.
+    if (layer != getLayer(c) || position != getPosition(c))
+      {
+        // Store the layer either in the JComponent or in the hashtable
+        if (c instanceof JComponent)
+          {
+            JComponent jc = (JComponent) c;
+            jc.putClientProperty(LAYER_PROPERTY, layerObj);
+          }
+        else
+          componentToLayer.put (c, layerObj);
+
+        // Update the component in the Z order of the Container.
+        Container parent = c.getParent();
+        if (parent == this)
+          {
+            int index = insertIndexForLayer(c, layer, position);
+            setComponentZOrder(c, index);
+          }
+      }
+    repaint(c.getX(), c.getY(), c.getWidth(), c.getHeight());
+  }
+
+  /**
+   * Overrides the default implementation from {@link java.awt.Container}
+   * such that <code>layerConstraint</code> is interpreted as an {@link
+   * Integer}, specifying the layer to which the component will be added
+   * (at the bottom position).
+   *
+   * The argument <code>index</code> specifies the position within the layer
+   * at which the component should be added, where <code>0</code> is the top
+   * position greater values specify positions below that and <code>-1</code>
+   * specifies the bottom position.
+   *
+   * @param comp the component to add
+   * @param layerConstraint an integer specifying the layer to add the
+   *        component to
+   * @param index the position within the layer
+   */
+  protected void addImpl(Component comp, Object layerConstraint, int index) 
+  {
+    int layer;
+    if (layerConstraint != null && layerConstraint instanceof Integer)
+      {
+        layer = ((Integer) layerConstraint).intValue();
+        setLayer(comp, layer);
+      }
+    else
+      layer = getLayer(comp);
+
+    int newIdx = insertIndexForLayer(layer, index);
+    super.addImpl(comp, layerConstraint, newIdx);
+    comp.validate();
+    comp.repaint();
+  }
+
+  /**
+   * Sets the layer property for a JComponent.
+   *
+   * @param component the component for which to set the layer
+   * @param layer the layer property to set
+   */
+  public static void putLayer(JComponent component, int layer)
+  {
+    component.putClientProperty(LAYER_PROPERTY, new Integer(layer));
+  }
+
+  /**
+   * Returns the accessible context for this <code>JLayeredPane</code>.
+   *
+   * @return the accessible context for this <code>JLayeredPane</code>
+   */
+  public AccessibleContext getAccessibleContext()
+  {
+    if (accessibleContext == null)
+      accessibleContext = new AccessibleJLayeredPane();
+    return accessibleContext;
+  }
+
+  /**
+   * This method is overridden order to provide a reasonable painting
+   * mechanism for <code>JLayeredPane</code>. This is necessary since
+   * <code>JLayeredPane</code>'s do not have an own UI delegate.
+   *
+   * Basically this method clears the background for the
+   * <code>JLayeredPane</code> and then calls <code>super.paint(g)</code>.
+   *
+   * @param g the graphics context to use
+   */
+  public void paint(Graphics g)
+  {
+    if (isOpaque())
+      {
+        Color oldColor = g.getColor();
+        Rectangle clip = g.getClipBounds();
+        g.setColor(getBackground());
+        g.fillRect(clip.x, clip.y, clip.width, clip.height);
+        g.setColor(oldColor);
+      }
+    super.paint(g);
+  }
+
+  /**
+   * Returns <code>false</code> if components in this layered pane can overlap,
+   * otherwise <code>true</code>.
+   *
+   * @return <code>false</code> if components in this layered pane can overlap,
+   *         otherwise <code>true</code>
+   */
+  public boolean isOptimizedDrawingEnabled()
+  {
+    int numChildren = getComponentCount();
+    boolean result = true;
+    for (int i = 0; i < numChildren; ++i)
+      {
+    	Component c1 = getComponent(i);
+    	if (! c1.isVisible())
+          continue;
+    	Rectangle r1 = c1.getBounds();
+    	if (r1.isEmpty())
+          continue;
+
+    	for (int j = i + 1; j < numChildren; ++j)
+          {
+            Component c2 = getComponent(j);
+            if (! c2.isVisible())
+              continue;
+            Rectangle r2 = c2.getBounds();
+            if (r2.isEmpty())
+              continue;
+            if (r1.intersects(r2))
+              {
+                result = false;
+                break;
+              }
+            if (result == false)
+              break;
+          }
+      }
+    return result;
+  }
+}

Added: llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JList.java
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JList.java?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JList.java (added)
+++ llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JList.java Thu Nov  8 16:56:19 2007
@@ -0,0 +1,2374 @@
+/* JList.java --
+   Copyright (C) 2002, 2003, 2004, 2005, 2006,  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;
+
+import java.awt.Color;
+import java.awt.Component;
+import java.awt.ComponentOrientation;
+import java.awt.Cursor;
+import java.awt.Dimension;
+import java.awt.Font;
+import java.awt.FontMetrics;
+import java.awt.Point;
+import java.awt.Rectangle;
+import java.awt.event.FocusListener;
+import java.beans.PropertyChangeEvent;
+import java.beans.PropertyChangeListener;
+import java.util.Locale;
+import java.util.Vector;
+
+import javax.accessibility.Accessible;
+import javax.accessibility.AccessibleComponent;
+import javax.accessibility.AccessibleContext;
+import javax.accessibility.AccessibleRole;
+import javax.accessibility.AccessibleSelection;
+import javax.accessibility.AccessibleState;
+import javax.accessibility.AccessibleStateSet;
+import javax.swing.event.ListDataEvent;
+import javax.swing.event.ListDataListener;
+import javax.swing.event.ListSelectionEvent;
+import javax.swing.event.ListSelectionListener;
+import javax.swing.plaf.ListUI;
+import javax.swing.text.Position;
+
+/**
+ * <p>This class is a facade over three separate objects: {@link
+ * javax.swing.ListModel}, {@link javax.swing.ListSelectionModel} and
+ * {@link javax.swing.plaf.ListUI}. The facade represents a unified "list"
+ * concept, with independently replacable (possibly client-provided) models
+ * for its contents and its current selection. In addition, each element in
+ * the list is rendered via a strategy class {@link
+ * javax.swing.ListCellRenderer}.</p>
+ *
+ * <p>Lists have many properties, some of which are stored in this class
+ * while others are delegated to the list's model or selection. The
+ * following properties are available:</p>
+ *
+ * <table>
+ * <tr><th>Property                       </th><th>Stored in</th><th>Bound?</th></tr>
+ * <tr><td>accessibleContext              </td><td>list     </td><td>no    </td></tr>
+ * <tr><td>anchorSelectionIndex           </td><td>selection</td><td>no    </td></tr>
+ * <tr><td>cellRenderer                   </td><td>list     </td><td>yes   </td></tr>
+ * <tr><td>dragEnabled                    </td><td>list     </td><td>no    </td></tr>
+ * <tr><td>firstVisibleIndex              </td><td>list     </td><td>no    </td></tr>
+ * <tr><td>fixedCellHeight                </td><td>list     </td><td>yes   </td></tr>
+ * <tr><td>fixedCellWidth                 </td><td>list     </td><td>yes   </td></tr>
+ * <tr><td>lastVisibleIndex               </td><td>list     </td><td>no    </td></tr>
+ * <tr><td>layoutOrientation              </td><td>list     </td><td>yes   </td></tr>
+ * <tr><td>leadSelectionIndex             </td><td>selection</td><td>no    </td></tr>
+ * <tr><td>maxSelectionIndex              </td><td>selection</td><td>no    </td></tr>
+ * <tr><td>minSelectionIndex              </td><td>selection</td><td>no    </td></tr>
+ * <tr><td>model                          </td><td>list     </td><td>yes   </td></tr>
+ * <tr><td>opaque                         </td><td>list     </td><td>no    </td></tr>
+ * <tr><td>preferredScrollableViewportSize</td><td>list     </td><td>no    </td></tr>
+ * <tr><td>prototypeCellValue             </td><td>list     </td><td>yes   </td></tr>
+ * <tr><td>scrollableTracksViewportHeight </td><td>list     </td><td>no    </td></tr>
+ * <tr><td>scrollableTracksViewportWidth  </td><td>list     </td><td>no    </td></tr>
+ * <tr><td>selectedIndex                  </td><td>selection</td><td>no    </td></tr>
+ * <tr><td>selectedIndices                </td><td>selection</td><td>no    </td></tr>
+ * <tr><td>selectedValue                  </td><td>model    </td><td>no    </td></tr>
+ * <tr><td>selectedValues                 </td><td>model    </td><td>no    </td></tr>
+ * <tr><td>selectionBackground            </td><td>list     </td><td>yes   </td></tr>
+ * <tr><td>selectionEmpty                 </td><td>selection</td><td>no    </td></tr>
+ * <tr><td>selectionForeground            </td><td>list     </td><td>yes   </td></tr>
+ * <tr><td>selectionMode                  </td><td>selection</td><td>no    </td></tr>
+ * <tr><td>selectionModel                 </td><td>list     </td><td>yes   </td></tr>
+ * <tr><td>UI                             </td><td>list     </td><td>yes   </td></tr>
+ * <tr><td>UIClassID                      </td><td>list     </td><td>no    </td></tr>
+ * <tr><td>valueIsAdjusting               </td><td>list     </td><td>no    </td></tr>
+ * <tr><td>visibleRowCount                </td><td>list     </td><td>no    </td></tr>
+ * </table> 
+ *
+ * @author Graydon Hoare (graydon at redhat.com)
+ */
+
+public class JList extends JComponent implements Accessible, Scrollable
+{
+
+  /**
+   * Provides accessibility support for <code>JList</code>.
+   */
+  protected class AccessibleJList extends AccessibleJComponent
+    implements AccessibleSelection, PropertyChangeListener,
+               ListSelectionListener, ListDataListener
+  {
+
+    /**
+     * Provides accessibility support for list elements in <code>JList</code>s.
+     */
+    protected class AccessibleJListChild extends AccessibleContext
+      implements Accessible, AccessibleComponent
+    {
+
+      /**
+       * The parent list.
+       */
+      JList parent;
+
+      /**
+       * The index in the list for that child.
+       */
+      int listIndex;
+
+      /**
+       * The cursor for this list child.
+       */
+      // TODO: Testcases show that this class somehow stores state about the
+      // cursor. I cannot make up though how that could affect
+      // the actual list.
+      Cursor cursor = Cursor.getDefaultCursor();
+
+      /**
+       * Creates a new instance of <code>AccessibleJListChild</code>.
+       *
+       * @param list the list of which this is an accessible child
+       * @param index the list index for this child
+       */
+      public AccessibleJListChild(JList list, int index)
+      {
+        parent = list;
+        listIndex = index;
+      }
+
+      /**
+       * Returns the accessible context of this object. Returns
+       * <code>this</code> since <code>AccessibleJListChild</code>s are their
+       * own accessible contexts.
+       *
+       * @return the accessible context of this object, <code>this</code>
+       */
+      public AccessibleContext getAccessibleContext()
+      {
+        return this;
+      }
+
+      /**
+       * Returns the background color for this list child. This returns the
+       * background of the <code>JList</code> itself since the background
+       * cannot be set on list children individually
+       *
+       * @return the background color for this list child
+       */
+      public Color getBackground()
+      {
+        return parent.getBackground();
+      }
+
+      /**
+       * Calling this method has no effect, since the background color cannot be
+       * set on list children individually.
+       *
+       * @param color not used here.
+       */
+      public void setBackground(Color color)
+      {
+        // Calling this method has no effect, since the background color cannot
+        // be set on list children individually.
+      }
+
+      /**
+       * Returns the foreground color for this list child. This returns the
+       * background of the <code>JList</code> itself since the foreground
+       * cannot be set on list children individually.
+       *
+       * @return the background color for this list child
+       */
+      public Color getForeground()
+      {
+        return parent.getForeground();
+      }
+
+      /**
+       * Calling this method has no effect, since the foreground color cannot be
+       * set on list children individually.
+       *
+       * @param color not used here.
+       */
+      public void setForeground(Color color)
+      {
+        // Calling this method has no effect, since the foreground color cannot
+        // be set on list children individually.
+      }
+
+      /**
+       * Returns the cursor for this list child.
+       *
+       * @return the cursor for this list child
+       */
+      public Cursor getCursor()
+      {
+        // TODO: Testcases show that this method returns the cursor that has
+        // been set by setCursor. I cannot make up though how that could affect
+        // the actual list.
+        return cursor;
+      }
+
+      /**
+       * Sets the cursor for this list child.
+       */
+      public void setCursor(Cursor cursor)
+      {
+        this.cursor = cursor;
+        // TODO: Testcases show that this method returns the cursor that has
+        // been set by setCursor. I cannot make up though how that could affect
+        // the actual list.
+      }
+
+      /**
+       * Returns the font of the <code>JList</code> since it is not possible to
+       * set fonts for list children individually.
+       *
+       * @return the font of the <code>JList</code>
+       */
+      public Font getFont()
+      {
+        return parent.getFont();
+      }
+
+      /**
+       * Does nothing since it is not possible to set the font on list children
+       * individually.
+       *
+       * @param font not used here
+       */
+      public void setFont(Font font)
+      {
+        // Does nothing since it is not possible to set the font on list
+        // children individually.
+      }
+
+      /**
+       * Returns the font metrics for the specified font. This method forwards
+       * to the parent <code>JList</code>. 
+       *
+       * @param font the font for which the font metrics is queried
+       *
+       * @return the font metrics for the specified font
+       */
+      public FontMetrics getFontMetrics(Font font)
+      {
+        return parent.getFontMetrics(font);
+      }
+
+      /**
+       * Returns <code>true</code> if the parent <code>JList</code> is enabled,
+       * <code>false</code> otherwise. The list children cannot have an enabled
+       * flag set individually.
+       *
+       * @return <code>true</code> if the parent <code>JList</code> is enabled,
+       *         <code>false</code> otherwise
+       */
+      public boolean isEnabled()
+      {
+        return parent.isEnabled();
+      }
+
+      /**
+       * Does nothing since the enabled flag cannot be set for list children
+       * individually.
+       *
+       * @param b not used here
+       */
+      public void setEnabled(boolean b)
+      {
+        // Does nothing since the enabled flag cannot be set for list children
+        // individually.
+      }
+
+      /**
+       * Returns <code>true</code> if this list child is visible,
+       * <code>false</code> otherwise. The value of this property depends
+       * on {@link JList#getFirstVisibleIndex()} and
+       * {@link JList#getLastVisibleIndex()}.
+       *
+       * @return <code>true</code> if this list child is visible,
+       *         <code>false</code> otherwise
+       */
+      public boolean isVisible()
+      {
+        return listIndex >= parent.getFirstVisibleIndex()
+               && listIndex <= parent.getLastVisibleIndex();
+      }
+
+      /**
+       * The value of the visible property cannot be modified, so this method
+       * does nothing.
+       *
+       * @param b not used here
+       */
+      public void setVisible(boolean b)
+      {
+        // The value of the visible property cannot be modified, so this method
+        // does nothing.
+      }
+
+      /**
+       * Returns <code>true</code> if this list child is currently showing on
+       * screen and <code>false</code> otherwise. The list child is showing if
+       * it is visible and if it's parent JList is currently showing.
+       *
+       * @return <code>true</code> if this list child is currently showing on
+       *         screen and <code>false</code> otherwise
+       */
+      public boolean isShowing()
+      {
+        return isVisible() && parent.isShowing();
+      }
+
+      /**
+       * Returns <code>true</code> if this list child covers the screen location
+       * <code>point</code> (relative to the <code>JList</code> coordinate
+       * system, <code>false</code> otherwise.
+       *
+       * @return <code>true</code> if this list child covers the screen location
+       *         <code>point</code> , <code>false</code> otherwise
+       */
+      public boolean contains(Point point)
+      {
+        return getBounds().contains(point);
+      }
+
+      /**
+       * Returns the absolute screen location of this list child.
+       *
+       * @return the absolute screen location of this list child
+       */
+      public Point getLocationOnScreen()
+      {
+        Point loc = getLocation();
+        SwingUtilities.convertPointToScreen(loc, parent);
+        return loc;
+      }
+
+      /**
+       * Returns the screen location of this list child relative to it's parent.
+       *
+       * @return the location of this list child relative to it's parent
+       *
+       * @see JList#indexToLocation(int)
+       */
+      public Point getLocation()
+      {
+        return parent.indexToLocation(listIndex);
+      }
+
+      /**
+       * Does nothing since the screen location cannot be set on list children
+       * explictitly.
+       *
+       * @param point not used here
+       */
+      public void setLocation(Point point)
+      {
+        // Does nothing since the screen location cannot be set on list children
+        // explictitly.
+      }
+
+      /**
+       * Returns the bounds of this list child.
+       *
+       * @return the bounds of this list child
+       *
+       * @see JList#getCellBounds(int, int)
+       */
+      public Rectangle getBounds()
+      {
+        return parent.getCellBounds(listIndex, listIndex);
+      }
+
+      /**
+       * Does nothing since the bounds cannot be set on list children
+       * individually.
+       *
+       * @param rectangle not used here
+       */
+      public void setBounds(Rectangle rectangle)
+      {
+        // Does nothing since the bounds cannot be set on list children
+        // individually.
+      }
+
+      /**
+       * Returns the size of this list child.
+       *
+       * @return the size of this list child
+       */
+      public Dimension getSize()
+      {
+        Rectangle b = getBounds();
+        return b.getSize();
+      }
+
+      /**
+       * Does nothing since the size cannot be set on list children
+       * individually.
+       *
+       * @param dimension not used here
+       */
+      public void setSize(Dimension dimension)
+      {
+        // Does nothing since the size cannot be set on list children
+        // individually.
+      }
+
+      /**
+       * Returns <code>null</code> because list children do not have children
+       * themselves
+       *
+       * @return <code>null</code>
+       */
+      public Accessible getAccessibleAt(Point point)
+      {
+        return null;
+      }
+
+      /**
+       * Returns <code>true</code> since list children are focus traversable.
+       *
+       * @return true
+       */
+      public boolean isFocusTraversable()
+      {
+        // TODO: Is this 100% ok?
+        return true;
+      }
+
+      /**
+       * Requests focus on the parent list. List children cannot request focus
+       * individually.
+       */
+      public void requestFocus()
+      {
+        // TODO: Is this 100% ok?
+        parent.requestFocus();
+      }
+
+      /**
+       * Adds a focus listener to the parent list. List children do not have
+       * their own focus management.
+       *
+       * @param listener the focus listener to add
+       */
+      public void addFocusListener(FocusListener listener)
+      {
+        // TODO: Is this 100% ok?
+        parent.addFocusListener(listener);
+      }
+
+      /**
+       * Removes a focus listener from the parent list. List children do not
+       * have their own focus management.
+       *
+       * @param listener the focus listener to remove
+       */
+      public void removeFocusListener(FocusListener listener)
+      {
+        // TODO: Is this 100%
+        parent.removeFocusListener(listener);
+      }
+
+      /**
+       * Returns the accessible role of this list item, which is
+       * {@link AccessibleRole#LABEL}.
+       *
+       * @return {@link AccessibleRole#LABEL}
+       */
+      public AccessibleRole getAccessibleRole()
+      {
+        return AccessibleRole.LABEL;
+      }
+
+      /**
+       * Returns the accessible state set of this list item.
+       *
+       * @return the accessible state set of this list item
+       */
+      public AccessibleStateSet getAccessibleStateSet()
+      {
+        AccessibleStateSet states = new AccessibleStateSet();
+        if (isVisible())
+          states.add(AccessibleState.VISIBLE);
+        if (isShowing())
+          states.add(AccessibleState.SHOWING);
+        if (isFocusTraversable())
+          states.add(AccessibleState.FOCUSABLE);
+        // TODO: How should the active state be handled? The API docs
+        // suggest that this state is set on the activated list child,
+        // that is the one that is drawn with a box. However, I don't know how
+        // to implement this.
+
+        // TODO: We set the selectable state here because list children are
+        // selectable. Is there a way to disable single children?
+        if (parent.isEnabled())
+          states.add(AccessibleState.SELECTABLE);
+ 
+        if (parent.isSelectedIndex(listIndex))
+          states.add(AccessibleState.SELECTED);
+
+        // TODO: Handle more states here?
+        return states;
+      }
+
+      /**
+       * Returns the index of this list child within it's parent list.
+       *
+       * @return the index of this list child within it's parent list
+       */
+      public int getAccessibleIndexInParent()
+      {
+        return listIndex;
+      }
+
+      /**
+       * Returns <code>0</code> since list children don't have children
+       * themselves.
+       *
+       * @return <code>0</code>
+       */
+      public int getAccessibleChildrenCount()
+      {
+        return 0;
+      }
+
+      /**
+       * Returns <code>null</code> since list children don't have children
+       * themselves.
+       *
+       * @return <code>null</code>
+       */
+      public Accessible getAccessibleChild(int i)
+      {
+        return null;
+      }
+
+      /**
+       * Returns the locale of this component. This call is forwarded to the
+       * parent list since list children don't have a separate locale setting.
+       *
+       * @return the locale of this component
+       */
+      public Locale getLocale()
+      {
+        return parent.getLocale();
+      }
+
+      /**
+       * This method does
+       * nothing, list children are transient accessible objects which means
+       * that they don't fire property change events.
+       *
+       * @param l not used here
+       */
+      public void addPropertyChangeListener(PropertyChangeListener l)
+      {
+        // Do nothing here.
+      }
+
+      /**
+       * This method does
+       * nothing, list children are transient accessible objects which means
+       * that they don't fire property change events.
+       *
+       * @param l not used here
+       */
+      public void removePropertyChangeListener(PropertyChangeListener l)
+      {
+        // Do nothing here.
+      }
+      
+      // TODO: Implement the remaining methods of this class.
+    }
+    
+    /**
+     * Create a new AccessibleJList.
+     */
+    public AccessibleJList()
+    {
+      // Nothing to do here.
+    }
+
+    /**
+     * Returns the number of selected accessible children.
+     *
+     * @return the number of selected accessible children
+     */
+    public int getAccessibleSelectionCount()
+    {
+      return getSelectedIndices().length;
+    }
+
+    /**
+     * Returns the n-th selected accessible child.
+     *
+     * @param n the index of the selected child to return
+     *
+     * @return the n-th selected accessible child
+     */
+    public Accessible getAccessibleSelection(int n)
+    {
+      return new AccessibleJListChild(JList.this, getSelectedIndices()[n]);
+    }
+
+    /**
+     * Returns <code>true</code> if the n-th child is selected,
+     * <code>false</code> otherwise.
+     *
+     * @param n the index of the child of which the selected state is queried
+     *
+     * @return <code>true</code> if the n-th child is selected,
+     *         <code>false</code> otherwise
+     */
+    public boolean isAccessibleChildSelected(int n)
+    {
+      return isSelectedIndex(n);
+    }
+
+    /**
+     * Adds the accessible item with the specified index to the selected items.
+     * If multiple selections are supported, the item is added to the selection,
+     * otherwise the item replaces the current selection.
+     *
+     * @param i the index of the item to add to the selection
+     */
+    public void addAccessibleSelection(int i)
+    {
+      addSelectionInterval(i, i);
+    }
+
+    /**
+     * Removes the accessible item with the specified index to the selection.
+     *
+     * @param i the index of the item to be removed from the selection
+     */
+    public void removeAccessibleSelection(int i)
+    {
+      removeSelectionInterval(i, i);
+    }
+
+    /**
+     * Remove all selection items from the selection.
+     */
+    public void clearAccessibleSelection()
+    {
+      clearSelection();
+    }
+
+    /**
+     * Selects all items if multiple selections are supported.
+     * Otherwise do nothing.
+     */
+    public void selectAllAccessibleSelection()
+    {
+      addSelectionInterval(0, getModel().getSize());
+    }
+
+    /**
+     * Receices notification when the list selection is changed. This method
+     * fires two property change events, the first with
+     * {@link AccessibleContext#ACCESSIBLE_VISIBLE_DATA_PROPERTY} and the second
+     * with {@link AccessibleContext#ACCESSIBLE_SELECTION_PROPERTY}.
+     *
+     * @param event the list selection event
+     */
+    public void valueChanged(ListSelectionEvent event)
+    {
+      firePropertyChange(ACCESSIBLE_VISIBLE_DATA_PROPERTY, Boolean.FALSE,
+                         Boolean.TRUE);
+      firePropertyChange(ACCESSIBLE_SELECTION_PROPERTY, Boolean.FALSE,
+                         Boolean.TRUE);
+    }
+
+    /**
+     * Receives notification when items have changed in the
+     * <code>JList</code>. This method fires a property change event with
+     * {@link AccessibleContext#ACCESSIBLE_VISIBLE_DATA_PROPERTY}.
+     *
+     * @param event the list data event
+     */
+    public void contentsChanged(ListDataEvent event)
+    {
+      firePropertyChange(ACCESSIBLE_VISIBLE_DATA_PROPERTY, Boolean.FALSE,
+                         Boolean.TRUE);
+    }
+
+    /**
+     * Receives notification when items are inserted into the
+     * <code>JList</code>. This method fires a property change event with
+     * {@link AccessibleContext#ACCESSIBLE_VISIBLE_DATA_PROPERTY}.
+     *
+     * @param event the list data event
+     */
+    public void intervalAdded(ListDataEvent event)
+    {
+      firePropertyChange(ACCESSIBLE_VISIBLE_DATA_PROPERTY, Boolean.FALSE,
+                         Boolean.TRUE);
+    }
+
+    /**
+     * Receives notification when items are removed from the
+     * <code>JList</code>. This method fires a property change event with
+     * {@link AccessibleContext#ACCESSIBLE_VISIBLE_DATA_PROPERTY}.
+     *
+     * @param event the list data event
+     */
+    public void intervalRemoved(ListDataEvent event)
+    {
+      firePropertyChange(ACCESSIBLE_VISIBLE_DATA_PROPERTY, Boolean.FALSE,
+                         Boolean.TRUE);
+    }
+
+
+    /**
+     * Receives notification about changes of the <code>JList</code>'s
+     * properties. This is used to re-register this object as listener to
+     * the data model and selection model when the data model or selection model
+     * changes.
+     *
+     * @param e the property change event
+     */
+    public void propertyChange(PropertyChangeEvent e)
+    {
+      String propertyName = e.getPropertyName();
+      if (propertyName.equals("model"))
+        {
+          ListModel oldModel = (ListModel) e.getOldValue();
+          oldModel.removeListDataListener(this);
+          ListModel newModel = (ListModel) e.getNewValue();
+          newModel.addListDataListener(this);
+        }
+      else if (propertyName.equals("selectionModel"))
+        {
+          ListSelectionModel oldModel = (ListSelectionModel) e.getOldValue();
+          oldModel.removeListSelectionListener(this);
+          ListSelectionModel newModel = (ListSelectionModel) e.getNewValue();
+          oldModel.addListSelectionListener(this);
+        }
+    }
+
+    /**
+     * Return the state set of the <code>JList</code>.
+     *
+     * @return the state set of the <code>JList</code>
+     */
+    public AccessibleStateSet getAccessibleStateSet()
+    {
+      // TODO: Figure out if there is possibly more state that must be
+      // handled here.
+      AccessibleStateSet s = super.getAccessibleStateSet();
+      if (getSelectionMode() != ListSelectionModel.SINGLE_SELECTION)
+        s.add(AccessibleState.MULTISELECTABLE);
+      return s;
+    }
+
+    /**
+     * Returns the accessible role for <code>JList</code>,
+     * {@link AccessibleRole#LIST}.
+     *
+     * @return the accessible role for <code>JList</code>
+     */
+    public AccessibleRole getAccessibleRole()
+    {
+      return AccessibleRole.LIST;
+    }
+
+    /**
+     * Returns the accessible child at the visual location <code>p</code>
+     * (relative to the upper left corner of the <code>JList</code>). If there
+     * is no child at that location, this returns <code>null</code>.
+     *
+     * @param p the screen location for which to return the accessible child
+     *
+     * @return the accessible child at the specified location, or
+     *         <code>null</code> if there is no child at that location
+     */
+    public Accessible getAccessibleAt(Point p)
+    {
+      int childIndex = locationToIndex(p);
+      return getAccessibleChild(childIndex);
+    }
+
+    /**
+     * Returns the number of accessible children in the <code>JList</code>.
+     *
+     * @return the number of accessible children in the <code>JList</code>
+     */
+    public int getAccessibleChildrenCount()
+    {
+      return getModel().getSize();
+    }
+
+    /**
+     * Returns the n-th accessible child of this <code>JList</code>. This will
+     * be an instance of {@link AccessibleJListChild}. If there is no child
+     * at that index, <code>null</code> is returned.
+     *
+     * @param n the index of the child to return
+     *
+     * @return the n-th accessible child of this <code>JList</code>
+     */
+    public Accessible getAccessibleChild(int n)
+    {
+      if (getModel().getSize() <= n)
+        return null;
+      return new AccessibleJListChild(JList.this, n);
+    }
+  }
+
+  private static final long serialVersionUID = 4406629526391098046L;
+
+  /** 
+   * Constant value used in "layoutOrientation" property. This value means
+   * that cells are laid out in a single vertical column. This is the default. 
+   */
+  public static final int VERTICAL = 0;
+
+  /** 
+   * Constant value used in "layoutOrientation" property. This value means
+   * that cells are laid out in multiple columns "newspaper style", filling
+   * vertically first, then horizontally. 
+   */
+  public static final int VERTICAL_WRAP = 1;
+  
+  /** 
+   * Constant value used in "layoutOrientation" property. This value means
+   * that cells are laid out in multiple columns "newspaper style",
+   * filling horizontally first, then vertically. 
+   */
+  public static final int HORIZONTAL_WRAP = 2;
+
+  /**
+   * This property indicates whether "drag and drop" functions are enabled
+   * on the list.
+   */
+  boolean dragEnabled;
+
+  /** This property provides a strategy for rendering cells in the list. */
+  ListCellRenderer cellRenderer;
+
+  /**
+   * This property indicates an fixed width to assign to all cells in the
+   * list. If its value is <code>-1</code>, no width has been
+   * assigned. This value can be set explicitly, or implicitly by setting
+   * the {@link #prototypeCellValue} property.
+   */
+  int fixedCellWidth;
+  
+  /**
+   * This property indicates an fixed height to assign to all cells in the
+   * list. If its value is <code>-1</code>, no height has been
+   * assigned. This value can be set explicitly, or implicitly by setting
+   * the {@link #prototypeCellValue} property.
+   */
+  int fixedCellHeight;
+
+  /** 
+   * This property holds the current layout orientation of the list, which
+   * is one of the integer constants {@link #VERTICAL}, {@link
+   * #VERTICAL_WRAP}, or {@link #HORIZONTAL_WRAP}. 
+   */
+  int layoutOrientation;
+  
+  /** This property holds the data elements displayed by the list. */
+  ListModel model;
+
+  /**
+   * <p>This property holds a reference to a "prototype" data value --
+   * typically a String -- which is used to calculate the {@link
+   * #fixedCellWidth} and {@link #fixedCellHeight} properties, using the
+   * {@link #cellRenderer} property to acquire a component to render the
+   * prototype.</p>
+   *
+   * <p>It is important that you <em>not</em> set this value to a
+   * component. It has to be a <em>data value</em> such as the objects you
+   * would find in the list's model. Setting it to a component will have
+   * undefined (and undesirable) affects. </p>
+   */
+  Object prototypeCellValue;
+
+  /** 
+   * This property specifies a foreground color for the selected cells in
+   * the list. When {@link ListCellRenderer#getListCellRendererComponent}
+   * is called with a selected cell object, the component returned will
+   * have its "foreground" set to this color.
+   */
+  Color selectionBackground;
+
+  /** 
+   * This property specifies a background color for the selected cells in
+   * the list. When {@link ListCellRenderer#getListCellRendererComponent}
+   * is called with a selected cell object, the component returned will
+   * have its "background" property set to this color.
+   */
+  Color selectionForeground;
+
+  /** 
+   * This property holds a description of which data elements in the {@link
+   * #model} property should be considered "selected", when displaying and
+   * interacting with the list.
+   */
+  ListSelectionModel selectionModel;
+
+  /** 
+   * This property indicates a <em>preference</em> for the number of rows
+   * displayed in the list, and will scale the
+   * {@link #getPreferredScrollableViewportSize} property accordingly. The actual
+   * number of displayed rows, when the list is placed in a real {@link
+   * JViewport} or other component, may be greater or less than this number.
+   */
+  int visibleRowCount;
+
+  /**
+   * Fire a {@link ListSelectionEvent} to all the registered 
+   * ListSelectionListeners.
+   * 
+   * @param firstIndex  the lowest index covering the selection change.
+   * @param lastIndex  the highest index covering the selection change.
+   * @param isAdjusting  a flag indicating if this event is one in a series
+   *     of events updating the selection.
+   */
+  protected void fireSelectionValueChanged(int firstIndex, int lastIndex, 
+                                           boolean isAdjusting) 
+  {
+    ListSelectionEvent evt = new ListSelectionEvent(this, firstIndex, 
+                                                    lastIndex, isAdjusting);
+    ListSelectionListener listeners[] = getListSelectionListeners();
+    for (int i = 0; i < listeners.length; ++i)
+      {
+        listeners[i].valueChanged(evt);
+      }
+  }
+
+  /**
+   * This private listener propagates {@link ListSelectionEvent} events
+   * from the list's "selectionModel" property to the list's {@link
+   * ListSelectionListener} listeners. It also listens to {@link
+   * ListDataEvent} events from the list's {@link #model} property. If this
+   * class receives either type of event, it triggers repainting of the
+   * list.
+   */
+  private class ListListener 
+    implements ListSelectionListener, ListDataListener
+  {
+    // ListDataListener events
+    public void contentsChanged(ListDataEvent event)
+    {
+      JList.this.revalidate();
+      JList.this.repaint();
+    }
+    public void intervalAdded(ListDataEvent event)
+    {
+      JList.this.revalidate();
+      JList.this.repaint();
+    }
+    public void intervalRemoved(ListDataEvent event)
+    {
+      JList.this.revalidate();
+      JList.this.repaint();
+    }
+    // ListSelectionListener events
+    public void valueChanged(ListSelectionEvent event)
+    {
+      JList.this.fireSelectionValueChanged(event.getFirstIndex(),
+                                           event.getLastIndex(),
+                                           event.getValueIsAdjusting());
+      JList.this.repaint();
+    }
+  }
+
+  /** 
+   * Shared ListListener instance, subscribed to both the current {@link
+   * #model} and {@link #selectionModel} properties of the list.
+   */
+  ListListener listListener;
+
+
+  /**
+   * Creates a new <code>JList</code> object.
+   */
+  public JList()
+  {
+    init(new DefaultListModel());
+  }
+
+  /**
+   * Creates a new <code>JList</code> object.
+   *
+   * @param items  the initial list items.
+   */
+  public JList(Object[] items)
+  {
+    init(createListModel(items));
+  }
+
+  /**
+   * Creates a new <code>JList</code> object.
+   *
+   * @param items  the initial list items.
+   */
+  public JList(Vector items)
+  {
+    init(createListModel(items));
+  }
+
+  /**
+   * Creates a new <code>JList</code> object.
+   *
+   * @param model  a model containing the list items (<code>null</code> not
+   *     permitted).
+   *     
+   * @throws IllegalArgumentException if <code>model</code> is 
+   *     <code>null</code>.
+   */
+  public JList(ListModel model)
+  {
+    init(model);
+  }
+
+  /**
+   * Initializes the list.
+   *
+   * @param m  the list model (<code>null</code> not permitted).
+   */
+  private void init(ListModel m)
+  {
+    if (m == null)
+      throw new IllegalArgumentException("Null model not permitted.");
+    dragEnabled = false;
+    fixedCellHeight = -1;
+    fixedCellWidth = -1;
+    layoutOrientation = VERTICAL;
+    opaque = true;
+    visibleRowCount = 8;
+
+    cellRenderer = new DefaultListCellRenderer();
+    listListener = new ListListener();
+
+    model = m;
+    if (model != null)
+      model.addListDataListener(listListener);
+
+    selectionModel = createSelectionModel();
+    if (selectionModel != null)
+      {
+        selectionModel.addListSelectionListener(listListener);
+        selectionModel.setSelectionMode
+                              (ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);
+      }
+    setLayout(null);
+    
+    updateUI();
+  }
+
+  /**
+   * Creates the default <code>ListSelectionModel</code>.
+   *
+   * @return the <code>ListSelectionModel</code>
+   */
+  protected ListSelectionModel createSelectionModel()
+  {
+    return new DefaultListSelectionModel();
+  }
+  
+  /**
+   * Gets the value of the {@link #fixedCellHeight} property. This property
+   * may be <code>-1</code> to indicate that no cell height has been
+   * set. This property is also set implicitly when the
+   * {@link #prototypeCellValue} property is set.
+   *
+   * @return The current value of the property 
+   * 
+   * @see #fixedCellHeight
+   * @see #setFixedCellHeight
+   * @see #setPrototypeCellValue
+   */
+  public int getFixedCellHeight()
+  {
+    return fixedCellHeight;
+  }
+
+  /**
+   * Sets the value of the {@link #fixedCellHeight} property. This property
+   * may be <code>-1</code> to indicate that no cell height has been
+   * set. This property is also set implicitly when the {@link
+   * #prototypeCellValue} property is set, but setting it explicitly
+   * overrides the height computed from {@link #prototypeCellValue}.
+   *
+   * @param h  the height.
+   * 
+   * @see #getFixedCellHeight
+   * @see #getPrototypeCellValue
+   */
+  public void setFixedCellHeight(int h)
+  {
+    if (fixedCellHeight == h)
+      return;
+
+    int old = fixedCellHeight;
+    fixedCellHeight = h;
+    firePropertyChange("fixedCellHeight", old, h);
+  }
+
+
+  /**
+   * Gets the value of the {@link #fixedCellWidth} property. This property
+   * may be <code>-1</code> to indicate that no cell width has been
+   * set. This property is also set implicitly when the {@link
+   * #prototypeCellValue} property is set.
+   *
+   * @return The current value of the property 
+   * 
+   * @see #setFixedCellWidth
+   * @see #setPrototypeCellValue
+   */
+  public int getFixedCellWidth()
+  {
+    return fixedCellWidth;
+  }
+
+  /**
+   * Sets the value of the {@link #fixedCellWidth} property. This property
+   * may be <code>-1</code> to indicate that no cell width has been
+   * set. This property is also set implicitly when the {@link
+   * #prototypeCellValue} property is set, but setting it explicitly
+   * overrides the width computed from {@link #prototypeCellValue}.
+   *
+   * @param w  the width.
+   * 
+   * @see #getFixedCellHeight
+   * @see #getPrototypeCellValue
+   */
+  public void setFixedCellWidth(int w)
+  {
+    if (fixedCellWidth == w)
+      return;
+    
+    int old = fixedCellWidth;
+    fixedCellWidth = w;
+    firePropertyChange("fixedCellWidth", old, w);
+  }
+
+  /** 
+   * Gets the value of the {@link #visibleRowCount} property.  The default 
+   * value is 8.
+   *
+   * @return the current value of the property.
+   * 
+   * @see #setVisibleRowCount(int)
+   */
+  public int getVisibleRowCount()
+  {
+    return visibleRowCount;
+  }
+
+  /**
+   * Sets the value of the {@link #visibleRowCount} property. 
+   *
+   * @param vc The new property value
+   * 
+   * @see #getVisibleRowCount()
+   */
+  public void setVisibleRowCount(int vc)
+  {
+    if (visibleRowCount != vc)
+      {
+        int oldValue = visibleRowCount;
+        visibleRowCount = Math.max(vc, 0);
+        firePropertyChange("visibleRowCount", oldValue, vc);
+        revalidate();
+        repaint();
+      }
+  }
+
+  /**
+   * Adds a {@link ListSelectionListener} to the listener list for this
+   * list. The listener will be called back with a {@link
+   * ListSelectionEvent} any time the list's {@link #selectionModel}
+   * property changes. The source of such events will be the JList,
+   * not the selection model.
+   *
+   * @param listener The new listener to add
+   */
+  public void addListSelectionListener(ListSelectionListener listener)
+  {
+    listenerList.add (ListSelectionListener.class, listener);
+  }
+
+  /**
+   * Removes a {@link ListSelectionListener} from the listener list for
+   * this list. The listener will no longer be called when the list's
+   * {@link #selectionModel} changes.
+   *
+   * @param listener The listener to remove
+   */
+  public void removeListSelectionListener(ListSelectionListener listener)
+  {
+    listenerList.remove(ListSelectionListener.class, listener);
+  }
+
+  /**
+   * Returns an array of all ListSelectionListeners subscribed to this
+   * list. 
+   *
+   * @return The current subscribed listeners
+   *
+   * @since 1.4
+   */
+  public ListSelectionListener[] getListSelectionListeners()
+  {
+    return (ListSelectionListener[]) getListeners(ListSelectionListener.class);
+  }
+
+  /**
+   * Returns the selection mode for the list (one of: 
+   * {@link ListSelectionModel#SINGLE_SELECTION}, 
+   * {@link ListSelectionModel#SINGLE_INTERVAL_SELECTION} and 
+   * {@link ListSelectionModel#MULTIPLE_INTERVAL_SELECTION}).
+   * 
+   * @return The selection mode.
+   * 
+   * @see #setSelectionMode(int)
+   */
+  public int getSelectionMode()
+  {
+    return selectionModel.getSelectionMode();
+  }
+  
+  /**
+   * Sets the list's "selectionMode" property, which simply mirrors the
+   * same property on the list's {@link #selectionModel} property. This
+   * property should be one of the integer constants
+   * <code>SINGLE_SELECTION</code>, <code>SINGLE_INTERVAL_SELECTION</code>,
+   * or <code>MULTIPLE_INTERVAL_SELECTION</code> from the {@link
+   * ListSelectionModel} interface.
+   *
+   * @param a The new selection mode
+   */
+  public void setSelectionMode(int a)
+  {
+    selectionModel.setSelectionMode(a);
+  }
+
+  /**
+   * Adds the interval <code>[a,a]</code> to the set of selections managed
+   * by this list's {@link #selectionModel} property. Depending on the
+   * selection mode, this may cause existing selections to become invalid,
+   * or may simply expand the set of selections. 
+   *
+   * @param a A number in the half-open range <code>[0, x)</code> where
+   * <code>x = getModel.getSize()</code>, indicating the index of an
+   * element in the list to select. When < 0 the selection is cleared.
+   *
+   * @see #setSelectionMode
+   * @see #selectionModel
+   */
+  public void setSelectedIndex(int a)
+  {
+    if (a < 0)
+      selectionModel.clearSelection();
+    else
+      selectionModel.setSelectionInterval(a, a);
+  }
+
+  /**
+   * For each element <code>a[i]</code> of the provided array
+   * <code>a</code>, calls {@link #setSelectedIndex} on <code>a[i]</code>.
+   *
+   * @param a  an array of selected indices (<code>null</code> not permitted).
+   * 
+   * @throws NullPointerException if <code>a</code> is <code>null</code>.
+   * @see #setSelectionMode
+   * @see #selectionModel
+   */
+  public void setSelectedIndices(int [] a)
+  {
+    for (int i = 0; i < a.length; ++i)
+      setSelectedIndex(a[i]);
+  }
+
+  /**
+   * Returns the minimum index of an element in the list which is currently
+   * selected.
+   *
+   * @return A number in the half-open range <code>[0, x)</code> where
+   * <code>x = getModel.getSize()</code>, indicating the minimum index of
+   * an element in the list for which the element is selected, or
+   * <code>-1</code> if no elements are selected
+   */
+  public int getSelectedIndex()
+  {
+    return selectionModel.getMinSelectionIndex();
+  }
+
+  /**
+   * Returns <code>true</code> if the model's selection is empty, otherwise
+   * <code>false</code>. 
+   *
+   * @return The return value of {@link ListSelectionModel#isSelectionEmpty}
+   */
+  public boolean isSelectionEmpty()
+  {
+    return selectionModel.isSelectionEmpty();
+  }
+
+  /**
+   * Returns the list index of the upper left or upper right corner of the
+   * visible rectangle of this list, depending on the {@link
+   * Component#getComponentOrientation} property.
+   *
+   * @return The index of the first visible list cell, or <code>-1</code>
+   * if none is visible.
+   */
+  public int getFirstVisibleIndex()
+  {
+    ComponentOrientation or = getComponentOrientation();
+    Rectangle r = getVisibleRect();
+    if (or == ComponentOrientation.RIGHT_TO_LEFT)
+      r.translate((int) r.getWidth() - 1, 0);
+    return getUI().locationToIndex(this, r.getLocation());      
+  }
+
+
+  /**
+   * Returns index of the cell to which specified location is closest to. If
+   * the location is outside the bounds of the list, then the greatest index
+   * in the list model is returned. If the list model is empty, then
+   * <code>-1</code> is returned.
+   *
+   * @param location for which to look for in the list
+   * 
+   * @return index of the cell to which specified location is closest to.
+   */
+   public int locationToIndex(Point location)
+   {
+     return getUI().locationToIndex(this, location);      
+   }
+
+  /**
+   * Returns location of the cell located at the specified index in the list.
+   * @param index of the cell for which location will be determined
+   * 
+   * @return location of the cell located at the specified index in the list.
+   */
+   public Point indexToLocation(int index)
+   {
+     return getUI().indexToLocation(this, index);
+   }
+
+  /**
+   * Returns the list index of the lower right or lower left corner of the
+   * visible rectangle of this list, depending on the {@link
+   * Component#getComponentOrientation} property.
+   *
+   * @return The index of the last visible list cell, or <code>-1</code>
+   * if none is visible.
+   */
+  public int getLastVisibleIndex()
+  {
+    ComponentOrientation or = getComponentOrientation();
+    Rectangle r = getVisibleRect();
+    r.translate(0, (int) r.getHeight() - 1);
+    if (or == ComponentOrientation.LEFT_TO_RIGHT)
+      r.translate((int) r.getWidth() - 1, 0);
+    if (getUI().locationToIndex(this, r.getLocation()) == -1
+        && indexToLocation(getModel().getSize() - 1).y < r.y)
+      return getModel().getSize() - 1;
+    return getUI().locationToIndex(this, r.getLocation());
+  }
+
+  /**
+   * Returns the indices of values in the {@link #model} property which are
+   * selected.
+   *
+   * @return An array of model indices, each of which is selected according
+   *         to the {@link #getSelectedValues} property
+   */
+  public int[] getSelectedIndices()
+  {
+    int lo, hi, n, i, j;
+    if (selectionModel.isSelectionEmpty())
+      return new int[0];
+    lo = selectionModel.getMinSelectionIndex();
+    hi = selectionModel.getMaxSelectionIndex();
+    n = 0;
+    for (i = lo; i <= hi; ++i)
+      if (selectionModel.isSelectedIndex(i))
+        n++;
+    int [] v = new int[n];
+    j = 0;
+    for (i = lo; i <= hi; ++i)
+      if (selectionModel.isSelectedIndex(i))
+        v[j++] = i;
+    return v;
+  }
+
+  /**
+   * Indicates whether the list element at a given index value is
+   * currently selected.
+   *
+   * @param a The index to check 
+   * @return <code>true</code> if <code>a</code> is the index of a selected
+   * list element
+   */
+  public boolean isSelectedIndex(int a)
+  {
+    return selectionModel.isSelectedIndex(a);
+  }
+
+  /**
+   * Returns the first value in the list's {@link #model} property which is
+   * selected, according to the list's {@link #selectionModel} property.
+   * This is equivalent to calling
+   * <code>getModel()getElementAt(getSelectedIndex())</code>, with a check
+   * for the special index value of <code>-1</code> which returns null
+   * <code>null</code>.
+   *
+   * @return The first selected element, or <code>null</code> if no element
+   * is selected.
+   *
+   * @see #getSelectedValues
+   */
+  public Object getSelectedValue()
+  {
+    int index = getSelectedIndex();
+    if (index == -1)
+      return null;
+    return getModel().getElementAt(index);
+  }
+
+  /**
+   * Returns all the values in the list's {@link #model} property which are
+   * selected, according to the list's {@link #selectionModel} property.
+   * 
+   * @return An array containing all the selected values
+   * @see #setSelectedValue
+   */
+  public Object[] getSelectedValues()
+  {
+    int[] idx = getSelectedIndices();
+    Object[] v = new Object[idx.length];
+    for (int i = 0; i < idx.length; ++i)
+      v[i] = getModel().getElementAt(idx[i]);
+    return v;
+  }
+
+  /**
+   * Gets the value of the {@link #selectionBackground} property.
+   *
+   * @return The current value of the property
+   */
+  public Color getSelectionBackground()
+  {
+    return selectionBackground;
+  }
+
+  /**
+   * Sets the value of the {@link #selectionBackground} property.
+   *
+   * @param c The new value of the property
+   */
+  public void setSelectionBackground(Color c)
+  {
+    if (selectionBackground == c)
+      return;
+
+    Color old = selectionBackground;
+    selectionBackground = c;
+    firePropertyChange("selectionBackground", old, c);
+    repaint();
+  }
+
+  /**
+   * Gets the value of the {@link #selectionForeground} property.
+   *
+   * @return The current value of the property
+   */
+  public Color getSelectionForeground()
+  {
+    return selectionForeground;
+  }
+  
+  /**
+   * Sets the value of the {@link #selectionForeground} property.
+   *
+   * @param c The new value of the property
+   */
+  public void setSelectionForeground(Color c)
+  {
+    if (selectionForeground == c)
+      return;
+
+    Color old = selectionForeground;
+    selectionForeground = c;
+    firePropertyChange("selectionForeground", old, c);
+  }
+
+  /**
+   * Sets the selection to cover only the specified value, if it
+   * exists in the model. 
+   *
+   * @param obj The object to select
+   * @param scroll Whether to scroll the list to make the newly selected
+   * value visible
+   *
+   * @see #ensureIndexIsVisible
+   */
+
+  public void setSelectedValue(Object obj, boolean scroll)
+  {
+    for (int i = 0; i < model.getSize(); ++i)
+      {
+        if (model.getElementAt(i).equals(obj))
+          {
+            setSelectedIndex(i);
+            if (scroll)
+              ensureIndexIsVisible(i);
+            break;
+          }
+      }
+  }
+
+  /**
+   * Scrolls this list to make the specified cell visible. This
+   * only works if the list is contained within a viewport.
+   *
+   * @param i The list index to make visible
+   *
+   * @see JComponent#scrollRectToVisible
+   */
+  public void ensureIndexIsVisible(int i)
+  {
+    Rectangle r = getUI().getCellBounds(this, i, i);
+    if (r != null)
+      scrollRectToVisible(r);
+  }
+
+  /**
+   * Sets the {@link #model} property of the list to a new anonymous
+   * {@link AbstractListModel} subclass which accesses the provided Object
+   * array directly.
+   *
+   * @param listData The object array to build a new list model on
+   * @see #setModel
+   */
+  public void setListData(Object[] listData)
+  {
+    setModel(createListModel(listData));
+  }
+
+  /**
+   * Returns a {@link ListModel} backed by the specified array.
+   * 
+   * @param items  the list items (don't use <code>null</code>).
+   * 
+   * @return A list model containing the specified items.
+   */
+  private ListModel createListModel(final Object[] items)
+  {
+    return new AbstractListModel()
+      {
+        public int getSize()
+        {
+          return items.length;
+        }
+        public Object getElementAt(int i)
+        {
+          return items[i];
+        }
+      };
+  }
+  
+  /**
+   * Returns a {@link ListModel} backed by the specified vector.
+   * 
+   * @param items  the list items (don't use <code>null</code>).
+   * 
+   * @return A list model containing the specified items.
+   */
+  private ListModel createListModel(final Vector items)
+  {
+    return new AbstractListModel()
+      {
+        public int getSize()
+        {
+          return items.size();
+        }
+        public Object getElementAt(int i)
+        {
+          return items.get(i);
+        }
+      };
+  }
+
+  /**
+   * Sets the {@link #model} property of the list to a new anonymous {@link
+   * AbstractListModel} subclass which accesses the provided vector
+   * directly.
+   *
+   * @param listData The object array to build a new list model on
+   * @see #setModel
+   */
+  public void setListData(Vector listData)
+  {
+    setModel(createListModel(listData));
+  }
+
+  /**
+   * Gets the value of the {@link #cellRenderer} property. 
+   *
+   * @return The current value of the property
+   */
+  public ListCellRenderer getCellRenderer()
+  {
+    return cellRenderer;
+  }
+
+  /**
+   * Sets the value of the {@link #getCellRenderer} property.
+   *
+   * @param renderer The new property value
+   */
+  public void setCellRenderer(ListCellRenderer renderer)
+  {
+    if (cellRenderer == renderer)
+      return;
+    
+    ListCellRenderer old = cellRenderer;
+    cellRenderer = renderer;
+    firePropertyChange("cellRenderer", old, renderer);
+    revalidate();
+    repaint();
+  }
+
+  /**
+   * Gets the value of the {@link #model} property. 
+   *
+   * @return The current value of the property
+   */
+  public ListModel getModel()
+  {
+    return model;
+  }
+
+  /**
+   * Sets the value of the {@link #model} property. The list's {@link
+   * #listListener} is unsubscribed from the existing model, if it exists,
+   * and re-subscribed to the new model.
+   *
+   * @param model  the new model (<code>null</code> not permitted).
+   * 
+   * @throws IllegalArgumentException if <code>model</code> is 
+   *         <code>null</code>.
+   */
+  public void setModel(ListModel model)
+  {
+    if (model == null) 
+      throw new IllegalArgumentException("Null 'model' argument.");
+    if (this.model == model)
+      return;
+    
+    if (this.model != null)
+      this.model.removeListDataListener(listListener);
+    
+    ListModel old = this.model;
+    this.model = model;
+    
+    if (this.model != null)
+      this.model.addListDataListener(listListener);
+    
+    firePropertyChange("model", old, model);
+    revalidate();
+    repaint();
+  }
+
+  /**
+   * Returns the selection model for the {@link JList} component.  Note that
+   * this class contains a range of convenience methods for configuring the
+   * selection model:<br>
+   * <ul>
+   *   <li>{@link #clearSelection()};</li>
+   *   <li>{@link #setSelectionMode(int)};</li>
+   *   <li>{@link #addSelectionInterval(int, int)};</li>
+   *   <li>{@link #setSelectedIndex(int)};</li>
+   *   <li>{@link #setSelectedIndices(int[])};</li>
+   *   <li>{@link #setSelectionInterval(int, int)}.</li>
+   * </ul>
+   * 
+   * @return The selection model.
+   */
+  public ListSelectionModel getSelectionModel()
+  {
+    return selectionModel;
+  }
+
+  /**
+   * Sets the value of the {@link #selectionModel} property. The list's
+   * {@link #listListener} is unsubscribed from the existing selection
+   * model, if it exists, and re-subscribed to the new selection model.
+   *
+   * @param model The new property value
+   */
+  public void setSelectionModel(ListSelectionModel model)
+  {
+    if (selectionModel == model)
+      return;
+    
+    if (selectionModel != null)
+      selectionModel.removeListSelectionListener(listListener);
+    
+    ListSelectionModel old = selectionModel;
+    selectionModel = model;
+    
+    if (selectionModel != null)
+      selectionModel.addListSelectionListener(listListener);
+    
+    firePropertyChange("selectionModel", old, model);
+    revalidate();
+    repaint();
+  }
+
+  /**
+   * Gets the value of the UI property.
+   *
+   * @return The current property value
+   */
+  public ListUI getUI()
+  {
+    return (ListUI) ui;
+  }
+
+  /**
+   * Sets the value of the UI property.
+   *
+   * @param ui The new property value
+   */
+  public void setUI(ListUI ui)
+  {
+    super.setUI(ui);
+  }
+
+  /**
+   * Calls {@link #setUI} with the {@link ListUI} subclass
+   * returned from calling {@link UIManager#getUI}.
+   */
+  public void updateUI()
+  {
+    setUI((ListUI) UIManager.getUI(this));
+  }
+
+  /**
+   * Return the class identifier for the list's UI property.  This should
+   * be the constant string <code>"ListUI"</code>, and map to an
+   * appropriate UI class in the {@link UIManager}.
+   *
+   * @return The class identifier
+   */
+  public String getUIClassID()
+  {
+    return "ListUI";
+  }
+
+
+  /**
+   * Returns the current value of the {@link #prototypeCellValue}
+   * property. This property holds a reference to a "prototype" data value
+   * -- typically a String -- which is used to calculate the {@link
+   * #fixedCellWidth} and {@link #fixedCellHeight} properties, using the
+   * {@link #cellRenderer} property to acquire a component to render the
+   * prototype.
+   *
+   * @return The current prototype cell value
+   * @see #setPrototypeCellValue
+   */
+  public Object getPrototypeCellValue()
+  {
+    return prototypeCellValue;
+  }
+
+  /**
+   * <p>Set the {@link #prototypeCellValue} property. This property holds a
+   * reference to a "prototype" data value -- typically a String -- which
+   * is used to calculate the {@link #fixedCellWidth} and {@link
+   * #fixedCellHeight} properties, using the {@link #cellRenderer} property
+   * to acquire a component to render the prototype.</p>
+   *
+   * <p>It is important that you <em>not</em> set this value to a
+   * component. It has to be a <em>data value</em> such as the objects you
+   * would find in the list's model. Setting it to a component will have
+   * undefined (and undesirable) affects. </p>
+   *
+   * @param obj The new prototype cell value
+   * @see #getPrototypeCellValue
+   */
+  public void setPrototypeCellValue(Object obj)
+  {
+    if (prototypeCellValue == obj)
+      return;
+
+    Object old = prototypeCellValue;
+    Component comp = getCellRenderer()
+      .getListCellRendererComponent(this, obj, 0, false, false); 
+    Dimension d = comp.getPreferredSize();
+    fixedCellWidth = d.width;
+    fixedCellHeight = d.height;
+    prototypeCellValue = obj;
+    firePropertyChange("prototypeCellValue", old, obj);
+  }
+
+  public AccessibleContext getAccessibleContext()
+  {
+    return new AccessibleJList();
+  }
+
+  /**
+   * Returns a size indicating how much space this list would like to
+   * consume, when contained in a scrollable viewport. This is part of the
+   * {@link Scrollable} interface, which interacts with {@link
+   * ScrollPaneLayout} and {@link JViewport} to define scrollable objects.
+   *
+   * @return The preferred size
+   */
+  public Dimension getPreferredScrollableViewportSize()
+  {
+    //If the layout orientation is not VERTICAL, then this will 
+    //return the value from getPreferredSize. The current ListUI is 
+    //expected to override getPreferredSize to return an appropriate value.
+    if (getLayoutOrientation() != VERTICAL)
+      return getPreferredSize();        
+
+    int size = getModel().getSize();
+    
+    // Trivial case: if fixedCellWidth and fixedCellHeight were set 
+    // just use them
+    if (fixedCellHeight != -1 && fixedCellWidth != -1)
+      return new Dimension(fixedCellWidth, size * fixedCellHeight);
+        
+    // If the model is empty we use 16 * the number of visible rows
+    // for the height and either fixedCellWidth (if set) or 256
+    // for the width
+    if (size == 0)
+      {
+        if (fixedCellWidth == -1)
+          return new Dimension(256, 16 * getVisibleRowCount());
+        else
+          return new Dimension(fixedCellWidth, 16 * getVisibleRowCount());
+      }
+
+    // Calculate the width: if fixedCellWidth was set use that, otherwise
+    // use the preferredWidth
+    int prefWidth;
+    if (fixedCellWidth != -1)
+      prefWidth = fixedCellWidth;
+    else
+      prefWidth = getPreferredSize().width;
+
+    // Calculate the height: if fixedCellHeight was set use that, otherwise
+    // use the height of the first row multiplied by the number of visible
+    // rows
+    int prefHeight;
+    if (fixedCellHeight != -1)
+      prefHeight = fixedCellHeight;
+    else
+      prefHeight = getVisibleRowCount() * getCellBounds(0, 0).height;
+
+    return new Dimension (prefWidth, prefHeight);
+  }
+
+  /**
+   * <p>Return the number of pixels the list must scroll in order to move a
+   * "unit" of the list into the provided visible rectangle. When the
+   * provided direction is positive, the call describes a "downwards"
+   * scroll, which will be exposing a cell at a <em>greater</em> index in
+   * the list than those elements currently showing. Then the provided
+   * direction is negative, the call describes an "upwards" scroll, which
+   * will be exposing a cell at a <em>lesser</em> index in the list than
+   * those elements currently showing.</p>
+   *
+   * <p>If the provided orientation is <code>HORIZONTAL</code>, the above
+   * comments refer to "rightwards" for positive direction, and "leftwards"
+   * for negative.</p>
+   * 
+   *
+   * @param visibleRect The rectangle to scroll an element into
+   * @param orientation One of the numeric consants <code>VERTICAL</code>
+   * or <code>HORIZONTAL</code>
+   * @param direction An integer indicating the scroll direction: positive means
+   * forwards (down, right), negative means backwards (up, left)
+   *
+   * @return The scrollable unit increment, in pixels
+   */
+  public int getScrollableUnitIncrement(Rectangle visibleRect,
+                                        int orientation, int direction)
+  {
+    ListUI lui = this.getUI();
+    if (orientation == SwingConstants.VERTICAL)
+      {
+        if (direction > 0)
+          {
+            // Scrolling down
+            Point bottomLeft = new Point(visibleRect.x,
+                                         visibleRect.y + visibleRect.height);
+            int curIdx = lui.locationToIndex(this, bottomLeft);
+            Rectangle curBounds = lui.getCellBounds(this, curIdx, curIdx);
+            if (curBounds.y + curBounds.height == bottomLeft.y)
+              {
+                // we are at the exact bottom of the current cell, so we 
+                // are being asked to scroll to the end of the next one
+                if (curIdx + 1 < model.getSize())
+                  {
+                    // there *is* a next item in the list
+                    Rectangle nxtBounds = lui.getCellBounds(this, curIdx + 1, curIdx + 1);
+                    return nxtBounds.height;
+                  }
+                else
+                  {
+                    // no next item, no advance possible
+                    return 0;
+                  }
+              }
+            else
+              {
+                // we are part way through an existing cell, so we are being
+                // asked to scroll to the bottom of it
+                return (curBounds.y + curBounds.height) - bottomLeft.y;
+              }		      
+          }
+        else
+          {
+            // scrolling up
+            Point topLeft = new Point(visibleRect.x, visibleRect.y);
+            int curIdx = lui.locationToIndex(this, topLeft);
+            Rectangle curBounds = lui.getCellBounds(this, curIdx, curIdx);
+            if (curBounds.y == topLeft.y)
+              {
+                // we are at the exact top of the current cell, so we 
+                // are being asked to scroll to the top of the previous one
+                if (curIdx > 0)
+                  {
+                    // there *is* a previous item in the list
+                    Rectangle nxtBounds = lui.getCellBounds(this, curIdx - 1, curIdx - 1);
+                    return -nxtBounds.height;
+                  }
+                else
+                  {
+                    // no previous item, no advance possible
+                    return 0;
+                  }
+              }
+            else
+              {
+                // we are part way through an existing cell, so we are being
+                // asked to scroll to the top of it
+                return curBounds.y - topLeft.y;
+              }		      
+          }
+      }
+
+    // FIXME: handle horizontal scrolling (also wrapping?)
+    return 1;
+  }
+
+  /**
+   * <p>Return the number of pixels the list must scroll in order to move a
+   * "block" of the list into the provided visible rectangle. When the
+   * provided direction is positive, the call describes a "downwards"
+   * scroll, which will be exposing a cell at a <em>greater</em> index in
+   * the list than those elements currently showing. Then the provided
+   * direction is negative, the call describes an "upwards" scroll, which
+   * will be exposing a cell at a <em>lesser</em> index in the list than
+   * those elements currently showing.</p>
+   *
+   * <p>If the provided orientation is <code>HORIZONTAL</code>, the above
+   * comments refer to "rightwards" for positive direction, and "leftwards"
+   * for negative.</p>
+   * 
+   *
+   * @param visibleRect The rectangle to scroll an element into
+   * @param orientation One of the numeric consants <code>VERTICAL</code>
+   * or <code>HORIZONTAL</code>
+   * @param direction An integer indicating the scroll direction: positive means
+   * forwards (down, right), negative means backwards (up, left)
+   *
+   * @return The scrollable unit increment, in pixels
+   */
+  public int getScrollableBlockIncrement(Rectangle visibleRect,
+                                         int orientation, int direction)
+  {
+      if (orientation == VERTICAL)
+	  return visibleRect.height * direction;
+      else
+	  return visibleRect.width * direction;
+  }
+
+  /**
+   * Gets the value of the <code>scrollableTracksViewportWidth</code> property.
+   *
+   * @return <code>true</code> if the viewport is larger (horizontally)
+   * than the list and the list should be expanded to fit the viewport;
+   * <code>false</code> if the viewport is smaller than the list and the
+   * list should scroll (horizontally) within the viewport
+   */
+  public boolean getScrollableTracksViewportWidth()
+  {
+    Component parent = getParent();
+    boolean retVal = false;
+    if (parent instanceof JViewport)
+      {
+        JViewport viewport = (JViewport) parent;
+        Dimension pref = getPreferredSize();
+        if (viewport.getSize().width > pref.width)
+          retVal = true;
+        if ((getLayoutOrientation() == HORIZONTAL_WRAP)
+            && (getVisibleRowCount() <= 0))
+          retVal = true;
+      }
+    return retVal;
+  }
+
+  /**
+   * Gets the value of the </code>scrollableTracksViewportWidth</code> property.
+   *
+   * @return <code>true</code> if the viewport is larger (vertically)
+   * than the list and the list should be expanded to fit the viewport;
+   * <code>false</code> if the viewport is smaller than the list and the
+   * list should scroll (vertically) within the viewport
+   */
+  public boolean getScrollableTracksViewportHeight()
+  {
+    Component parent = getParent();
+    boolean retVal = false;
+    if (parent instanceof JViewport)
+      {
+        JViewport viewport = (JViewport) parent;
+        Dimension pref = getPreferredSize();
+        if (viewport.getSize().height > pref.height)
+          retVal = true;
+        if ((getLayoutOrientation() == VERTICAL_WRAP)
+            && (getVisibleRowCount() <= 0))
+          retVal = true;
+      }
+    return retVal;
+  }
+
+  /**
+   * Returns the index of the anchor item in the current selection, or
+   * <code>-1</code> if there is no anchor item.
+   * 
+   * @return The item index.
+   */
+  public int getAnchorSelectionIndex()
+  {
+    return selectionModel.getAnchorSelectionIndex();
+  }
+
+  /**
+   * Returns the index of the lead item in the current selection, or
+   * <code>-1</code> if there is no lead item.
+   * 
+   * @return The item index.
+   */
+  public int getLeadSelectionIndex()
+  {
+    return selectionModel.getLeadSelectionIndex();
+  }
+
+  /**
+   * Returns the lowest item index in the current selection, or <code>-1</code>
+   * if there is no selection.
+   * 
+   * @return The index.
+   * 
+   * @see #getMaxSelectionIndex()
+   */
+  public int getMinSelectionIndex()
+  {
+    return selectionModel.getMinSelectionIndex();
+  }
+
+  /**
+   * Returns the highest item index in the current selection, or 
+   * <code>-1</code> if there is no selection.
+   * 
+   * @return The index.
+   * 
+   * @see #getMinSelectionIndex()
+   */
+  public int getMaxSelectionIndex()
+  {
+    return selectionModel.getMaxSelectionIndex();
+  }
+
+  /**
+   * Clears the current selection.
+   */
+  public void clearSelection()
+  {
+    selectionModel.clearSelection();
+  }
+
+  /**
+   * Sets the current selection to the items in the specified range (inclusive).
+   * Note that <code>anchor</code> can be less than, equal to, or greater than 
+   * <code>lead</code>.
+   * 
+   * @param anchor  the index of the anchor item.
+   * @param lead  the index of the anchor item.
+   */
+  public void setSelectionInterval(int anchor, int lead)
+  {
+    selectionModel.setSelectionInterval(anchor, lead);
+  }
+
+  /**
+   * Adds the specified interval to the current selection.  Note that 
+   * <code>anchor</code> can be less than, equal to, or greater than 
+   * <code>lead</code>.
+   * 
+   * @param anchor  the index of the anchor item.
+   * @param lead  the index of the lead item.
+   */
+  public void addSelectionInterval(int anchor, int lead)
+  {
+    selectionModel.addSelectionInterval(anchor, lead);
+  }
+
+  /**
+   * Removes the specified interval from the current selection.  Note that 
+   * <code>index0</code> can be less than, equal to, or greater than 
+   * <code>index1</code>.
+   * 
+   * @param index0  an index for one end of the range.
+   * @param index1  an index for the other end of the range.
+   */
+  public void removeSelectionInterval(int index0, int index1)
+  {
+    selectionModel.removeSelectionInterval(index0, index1);
+  }
+
+  /**
+   * Returns the <code>valueIsAdjusting</code> flag from the list's selection
+   * model.
+   *
+   * @return the value
+   */
+  public boolean getValueIsAdjusting()
+  {
+    return selectionModel.getValueIsAdjusting();
+  }
+
+  /**
+   * Sets the <code>valueIsAdjusting</code> flag in the list's selection 
+   * model.
+   *
+   * @param isAdjusting the new value
+   */
+  public void setValueIsAdjusting(boolean isAdjusting)
+  {
+    selectionModel.setValueIsAdjusting(isAdjusting);
+  }
+
+  /**
+   * Return the value of the <code>dragEnabled</code> property.
+   *
+   * @return the value
+   * 
+   * @since 1.4
+   */
+  public boolean getDragEnabled()
+  {
+    return dragEnabled;
+  }
+
+  /**
+   * Set the <code>dragEnabled</code> property.
+   *
+   * @param enabled new value
+   * 
+   * @since 1.4
+   */
+  public void setDragEnabled(boolean enabled)
+  {
+    dragEnabled = enabled;
+  }
+
+  /**
+   * Returns the layout orientation, which will be one of {@link #VERTICAL}, 
+   * {@link #VERTICAL_WRAP} and {@link #HORIZONTAL_WRAP}.  The default value
+   * is {@link #VERTICAL}.
+   *
+   * @return the orientation.
+   *
+   * @see #setLayoutOrientation(int)
+   * @since 1.4
+   */
+  public int getLayoutOrientation()
+  {
+    return layoutOrientation;
+  }
+
+  /**
+   * Sets the layout orientation (this is a bound property with the name
+   * 'layoutOrientation').  Valid orientations are {@link #VERTICAL}, 
+   * {@link #VERTICAL_WRAP} and {@link #HORIZONTAL_WRAP}.
+   *
+   * @param orientation the orientation.
+   *
+   * @throws IllegalArgumentException if <code>orientation</code> is not one
+   *     of the specified values.
+   * @since 1.4
+   * @see #getLayoutOrientation()
+   */
+  public void setLayoutOrientation(int orientation)
+  {
+    if (orientation < JList.VERTICAL || orientation > JList.HORIZONTAL_WRAP)
+      throw new IllegalArgumentException();
+    if (layoutOrientation == orientation)
+      return;
+
+    int old = layoutOrientation;
+    layoutOrientation = orientation;
+    firePropertyChange("layoutOrientation", old, orientation);
+  }
+
+  /**
+   * Returns the bounds of the rectangle that encloses both list cells
+   * with index0 and index1.
+   *
+   * @param index0 the index of the first cell
+   * @param index1 the index of the second cell
+   *
+   * @return  the bounds of the rectangle that encloses both list cells
+   *     with index0 and index1, <code>null</code> if one of the indices is
+   *     not valid
+   */
+  public Rectangle getCellBounds(int index0, int index1)
+  {
+    ListUI ui = getUI();
+    Rectangle bounds = null;
+    if (ui != null)
+      {
+        bounds = ui.getCellBounds(this, index0, index1);
+      }
+    // When the UI is null, this method also returns null in the RI.
+    return bounds;
+  }
+
+  /**
+   * Returns the index of the next list element (beginning at 
+   * <code>startIndex</code> and moving in the specified direction through the
+   * list, looping around if necessary) that starts with <code>prefix</code>
+   * (ignoring case).
+   *
+   * @param prefix the prefix to search for in the cell values
+   * @param startIndex the index where to start searching from
+   * @param direction the search direction, either {@link Position.Bias#Forward}
+   *     or {@link Position.Bias#Backward} (<code>null</code> is interpreted
+   *     as {@link Position.Bias#Backward}.
+   *
+   * @return the index of the found element or -1 if no such element has
+   *     been found
+   *
+   * @throws IllegalArgumentException if prefix is <code>null</code> or
+   *     startIndex is not valid
+   *
+   * @since 1.4
+   */
+  public int getNextMatch(String prefix, int startIndex, 
+                          Position.Bias direction)
+  {
+    if (prefix == null)
+      throw new IllegalArgumentException("The argument 'prefix' must not be"
+                                         + " null.");
+    if (startIndex < 0)
+      throw new IllegalArgumentException("The argument 'startIndex' must not"
+                                         + " be less than zero.");
+
+    int size = model.getSize();
+    if (startIndex >= model.getSize())
+      throw new IllegalArgumentException("The argument 'startIndex' must not"
+                                         + " be greater than the number of"
+                                         + " elements in the ListModel.");
+
+    int result = -1;
+    int current = startIndex;
+    int delta = -1;
+    int itemCount = model.getSize();
+    boolean finished = false;
+    prefix = prefix.toUpperCase();
+    
+    if (direction == Position.Bias.Forward)
+      delta = 1;
+    while (!finished)
+      {
+        String itemStr = model.getElementAt(current).toString().toUpperCase();
+        if (itemStr.startsWith(prefix))
+          return current;
+        current = (current + delta);
+        if (current == -1)
+          current += itemCount;
+        else
+          current = current % itemCount; 
+        finished = current == startIndex;
+      }
+    return result;
+  }
+  
+  /**
+   * Returns a string describing the attributes for the <code>JList</code>
+   * component, for use in debugging.  The return value is guaranteed to be 
+   * non-<code>null</code>, but the format of the string may vary between
+   * implementations.
+   *
+   * @return A string describing the attributes of the <code>JList</code>.
+   */
+  protected String paramString()
+  {
+    StringBuffer sb = new StringBuffer(super.paramString());
+    sb.append(",fixedCellHeight=").append(getFixedCellHeight());
+    sb.append(",fixedCellWidth=").append(getFixedCellWidth());
+    sb.append(",selectionBackground=");
+    if (getSelectionBackground() != null)
+      sb.append(getSelectionBackground());
+    sb.append(",selectionForeground=");
+    if (getSelectionForeground() != null)
+      sb.append(getSelectionForeground());
+    sb.append(",visibleRowCount=").append(getVisibleRowCount());
+    sb.append(",layoutOrientation=").append(getLayoutOrientation());
+    return sb.toString();
+  }
+}

Added: llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JMenu.java
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JMenu.java?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JMenu.java (added)
+++ llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JMenu.java Thu Nov  8 16:56:19 2007
@@ -0,0 +1,1183 @@
+/* JMenu.java --
+   Copyright (C) 2002, 2004, 2005, 2006  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;
+
+import java.awt.Component;
+import java.awt.Point;
+import java.awt.PopupMenu;
+import java.awt.event.KeyEvent;
+import java.awt.event.WindowAdapter;
+import java.awt.event.WindowEvent;
+import java.beans.PropertyChangeEvent;
+import java.beans.PropertyChangeListener;
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.EventListener;
+
+import javax.accessibility.Accessible;
+import javax.accessibility.AccessibleContext;
+import javax.accessibility.AccessibleRole;
+import javax.accessibility.AccessibleSelection;
+import javax.swing.event.MenuEvent;
+import javax.swing.event.MenuListener;
+import javax.swing.plaf.MenuItemUI;
+
+/**
+ * This class represents a menu that can be added to a menu bar or
+ * can be a submenu in some other menu. When JMenu is selected it
+ * displays JPopupMenu containing its menu items.
+ *
+ * <p>
+ * JMenu's fires MenuEvents when this menu's selection changes. If this menu
+ * is selected, then fireMenuSelectedEvent() is invoked. In case when menu is
+ * deselected or cancelled, then fireMenuDeselectedEvent() or 
+ * fireMenuCancelledEvent() is invoked, respectivelly.
+ * </p>
+ */
+public class JMenu extends JMenuItem implements Accessible, MenuElement
+{
+  private static final long serialVersionUID = 4227225638931828014L;
+
+  /** A Popup menu associated with this menu, which pops up when menu is selected */
+  private JPopupMenu popupMenu = null;
+
+  /** Whenever menu is selected or deselected the MenuEvent is fired to
+     menu's registered listeners. */
+  private MenuEvent menuEvent = new MenuEvent(this);
+
+  /*Amount of time, in milliseconds, that should pass before popupMenu
+    associated with this menu appears or disappers */
+  private int delay;
+
+  /* PopupListener */
+  protected WinListener popupListener;
+
+  /** Location at which popup menu associated with this menu will be
+     displayed */
+  private Point menuLocation;
+
+  /**
+   * Creates a new JMenu object.
+   */
+  public JMenu()
+  {
+    super();
+    setOpaque(false);
+    setDelay(200);
+  }
+
+  /**
+   * Creates a new <code>JMenu</code> with the specified label.
+   *
+   * @param text label for this menu
+   */
+  public JMenu(String text)
+  {
+    super(text);
+    popupMenu = new JPopupMenu(); 
+    popupMenu.setInvoker(this);
+    setOpaque(false);
+    setDelay(200);
+  }
+
+  /**
+   * Creates a new <code>JMenu</code> object.
+   *
+   * @param action Action that is used to create menu item tha will be
+   * added to the menu.
+   */
+  public JMenu(Action action)
+  {
+    super(action);
+    createActionChangeListener(this);
+    popupMenu = new JPopupMenu();
+    popupMenu.setInvoker(this);
+    setOpaque(false);
+    setDelay(200);
+  }
+
+  /**
+   * Creates a new <code>JMenu</code> with specified label and an option
+   * for this menu to be tear-off menu.
+   *
+   * @param text label for this menu
+   * @param tearoff true if this menu should be tear-off and false otherwise
+   */
+  public JMenu(String text, boolean tearoff)
+  {
+    // FIXME: tearoff not implemented
+    this(text);
+    setDelay(200);
+  }
+
+  /**
+   * Adds specified menu item to this menu
+   *
+   * @param item Menu item to add to this menu
+   *
+   * @return Menu item that was added
+   */
+  public JMenuItem add(JMenuItem item)
+  {
+    return getPopupMenu().add(item);
+  }
+
+  /**
+   * Adds specified component to this menu.
+   *
+   * @param component Component to add to this menu
+   *
+   * @return Component that was added
+   */
+  public Component add(Component component)
+  {
+    getPopupMenu().insert(component, -1);
+    return component;
+  }
+
+  /**
+   * Adds specified component to this menu at the given index
+   *
+   * @param component Component to add
+   * @param index Position of this menu item in the menu
+   *
+   * @return Component that was added
+   */
+  public Component add(Component component, int index)
+  {
+    return getPopupMenu().add(component, index);
+  }
+
+  /**
+   * Adds JMenuItem constructed with the specified label to this menu
+   *
+   * @param text label for the menu item that will be added
+   *
+   * @return Menu Item that was added to this menu
+   */
+  public JMenuItem add(String text)
+  {
+    return getPopupMenu().add(text);
+  }
+
+  /**
+   * Adds JMenuItem constructed using properties from specified action.
+   *
+   * @param action action to construct the menu item with
+   *
+   * @return Menu Item that was added to this menu
+   */
+  public JMenuItem add(Action action)
+  {
+    return getPopupMenu().add(action);
+  }
+
+  /**
+   * Removes given menu item from this menu. Nothing happens if
+   * this menu doesn't contain specified menu item.
+   *
+   * @param item Menu Item which needs to be removed
+   */
+  public void remove(JMenuItem item)
+  {
+    getPopupMenu().remove(item);
+  }
+
+  /**
+   * Removes component at the specified index from this menu
+   *
+   * @param index Position of the component that needs to be removed in the menu
+   */
+  public void remove(int index)
+  {
+    if (index < 0 || (index > 0 && getMenuComponentCount() == 0))
+      throw new IllegalArgumentException();
+  
+    if (getMenuComponentCount() > 0)
+      popupMenu.remove(index);
+  }
+
+  /**
+   * Removes given component from this menu.
+   *
+   * @param component Component to remove
+   */
+  public void remove(Component component)
+  {
+    int index = getPopupMenu().getComponentIndex(component);
+    if (index >= 0)
+      getPopupMenu().remove(index);
+  }
+
+  /**
+   * Removes all menu items from the menu
+   */
+  public void removeAll()
+  {
+    if (popupMenu != null)
+      popupMenu.removeAll();
+  }
+
+  /**
+   * Creates JMenuItem with the specified text and inserts it in the
+   * at the specified index
+   *
+   * @param text label for the new menu item
+   * @param index index at which to insert newly created menu item.
+   */
+  public void insert(String text, int index)
+  {
+    this.insert(new JMenuItem(text), index);
+  }
+
+  /**
+   * Creates JMenuItem with the specified text and inserts it in the
+   * at the specified index. IllegalArgumentException is thrown
+   * if index is less than 0
+   *
+   * @param item menu item to insert
+   * @param index index at which to insert menu item.
+   * @return Menu item that was added to the menu
+   */
+  public JMenuItem insert(JMenuItem item, int index)
+  {
+    if (index < 0)
+      throw new IllegalArgumentException("index less than zero");
+
+    getPopupMenu().insert(item, index);
+    return item;
+  }
+
+  /**
+   * Creates JMenuItem with the associated action and inserts it to the menu
+   * at the specified index. IllegalArgumentException is thrown
+   * if index is less than 0
+   *
+   * @param action Action for the new menu item
+   * @param index index at which to insert newly created menu item.
+   * @return Menu item that was added to the menu
+   */
+  public JMenuItem insert(Action action, int index)
+  {
+    JMenuItem item = new JMenuItem(action);
+    this.insert(item, index);
+
+    return item;
+  }
+
+  /**
+   * This method sets this menuItem's UI to the UIManager's default for the
+   * current look and feel.
+   */
+  public void updateUI()
+  {
+    setUI((MenuItemUI) UIManager.getUI(this));
+  }
+
+  /**
+   * This method returns a name to identify which look and feel class will be
+   * the UI delegate for the menu.
+   *
+   * @return The Look and Feel classID. "MenuUI"
+   */
+  public String getUIClassID()
+  {
+    return "MenuUI";
+  }
+
+  /**
+   * Sets model for this menu.
+   *
+   * @param model model to set
+   */
+  public void setModel(ButtonModel model)
+  {
+    super.setModel(model);
+  }
+
+  /**
+   * Returns true if the menu is selected and false otherwise
+   *
+   * @return true if the menu is selected and false otherwise
+   */
+  public boolean isSelected()
+  {
+    return super.isSelected();
+  }
+
+  /**
+   * A helper method to handle setSelected calls from both mouse events and 
+   * direct calls to setSelected.  Direct calls shouldn't expand the popup
+   * menu and should select the JMenu even if it is disabled.  Mouse events
+   * only select the JMenu if it is enabled and should expand the popup menu
+   * associated with this JMenu.
+   * @param selected whether or not the JMenu was selected
+   * @param menuEnabled whether or not selecting the menu is "enabled".  This
+   * is always true for direct calls, and is set to isEnabled() for mouse 
+   * based calls.
+   * @param showMenu whether or not to show the popup menu
+   */
+  private void setSelectedHelper(boolean selected, boolean menuEnabled, boolean showMenu)
+  {
+    // If menu is selected and enabled, activates the menu and 
+    // displays associated popup.	
+    if (selected && menuEnabled)
+      {
+	super.setArmed(true);
+	super.setSelected(true);
+
+        // FIXME: The popup menu should be shown on the screen after certain
+        // number of seconds pass. The 'delay' property of this menu indicates
+        // this amount of seconds. 'delay' property is 0 by default.
+	if (isShowing())
+	  {
+	    fireMenuSelected();
+            
+	    int x = 0;
+	    int y = 0;
+            if (showMenu)
+              if (menuLocation == null)
+                {
+                  // Calculate correct position of the popup. Note that location of the popup 
+                  // passed to show() should be relative to the popup's invoker
+                  if (isTopLevelMenu())
+                    y = this.getHeight();
+                  else
+                    x = this.getWidth();
+                  getPopupMenu().show(this, x, y);
+                }
+              else
+                {
+                  getPopupMenu().show(this, menuLocation.x, menuLocation.y);
+                }
+	  }
+      }
+    
+    else
+      {
+	super.setSelected(false);
+	super.setArmed(false);
+	fireMenuDeselected();
+        getPopupMenu().setVisible(false);
+      }
+  }
+
+  /**
+   * Changes this menu selected state if selected is true and false otherwise
+   * This method fires menuEvents to menu's registered listeners.
+   *
+   * @param selected true if the menu should be selected and false otherwise
+   */
+  public void setSelected(boolean selected)
+  {
+    setSelectedHelper(selected, true, false); 
+  }
+
+  /**
+   * Checks if PopupMenu associated with this menu is visible
+   *
+   * @return true if the popup associated with this menu is currently visible
+   * on the screen and false otherwise.
+   */
+  public boolean isPopupMenuVisible()
+  {
+    return getPopupMenu().isVisible();
+  }
+
+  /**
+   * Sets popup menu visibility
+   *
+   * @param popup true if popup should be visible and false otherwise
+   */
+  public void setPopupMenuVisible(boolean popup)
+  {
+    if (getModel().isEnabled())
+      getPopupMenu().setVisible(popup);
+  }
+
+  /**
+   * Returns origin point of the popup menu
+   *
+   * @return Point containing
+   */
+  protected Point getPopupMenuOrigin()
+  {
+    // if menu in the menu bar
+    if (isTopLevelMenu())
+      return new Point(0, this.getHeight());
+
+    // if submenu            
+    return new Point(this.getWidth(), 0);
+  }
+
+  /**
+   * Returns delay property.
+   *
+   * @return delay property, indicating number of milliseconds before
+   * popup menu associated with the menu appears or disappears after
+   * menu was selected or deselected respectively
+   */
+  public int getDelay()
+  {
+    return delay;
+  }
+
+  /**
+   * Sets delay property for this menu. If given time for the delay
+   * property is negative, then IllegalArgumentException is thrown
+   *
+   * @param delay number of milliseconds before
+   * popup menu associated with the menu appears or disappears after
+   * menu was selected or deselected respectively
+   */
+  public void setDelay(int delay)
+  {
+    if (delay < 0)
+      throw new IllegalArgumentException("delay less than 0");
+    this.delay = delay;
+  }
+
+  /**
+   * Sets location at which popup menu should be displayed
+   * The location given is relative to this menu item
+   *
+   * @param x x-coordinate of the menu location
+   * @param y y-coordinate of the menu location
+   */
+  public void setMenuLocation(int x, int y)
+  {
+    menuLocation = new Point(x, y);
+  }
+
+  /**
+   * Creates and returns JMenuItem associated with the given action
+   *
+   * @param action Action to use for creation of JMenuItem
+   *
+   * @return JMenuItem that was creted with given action
+   */
+  protected JMenuItem createActionComponent(Action action)
+  {
+    return new JMenuItem(action);
+  }
+
+  /**
+   * Creates ActionChangeListener to listen for PropertyChangeEvents occuring
+   * in the action that is associated with this menu
+   *
+   * @param item menu that contains action to listen to
+   *
+   * @return The PropertyChangeListener
+   */
+  protected PropertyChangeListener createActionChangeListener(JMenuItem item)
+  {
+    return new ActionChangedListener(item);
+  }
+
+  /**
+   * Adds separator to the end of the menu items in the menu.
+   */
+  public void addSeparator()
+  {
+    getPopupMenu().addSeparator();
+  }
+
+  /**
+   * Inserts separator in the menu at the specified index.
+   *
+   * @param index Index at which separator should be inserted
+   */
+  public void insertSeparator(int index)
+  {
+    if (index < 0)
+      throw new IllegalArgumentException("index less than 0");
+
+    getPopupMenu().insert(new JPopupMenu.Separator(), index);
+  }
+
+  /**
+   * Returns menu item located at the specified index in the menu
+   *
+   * @param index Index at which to look for the menu item
+   *
+   * @return menu item located at the specified index in the menu
+   */
+  public JMenuItem getItem(int index)
+  {
+    if (index < 0)
+      throw new IllegalArgumentException("index less than 0");
+
+    if (getItemCount() == 0)
+      return null;
+    
+    Component c = popupMenu.getComponentAtIndex(index);
+
+    if (c instanceof JMenuItem)
+      return (JMenuItem) c;
+    else
+      return null;
+  }
+
+  /**
+   * Returns number of items in the menu including separators.
+   *
+   * @return number of items in the menu
+   *
+   * @see #getMenuComponentCount()
+   */
+  public int getItemCount()
+  {
+    return getMenuComponentCount();
+  }
+
+  /**
+   * Checks if this menu is a tear-off menu.
+   *
+   * @return true if this menu is a tear-off menu and false otherwise
+   */
+  public boolean isTearOff()
+  {
+    // NOT YET IMPLEMENTED 
+    throw new Error("The method isTearOff() has not yet been implemented.");
+  }
+
+  /**
+   * Returns number of menu components in this menu
+   *
+   * @return number of menu components in this menu
+   */
+  public int getMenuComponentCount()
+  {
+    return getPopupMenu().getComponentCount();
+  }
+
+  /**
+   * Returns menu component located at the givent index
+   * in the menu
+   *
+   * @param index index at which to get the menu component in the menu
+   *
+   * @return Menu Component located in the menu at the specified index
+   */
+  public Component getMenuComponent(int index)
+  {
+    if (getPopupMenu() == null || getMenuComponentCount() == 0)
+      return null;
+    
+    return (Component) popupMenu.getComponentAtIndex(index);
+  }
+
+  /**
+   * Return components belonging to this menu
+   *
+   * @return components belonging to this menu
+   */
+  public Component[] getMenuComponents()
+  {
+    return getPopupMenu().getComponents();
+  }
+
+  /**
+   * Checks if this menu is a top level menu. The menu is top
+   * level menu if it is inside the menu bar. While if the menu
+   * inside some other menu, it is considered to be a pull-right menu.
+   *
+   * @return true if this menu is top level menu, and false otherwise
+   */
+  public boolean isTopLevelMenu()
+  {
+    return getParent() instanceof JMenuBar;
+  }
+
+  /**
+   * Checks if given component exists in this menu. The submenus of
+   * this menu are checked as well
+   *
+   * @param component Component to look for
+   *
+   * @return true if the given component exists in this menu, and false otherwise
+   */
+  public boolean isMenuComponent(Component component)
+  {
+    return false;
+  }
+
+  /**
+   * Returns popup menu associated with the menu.
+   *
+   * @return popup menu associated with the menu.
+   */
+  public JPopupMenu getPopupMenu()
+  {
+    if (popupMenu == null)
+      {
+        popupMenu = new JPopupMenu();
+        popupMenu.setInvoker(this);
+      }
+    return popupMenu;
+  }
+
+  /**
+   * Adds MenuListener to the menu
+   *
+   * @param listener MenuListener to add
+   */
+  public void addMenuListener(MenuListener listener)
+  {
+    listenerList.add(MenuListener.class, listener);
+  }
+
+  /**
+   * Removes MenuListener from the menu
+   *
+   * @param listener MenuListener to remove
+   */
+  public void removeMenuListener(MenuListener listener)
+  {
+    listenerList.remove(MenuListener.class, listener);
+  }
+
+  /**
+   * Returns all registered <code>MenuListener</code> objects.
+   *
+   * @return an array of listeners
+   * 
+   * @since 1.4
+   */
+  public MenuListener[] getMenuListeners()
+  {
+    return (MenuListener[]) listenerList.getListeners(MenuListener.class);
+  }
+
+  /**
+   * This method fires MenuEvents to all menu's MenuListeners. In this case
+   * menuSelected() method of MenuListeners is called to indicated that the menu
+   * was selected.
+   */
+  protected void fireMenuSelected()
+  {
+    MenuListener[] listeners = getMenuListeners();
+
+    for (int index = 0; index < listeners.length; ++index)
+      listeners[index].menuSelected(menuEvent);
+  }
+
+  /**
+   * This method fires MenuEvents to all menu's MenuListeners. In this case
+   * menuDeselected() method of MenuListeners is called to indicated that the menu
+   * was deselected.
+   */
+  protected void fireMenuDeselected()
+  {
+    EventListener[] ll = listenerList.getListeners(MenuListener.class);
+
+    for (int i = 0; i < ll.length; i++)
+      ((MenuListener) ll[i]).menuDeselected(menuEvent);
+  }
+
+  /**
+   * This method fires MenuEvents to all menu's MenuListeners. In this case
+   * menuSelected() method of MenuListeners is called to indicated that the menu
+   * was cancelled. The menu is cancelled when it's popup menu is close without selection.
+   */
+  protected void fireMenuCanceled()
+  {
+    EventListener[] ll = listenerList.getListeners(MenuListener.class);
+
+    for (int i = 0; i < ll.length; i++)
+      ((MenuListener) ll[i]).menuCanceled(menuEvent);
+  }
+
+  /**
+   * Creates WinListener that listens to the menu;s popup menu.
+   *
+   * @param popup JPopupMenu to listen to
+   *
+   * @return The WinListener
+   */
+  protected WinListener createWinListener(JPopupMenu popup)
+  {
+    return new WinListener(popup);
+  }
+
+  /**
+   * Method of the MenuElementInterface. It reacts to the selection
+   * changes in the menu. If this menu was selected, then it
+   * displayes popup menu associated with it and if this menu was
+   * deselected it hides the popup menu.
+   *
+   * @param changed true if the menu was selected and false otherwise
+   */
+  public void menuSelectionChanged(boolean changed)
+  {
+    // if this menu selection is true, then activate this menu and 
+    // display popup associated with this menu
+    setSelectedHelper(changed, isEnabled(), true);
+  }
+
+  /**
+   * Method of MenuElement interface. Returns sub components of
+   * this menu.
+   *
+   * @return array containing popupMenu that is associated with this menu
+   */
+  public MenuElement[] getSubElements()
+  {
+    return new MenuElement[] { popupMenu };
+  }
+
+  /**
+   * @return Returns reference to itself
+   */
+  public Component getComponent()
+  {
+    return this;
+  }
+
+  /**
+   * This method is overriden with empty implementation, s.t the
+   * accelerator couldn't be set for the menu. The mnemonic should
+   * be used for the menu instead.
+   *
+   * @param keystroke accelerator for this menu
+   */
+  public void setAccelerator(KeyStroke keystroke)
+  {
+    throw new Error("setAccelerator() is not defined for JMenu.  Use setMnemonic() instead.");
+  }
+
+  /**
+   * This method process KeyEvent occuring when the menu is visible
+   *
+   * @param event The KeyEvent
+   */
+  protected void processKeyEvent(KeyEvent event)
+  {
+    MenuSelectionManager.defaultManager().processKeyEvent(event);
+  }
+
+  /**
+   * Programatically performs click
+   *
+   * @param time Number of milliseconds for which this menu stays pressed
+   */
+  public void doClick(int time)
+  {
+    getModel().setArmed(true);
+    getModel().setPressed(true);
+    try
+      {
+	java.lang.Thread.sleep(time);
+      }
+    catch (java.lang.InterruptedException e)
+      {
+	// probably harmless
+      }
+
+    getModel().setPressed(false);
+    getModel().setArmed(false);
+    popupMenu.show(this, this.getWidth(), 0);
+  }
+
+  /**
+   * A string that describes this JMenu. Normally only used
+   * for debugging.
+   *
+   * @return A string describing this JMenu
+   */
+  protected String paramString()
+  {
+    return super.paramString();
+  }
+
+  public AccessibleContext getAccessibleContext()
+  {
+    if (accessibleContext == null)
+      accessibleContext = new AccessibleJMenu();
+
+    return accessibleContext;
+  }
+
+  /**
+   * Implements support for assisitive technologies for <code>JMenu</code>.
+   */
+  protected class AccessibleJMenu extends AccessibleJMenuItem
+    implements AccessibleSelection
+  {
+    private static final long serialVersionUID = -8131864021059524309L;
+
+    protected AccessibleJMenu()
+    {
+      // Nothing to do here.
+    }
+
+    /**
+     * Returns the number of accessible children of this object.
+     *
+     * @return the number of accessible children of this object
+     */
+    public int getAccessibleChildrenCount()
+    {
+      Component[] children = getMenuComponents();
+      int count = 0;
+      for (int i = 0; i < children.length; i++)
+        {
+          if (children[i] instanceof Accessible)
+            count++;
+        }
+      return count;
+    }
+
+    /**
+     * Returns the accessible child with the specified <code>index</code>.
+     *
+     * @param index the index of the child to fetch
+     *
+     * @return the accessible child with the specified <code>index</code>
+     */
+    public Accessible getAccessibleChild(int index)
+    {
+      Component[] children = getMenuComponents();
+      int count = 0;
+      Accessible found = null;
+      for (int i = 0; i < children.length; i++)
+        {
+          if (children[i] instanceof Accessible)
+            {
+              if (count == index)
+                {
+                  found = (Accessible) children[i];
+                  break;
+                }
+              count++;
+            }
+        }
+      return found;
+    }
+
+    /**
+     * Returns the accessible selection of this object. AccessibleJMenus handle
+     * their selection themselves, so we always return <code>this</code> here.
+     *
+     * @return the accessible selection of this object
+     */
+    public AccessibleSelection getAccessibleSelection()
+    {
+      return this;
+    }
+
+    /**
+     * Returns the selected accessible child with the specified
+     * <code>index</code>.
+     *
+     * @param index the index of the accessible selected child to return
+     *
+     * @return the selected accessible child with the specified
+     *         <code>index</code>
+     */
+    public Accessible getAccessibleSelection(int index)
+    {
+      Accessible selected = null;
+      // Only one item can be selected, which must therefore have index == 0.
+      if (index == 0)
+        {
+          MenuSelectionManager msm = MenuSelectionManager.defaultManager();
+          MenuElement[] me = msm.getSelectedPath();
+          if (me != null)
+            {
+              for (int i = 0; i < me.length; i++)
+                {
+                  if (me[i] == JMenu.this)
+                    {
+                      // This JMenu is selected, find and return the next
+                      // JMenuItem in the path.
+                      do
+                        {
+                          if (me[i] instanceof Accessible)
+                            {
+                              selected = (Accessible) me[i];
+                              break;
+                            }
+                          i++;
+                        } while (i < me.length);
+                    }
+                  if (selected != null)
+                    break;
+                }
+            }
+        }
+      return selected;
+    }
+
+    /**
+     * Returns <code>true</code> if the accessible child with the specified
+     * index is selected, <code>false</code> otherwise.
+     *
+     * @param index the index of the accessible child to check
+     *
+     * @return <code>true</code> if the accessible child with the specified
+     *         index is selected, <code>false</code> otherwise
+     */
+    public boolean isAccessibleChildSelected(int index)
+    {
+      boolean selected = false;
+      MenuSelectionManager msm = MenuSelectionManager.defaultManager();
+      MenuElement[] me = msm.getSelectedPath();
+      if (me != null)
+        {
+          Accessible toBeFound = getAccessibleChild(index);
+          for (int i = 0; i < me.length; i++)
+            {
+              if (me[i] == toBeFound)
+                {
+                  selected = true;
+                  break;
+                }
+            }
+        }
+      return selected;
+    }
+
+    /**
+     * Returns the accessible role of this object, which is
+     * {@link AccessibleRole#MENU} for the AccessibleJMenu.
+     *
+     * @return the accessible role of this object
+     */
+    public AccessibleRole getAccessibleRole()
+    {
+      return AccessibleRole.MENU;
+    }
+
+    /**
+     * Returns the number of selected accessible children. This will be
+     * <code>0</code> if no item is selected, or <code>1</code> if an item
+     * is selected. AccessibleJMenu can have maximum 1 selected item.
+     *
+     * @return the number of selected accessible children
+     */
+    public int getAccessibleSelectionCount()
+    {
+      int count = 0;
+      MenuSelectionManager msm = MenuSelectionManager.defaultManager();
+      MenuElement[] me = msm.getSelectedPath();
+      if (me != null)
+        {
+          for (int i = 0; i < me.length; i++)
+            {
+              if (me[i] == JMenu.this)
+                {
+                  if (i + 1 < me.length)
+                    {
+                      count = 1;
+                      break;
+                    }
+                }
+            }
+        }
+      return count;
+    }
+
+    /**
+     * Selects the accessible child with the specified index.
+     *
+     * @param index the index of the accessible child to select
+     */
+    public void addAccessibleSelection(int index)
+    {
+      Accessible child = getAccessibleChild(index);
+      if (child != null && child instanceof JMenuItem)
+        {
+          JMenuItem mi = (JMenuItem) child;
+          MenuSelectionManager msm = MenuSelectionManager.defaultManager();
+          msm.setSelectedPath(createPath(JMenu.this));
+        }
+    }
+
+    /**
+     * Removes the item with the specified index from the selection.
+     *
+     * @param index the index of the selected item to remove from the selection
+     */
+    public void removeAccessibleSelection(int index)
+    {
+      Accessible child = getAccessibleChild(index);
+      if (child != null)
+        {
+          MenuSelectionManager msm = MenuSelectionManager.defaultManager();
+          MenuElement[] oldSelection = msm.getSelectedPath();
+          for (int i = 0; i < oldSelection.length; i++)
+            {
+              if (oldSelection[i] == child)
+                {
+                  // Found the specified child in the selection. Remove it
+                  // from the selection.
+                  MenuElement[] newSel = new MenuElement[i - 1];
+                  System.arraycopy(oldSelection, 0, newSel, 0, i - 1);
+                  msm.setSelectedPath(newSel);
+                  break;
+                }
+            }
+        }
+    }
+
+    /**
+     * Removes all possibly selected accessible children of this object from
+     * the selection.
+     */
+    public void clearAccessibleSelection()
+    {
+      MenuSelectionManager msm = MenuSelectionManager.defaultManager();
+      MenuElement[] oldSelection = msm.getSelectedPath();
+      for (int i = 0; i < oldSelection.length; i++)
+        {
+          if (oldSelection[i] == JMenu.this)
+            {
+              // Found this menu in the selection. Remove all children from
+              // the selection.
+              MenuElement[] newSel = new MenuElement[i];
+              System.arraycopy(oldSelection, 0, newSel, 0, i);
+              msm.setSelectedPath(newSel);
+              break;
+            }
+        }
+    }
+
+    /**
+     * AccessibleJMenu don't support multiple selection, so this method
+     * does nothing.
+     */
+    public void selectAllAccessibleSelection()
+    {
+      // Nothing to do here.
+    }
+  }
+
+  protected class WinListener extends WindowAdapter implements Serializable
+  {
+    private static final long serialVersionUID = -6415815570638474823L;
+
+    /**
+     * Creates a new <code>WinListener</code>.
+     *
+     * @param popup the popup menu which is observed
+     */
+    public WinListener(JPopupMenu popup)
+    {
+      // TODO: What should we do with the popup argument?
+    }
+
+    /**
+     * Receives notification when the popup menu is closing and deselects
+     * the menu.
+     *
+     * @param event the window event
+     */
+    public void windowClosing(WindowEvent event)
+    {
+      setSelected(false);
+    }
+  }
+
+  /**
+   * This class listens to PropertyChangeEvents occuring in menu's action
+   */
+  private class ActionChangedListener implements PropertyChangeListener
+  {
+    /** menu item associated with the action */
+    private JMenuItem menuItem;
+
+    /** Creates new ActionChangedListener and adds it to menuItem's action */
+    public ActionChangedListener(JMenuItem menuItem)
+    {
+      this.menuItem = menuItem;
+
+      Action a = menuItem.getAction();
+      if (a != null)
+	a.addPropertyChangeListener(this);
+    }
+
+    /**This method is invoked when some change occures in menuItem's action*/
+    public void propertyChange(PropertyChangeEvent evt)
+    {
+      // FIXME: Need to implement
+    }
+  }
+
+  /**
+   * Creates an array to be feeded as argument to
+   * {@link MenuSelectionManager#setSelectedPath(MenuElement[])} for the
+   * specified element. This has the effect of selecting the specified element
+   * and all its parents.
+   *
+   * @param leaf the leaf element for which to create the selected path
+   *
+   * @return the selected path array
+   */
+  MenuElement[] createPath(JMenu leaf)
+  {
+    ArrayList path = new ArrayList();
+    MenuElement[] array = null;
+    Component current = leaf.getPopupMenu();
+    while (true)
+      {
+        if (current instanceof JPopupMenu)
+          {
+            JPopupMenu popupMenu = (JPopupMenu) current;
+            path.add(0, popupMenu);
+            current = popupMenu.getInvoker();
+          }
+        else if (current instanceof JMenu)
+          {
+            JMenu menu = (JMenu) current;
+            path.add(0, menu);
+            current = menu.getParent();
+          }
+        else if (current instanceof JMenuBar)
+          {
+            JMenuBar menuBar = (JMenuBar) current;
+            path.add(0, menuBar);
+            array = new MenuElement[path.size()];
+            array = (MenuElement[]) path.toArray(array);
+            break;
+          }
+      }
+    return array;
+  }
+}

Added: llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JMenuBar.java
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JMenuBar.java?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JMenuBar.java (added)
+++ llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JMenuBar.java Thu Nov  8 16:56:19 2007
@@ -0,0 +1,685 @@
+/* JMenuBar.java --
+   Copyright (C) 2002, 2004, 2005, 2006  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;
+
+import java.awt.Component;
+import java.awt.Graphics;
+import java.awt.Insets;
+import java.awt.event.KeyEvent;
+import java.awt.event.MouseEvent;
+
+import javax.accessibility.Accessible;
+import javax.accessibility.AccessibleContext;
+import javax.accessibility.AccessibleRole;
+import javax.accessibility.AccessibleSelection;
+import javax.accessibility.AccessibleStateSet;
+import javax.swing.plaf.MenuBarUI;
+
+import javax.swing.border.Border;
+
+/**
+ * JMenuBar is a container for menu's. For a menu bar to be seen on the
+ * screen, at least one menu should be added to it. Just like adding
+ * components to container, one can use add() to add menu's to the menu bar.
+ * Menu's will be displayed in the menu  bar in the order they were added.
+ * The JMenuBar uses selectionModel to keep track of selected menu index.
+ * JMenuBar's selectionModel will fire ChangeEvents to its registered 
+ * listeners when the selected index changes.
+ */
+public class JMenuBar extends JComponent implements Accessible, MenuElement
+{
+  /**
+   * Provides accessibility support for <code>JMenuBar</code>.
+   * 
+   * @author Roman Kennke (kennke at aicas.com)
+   */
+  protected class AccessibleJMenuBar extends AccessibleJComponent
+    implements AccessibleSelection
+  {
+
+    /**
+     * Returns the number of selected items in the menu bar. Possible values
+     * are <code>0</code> if nothing is selected, or <code>1</code> if one
+     * item is selected.
+     *
+     * @return the number of selected items in the menu bar
+     */
+    public int getAccessibleSelectionCount()
+    {
+      int count = 0;
+      if (getSelectionModel().getSelectedIndex() != -1)
+        count = 1;
+      return count;
+    }
+
+    /**
+     * Returns the selected with index <code>i</code> menu, or
+     * <code>null</code> if the specified menu is not selected.
+     *
+     * @param i the index of the menu to return
+     *
+     * @return the selected with index <code>i</code> menu, or
+     *         <code>null</code> if the specified menu is not selected
+     */
+    public Accessible getAccessibleSelection(int i)
+    {
+      if (getSelectionModel().getSelectedIndex() != i)
+        return null;
+      return getMenu(i);
+    }
+
+    /**
+     * Returns <code>true</code> if the specified menu is selected,
+     * <code>false</code> otherwise.
+     *
+     * @param i the index of the menu to check
+     *
+     *@return <code>true</code> if the specified menu is selected,
+     *        <code>false</code> otherwise
+     */
+    public boolean isAccessibleChildSelected(int i)
+    {
+      return getSelectionModel().getSelectedIndex() == i;
+    }
+
+    /**
+     * Selects the menu with index <code>i</code>. If another menu is already
+     * selected, this will be deselected.
+     *
+     * @param i the menu to be selected
+     */
+    public void addAccessibleSelection(int i)
+    {
+      getSelectionModel().setSelectedIndex(i);
+    }
+
+    /**
+     * Deselects the menu with index <code>i</code>.
+     *
+     * @param i the menu index to be deselected
+     */
+    public void removeAccessibleSelection(int i)
+    {
+      if (getSelectionModel().getSelectedIndex() == i)
+        getSelectionModel().clearSelection();
+    }
+
+    /**
+     * Deselects all possibly selected menus.
+     */
+    public void clearAccessibleSelection()
+    {
+      getSelectionModel().clearSelection();
+    }
+
+    /**
+     * In menu bars it is not possible to select all items, so this method
+     * does nothing.
+     */
+    public void selectAllAccessibleSelection()
+    {
+      // In menu bars it is not possible to select all items, so this method
+      // does nothing.
+    }
+
+    /**
+     * Returns the accessible role of <code>JMenuBar</code>, which is
+     * {@link AccessibleRole#MENU_BAR}.
+     *
+     * @return the accessible role of <code>JMenuBar</code>, which is
+     *         {@link AccessibleRole#MENU_BAR}
+     */
+    public AccessibleRole getAccessibleRole()
+    {
+      return AccessibleRole.MENU_BAR;
+    }
+
+    /**
+     * Returns the <code>AccessibleSelection</code> for this object. This
+     * method returns <code>this</code>, since the
+     * <code>AccessibleJMenuBar</code> manages its selection itself.
+     *
+     * @return the <code>AccessibleSelection</code> for this object
+     */
+    public AccessibleSelection getAccessibleSelection()
+    {
+      return this;
+    }
+
+    /**
+     * Returns the state of this <code>AccessibleJMenuBar</code>.
+     *
+     * @return the state of this <code>AccessibleJMenuBar</code>.
+     */
+    public AccessibleStateSet getAccessibleStateSet()
+    {
+      AccessibleStateSet stateSet = super.getAccessibleStateSet();
+      // TODO: Figure out what state must be added to the super state set.
+      return stateSet;
+    }
+  }
+
+  private static final long serialVersionUID = -8191026883931977036L;
+
+  /** JMenuBar's model. It keeps track of selected menu's index */
+  private transient SingleSelectionModel selectionModel;
+
+  /* borderPainted property indicating if the menuBar's border will be painted*/
+  private boolean borderPainted;
+
+  /* margin between menu bar's border and its menues*/
+  private Insets margin;
+
+  /**
+   * Creates a new JMenuBar object.
+   */
+  public JMenuBar()
+  {
+    selectionModel = new DefaultSingleSelectionModel();
+    borderPainted = true;
+    updateUI();
+  }
+
+  /**
+   * Adds menu to the menu bar
+   *
+   * @param c menu to add
+   *
+   * @return reference to the added menu
+   */
+  public JMenu add(JMenu c)
+  {
+    c.setAlignmentX(Component.LEFT_ALIGNMENT);
+    super.add(c);
+    return c;
+  }
+
+  /**
+   * This method overrides addNotify() in the Container to register
+   * this menu bar with the current keyboard manager.
+   */
+  public void addNotify()
+  {
+    super.addNotify();
+    KeyboardManager.getManager().registerJMenuBar(this);
+  }
+
+  public AccessibleContext getAccessibleContext()
+  {
+    if (accessibleContext == null)
+      accessibleContext = new AccessibleJMenuBar();
+    return accessibleContext;
+  }
+
+  /**
+   * Returns reference to this menu bar
+   *
+   * @return reference to this menu bar
+   */
+  public Component getComponent()
+  {
+    return this;
+  }
+
+  /**
+   * Returns component at the specified index.
+   *
+   * @param i index of the component to get
+   *
+   * @return component at the specified index. Null is returned if
+   * component at the specified index doesn't exist.
+   * @deprecated Replaced by getComponent(int)
+   */
+  public Component getComponentAtIndex(int i)
+  {
+    return getComponent(i);
+  }
+
+  /**
+   * Returns index of the specified component
+   *
+   * @param c Component to search for
+   *
+   * @return index of the specified component. -1 is returned if
+   * specified component doesnt' exist in the menu bar.
+   */
+  public int getComponentIndex(Component c)
+  {
+    Component[] comps = getComponents();
+
+    int index = -1;
+
+    for (int i = 0; i < comps.length; i++)
+      {
+	if (comps[i].equals(c))
+	  {
+	    index = i;
+	    break;
+	  }
+      }
+
+    return index;
+  }
+
+  /**
+   * DOCUMENT ME!
+   *
+   * @return DOCUMENT ME!
+   */
+  public JMenu getHelpMenu()
+  {
+    return null;
+  }
+
+  /**
+   * Returns margin betweeen menu bar's border and its menues
+   *
+   * @return margin between menu bar's border and its menues
+   */
+  public Insets getMargin()
+  {
+    if (margin == null)
+      return new Insets(0, 0, 0, 0);
+    else
+      return margin;
+  }
+
+  /**
+   * Return menu at the specified index. If component at the
+   * specified index is not a menu, then null is returned.
+   *
+   * @param index index to look for the menu
+   *
+   * @return menu at specified index, or null if menu doesn't exist
+   * at the specified index.
+   */
+  public JMenu getMenu(int index)
+  {
+    if (getComponentAtIndex(index) instanceof JMenu)
+      return (JMenu) getComponentAtIndex(index);
+    else
+      return null;
+  }
+
+  /**
+   * Returns number of menu's in this menu bar
+   *
+   * @return number of menu's in this menu bar
+   */
+  public int getMenuCount()
+  {
+    return getComponentCount();
+  }
+
+  /**
+   * Returns selection model for this menu bar. SelectionModel
+   * keeps track of the selected menu in the menu bar. Whenever
+   * selected property of selectionModel changes, the ChangeEvent
+   * will be fired its ChangeListeners.
+   *
+   * @return selection model for this menu bar.
+   */
+  public SingleSelectionModel getSelectionModel()
+  {
+    return selectionModel;
+  }
+
+  /**
+   * Method of MenuElement interface. It returns subcomponents
+   * of the menu bar, which are all the menues that it contains.
+   *
+   * @return MenuElement[] array containing menues in this menu bar
+   */
+  public MenuElement[] getSubElements()
+  {
+    MenuElement[] subElements = new MenuElement[getComponentCount()];
+
+    int j = 0;
+    boolean doResize = false;
+    MenuElement menu;
+    for (int i = 0; i < getComponentCount(); i++)
+      {
+        menu = getMenu(i);
+        if (menu != null)
+          {
+            subElements[j++] = (MenuElement) menu;
+          }
+        else
+          doResize = true;
+      }
+
+    if (! doResize)
+      return subElements;
+    else
+      {
+        MenuElement[] subElements2 = new MenuElement[j];
+        for (int i = 0; i < j; i++)
+          subElements2[i] = subElements[i];
+
+        return subElements2;
+      }
+  }
+
+  /**
+    * Set the "UI" property of the menu bar, which is a look and feel class
+    * responsible for handling the menuBar's input events and painting it.
+    *
+    * @return The current "UI" property
+    */
+  public MenuBarUI getUI()
+  {
+    return (MenuBarUI) ui;
+  }
+
+  /**
+   * This method returns a name to identify which look and feel class will be
+   * the UI delegate for the menu bar.
+   *
+   * @return The Look and Feel classID. "MenuBarUI"
+   */
+  public String getUIClassID()
+  {
+    return "MenuBarUI";
+  }
+
+  /**
+   * Returns true if menu bar paints its border and false otherwise
+   *
+   * @return true if menu bar paints its border and false otherwise
+   */
+  public boolean isBorderPainted()
+  {
+    return borderPainted;
+  }
+
+  /**
+   * Returns true if some menu in menu bar is selected.
+   *
+   * @return true if some menu in menu bar is selected and false otherwise
+   */
+  public boolean isSelected()
+  {
+    return selectionModel.isSelected();
+  }
+
+  /**
+   * This method does nothing by default. This method is need for the
+   * MenuElement interface to be implemented.
+   *
+   * @param isIncluded true if menuBar is included in the selection
+   * and false otherwise
+   */
+  public void menuSelectionChanged(boolean isIncluded)
+  {
+    // Do nothing - needed for implementation of MenuElement interface
+  }
+
+  /**
+   * Paints border of the menu bar, if its borderPainted property is set to
+   * true.
+   *
+   * @param g The graphics context with which to paint the border
+   */
+  protected void paintBorder(Graphics g)
+  {
+    if (borderPainted)
+      {
+        Border border = getBorder();
+        if (border != null)
+          getBorder().paintBorder(this, g, 0, 0, getSize(null).width,
+                                  getSize(null).height);
+      }
+  }
+
+  /**
+   * A string that describes this JMenuBar. Normally only used
+   * for debugging.
+   *
+   * @return A string describing this JMenuBar
+   */
+  protected String paramString()
+  {
+    StringBuffer sb = new StringBuffer();
+    sb.append(super.paramString());
+    sb.append(",margin=");
+    if (getMargin() != null)
+      sb.append(getMargin());
+    sb.append(",paintBorder=").append(isBorderPainted());
+    return sb.toString();
+  }
+
+  /**
+   * Process key events forwarded from MenuSelectionManager. This method
+   * doesn't do anything. It is here to conform to the MenuElement interface.
+   *
+   * @param e event forwarded from MenuSelectionManager
+   * @param path path to the menu element from which event was generated
+   * @param manager MenuSelectionManager for the current menu hierarchy
+   *
+   */
+  public void processKeyEvent(KeyEvent e, MenuElement[] path,
+                              MenuSelectionManager manager)
+  {
+    // Do nothing - needed for implementation of MenuElement interface
+  }
+
+  /**
+   * This method overrides JComponent.processKeyBinding to allow the 
+   * JMenuBar to check all the child components (recursiveley) to see 
+   * if they'll consume the event.
+   * 
+   * @param ks the KeyStroke for the event
+   * @param e the KeyEvent for the event
+   * @param condition the focus condition for the binding
+   * @param pressed true if the key is pressed 
+   */
+  protected boolean processKeyBinding(KeyStroke ks, KeyEvent e, int condition,
+                                      boolean pressed)
+  {
+    // See if the regular JComponent behavior consumes the event
+    if (super.processKeyBinding(ks, e, condition, pressed))
+      return true;
+    
+    // If not, have to recursively check all the child menu elements to see 
+    // if they want it    
+    MenuElement[] children = getSubElements();
+    for (int i = 0; i < children.length; i++)
+      if (processKeyBindingHelper(children[i], ks, e, condition, pressed))
+        return true;
+    return false;
+  }
+  
+  /**
+   * This is a helper method to recursively check the children of this
+   * JMenuBar to see if they will consume a key event via key bindings.  
+   * This is used for menu accelerators.
+   * @param menuElement the menuElement to check (and check all its children)
+   * @param ks the KeyStroke for the event
+   * @param e the KeyEvent that may be consumed
+   * @param condition the focus condition for the binding
+   * @param pressed true if the key was pressed
+   * @return true <code>menuElement</code> or one of its children consume
+   * the event (processKeyBinding returns true for menuElement or one of
+   * its children).
+   */
+  static boolean processKeyBindingHelper(MenuElement menuElement, KeyStroke ks,
+                                         KeyEvent e, int condition,
+                                         boolean pressed)
+  {
+    if (menuElement == null)
+      return false;
+
+    // First check the menuElement itself, if it's a JComponent
+    if (menuElement instanceof JComponent
+        && ((JComponent) menuElement).processKeyBinding(ks, e, condition,
+                                                        pressed))
+      return true;
+    
+    // If that didn't consume it, check all the children recursively
+    MenuElement[] children = menuElement.getSubElements();
+    for (int i = 0; i < children.length; i++)
+      if (processKeyBindingHelper(children[i], ks, e, condition, pressed))
+        return true;
+    return false;
+  }
+  
+  /**
+   * Process mouse events forwarded from MenuSelectionManager. This method
+   * doesn't do anything. It is here to conform to the MenuElement interface.
+   *
+   * @param event event forwarded from MenuSelectionManager
+   * @param path path to the menu element from which event was generated
+   * @param manager MenuSelectionManager for the current menu hierarchy
+   *
+   */
+  public void processMouseEvent(MouseEvent event, MenuElement[] path,
+                                MenuSelectionManager manager)
+  {
+    // Do nothing - needed for implementation of MenuElement interface
+  }
+
+  /**
+   * This method overrides removeNotify() in the Container to
+   * unregister this menu bar from the current keyboard manager.
+   */
+  public void removeNotify()
+  {
+    KeyboardManager.getManager().unregisterJMenuBar(this);
+    super.removeNotify();
+  }
+
+  /**
+   * Sets painting status of the border. If 'b' is true then menu bar's
+   * border will be painted, and it will not be painted otherwise.
+   *
+   * @param b indicates if menu bar's border should be painted.
+   */
+  public void setBorderPainted(boolean b)
+  {
+    if (b != borderPainted)
+      {
+	boolean old = borderPainted;
+	borderPainted = b;
+	firePropertyChange("borderPainted", old, b);
+	revalidate();
+	repaint();
+      }
+  }
+
+  /**
+   * Sets help menu for this menu bar
+   *
+   * @param menu help menu
+   *
+   * @specnote The specification states that this method is not yet implemented
+   *           and should throw an exception.
+   */
+  public void setHelpMenu(JMenu menu)
+  {
+    // We throw an Error here, just as Sun's JDK does.
+    throw new Error("setHelpMenu() not yet implemented.");
+  }
+
+  /**
+   * Sets the menu bar's "margin" bound property,  which represents
+   * distance between the menubar's border and its menus.
+   * icon. When marging property is modified, PropertyChangeEvent will
+   * be fired to menuBar's PropertyChangeListener's.
+   *
+   * @param m distance between the menubar's border and its menus.
+   *
+   */
+  public void setMargin(Insets m)
+  {
+    if (m != margin)
+      {
+	Insets oldMargin = margin;
+	margin = m;
+	firePropertyChange("margin", oldMargin, margin);
+      }
+  }
+
+  /**
+   * Changes menu bar's selection to the specified menu.
+   * This method updates selected index of menu bar's selection model,
+   * which results in a model firing change event.
+   *
+   * @param sel menu to select
+   */
+  public void setSelected(Component sel)
+  {
+    int index = getComponentIndex(sel);
+    selectionModel.setSelectedIndex(index);
+  }
+
+  /**
+   * Sets menuBar's selection model to the one specified
+   *
+   * @param model SingleSelectionModel that needs to be set for this menu bar
+   */
+  public void setSelectionModel(SingleSelectionModel model)
+  {
+    if (selectionModel != model)
+      {
+	SingleSelectionModel oldModel = selectionModel;
+	selectionModel = model;
+	firePropertyChange("model", oldModel, selectionModel);
+      }
+  }
+
+  /**
+   * Set the "UI" property of the menu bar, which is a look and feel class
+   * responsible for handling menuBar's input events and painting it.
+   *
+   * @param ui The new "UI" property
+   */
+  public void setUI(MenuBarUI ui)
+  {
+    super.setUI(ui);
+  }
+
+  /**
+   * Set the "UI" property to a class constructed, via the {@link
+   * UIManager}, from the current look and feel.
+   */
+  public void updateUI()
+  {
+    setUI((MenuBarUI) UIManager.getUI(this));
+  }
+}

Added: llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JMenuItem.java
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JMenuItem.java?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JMenuItem.java (added)
+++ llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JMenuItem.java Thu Nov  8 16:56:19 2007
@@ -0,0 +1,836 @@
+/* JMenuItem.java --
+   Copyright (C) 2002, 2004, 2005, 2006  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;
+
+import java.awt.Component;
+import java.awt.event.InputEvent;
+import java.awt.event.KeyEvent;
+import java.awt.event.MouseEvent;
+import java.beans.PropertyChangeEvent;
+import java.beans.PropertyChangeListener;
+import java.util.EventListener;
+
+import javax.accessibility.Accessible;
+import javax.accessibility.AccessibleContext;
+import javax.accessibility.AccessibleRole;
+import javax.accessibility.AccessibleState;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;
+import javax.swing.event.MenuDragMouseEvent;
+import javax.swing.event.MenuDragMouseListener;
+import javax.swing.event.MenuKeyEvent;
+import javax.swing.event.MenuKeyListener;
+import javax.swing.plaf.MenuItemUI;
+
+/**
+ * JMenuItem represents element in the menu. It inherits most of
+ * its functionality from AbstractButton, however its behavior somewhat
+ * varies from it. JMenuItem fire different kinds of events.
+ * PropertyChangeEvents are fired when menuItems properties are modified;
+ * ChangeEvents are fired when menuItem's state changes and actionEvents are
+ * fired when menu item is selected. In addition to this events menuItem also
+ * fire MenuDragMouseEvent and MenuKeyEvents when mouse is dragged over
+ * the menu item or associated key with menu item is invoked respectively.
+ */
+public class JMenuItem extends AbstractButton implements Accessible,
+                                                         MenuElement
+{
+  private static final long serialVersionUID = -1681004643499461044L;
+
+  /** Combination of keyboard keys that can be used to activate this menu item */
+  private KeyStroke accelerator;
+
+  /**
+   * Creates a new JMenuItem object.
+   */
+  public JMenuItem()
+  {
+    super();
+    init(null, null);
+  }
+
+  /**
+   * Creates a new JMenuItem with the given icon.
+   *
+   * @param icon Icon that will be displayed on the menu item
+   */
+  public JMenuItem(Icon icon)
+  {
+    // FIXME: The requestedFocusEnabled property should
+    // be set to false, when only icon is set for menu item.
+    super();
+    init(null, icon);
+  }
+
+  /**
+   * Creates a new JMenuItem with the given label.
+   *
+   * @param text label for the menu item
+   */
+  public JMenuItem(String text)
+  {
+    this(text, null);
+  }
+
+  /**
+   * Creates a new JMenuItem associated with the specified action.
+   *
+   * @param action action for this menu item
+   */
+  public JMenuItem(Action action)
+  {
+    super();
+    super.setAction(action);
+    init(null, null);
+    if (action != null)
+      {
+	String name = (String) action.getValue(Action.NAME);
+	if (name != null)
+          setName(name);
+
+	KeyStroke accel = (KeyStroke) action.getValue(Action.ACCELERATOR_KEY);
+	if (accel != null)
+          setAccelerator(accel);
+
+	Integer mnemonic = (Integer) action.getValue(Action.MNEMONIC_KEY);
+	if (mnemonic != null)
+          setMnemonic(mnemonic.intValue());
+
+	String command = (String) action.getValue(Action.ACTION_COMMAND_KEY);
+	if (command != null)
+          setActionCommand(command);
+      }
+  }
+
+  /**
+   * Creates a new JMenuItem with specified text and icon.
+   * Text is displayed to the left of icon by default.
+   *
+   * @param text label for this menu item
+   * @param icon icon that will be displayed on this menu item
+   */
+  public JMenuItem(String text, Icon icon)
+  {
+    super();
+    init(text, icon);
+  }
+
+  /**
+   * Creates a new JMenuItem object.
+   *
+   * @param text label for this menu item
+   * @param mnemonic - Single key that can be used with a
+   * look-and-feel meta key to activate this menu item. However
+   * menu item should be visible on the screen when mnemonic is used.
+   */
+  public JMenuItem(String text, int mnemonic)
+  {
+    this(text, null);
+    setMnemonic(mnemonic);
+  }
+
+  /**
+   * Initializes this menu item
+   *
+   * @param text label for this menu item
+   * @param icon icon to be displayed for this menu item
+   */
+  protected void init(String text, Icon icon)
+  {
+    super.init(text, icon);
+    setModel(new DefaultButtonModel());
+
+    // Initializes properties for this menu item, that are different
+    // from Abstract button properties. 
+    /* NOTE: According to java specifications paint_border should be set to false,
+      since menu item should not have a border. However running few java programs
+      it seems that menu items and menues can have a border. Commenting
+      out statement below for now. */
+    //borderPainted = false;
+    focusPainted = false;
+    horizontalAlignment = JButton.LEADING;
+    horizontalTextPosition = JButton.TRAILING;
+  }
+
+  /**
+   * Set the "UI" property of the menu item, which is a look and feel class
+   * responsible for handling menuItem's input events and painting it.
+   *
+   * @param ui The new "UI" property
+   */
+  public void setUI(MenuItemUI ui)
+  {
+    super.setUI(ui);
+  }
+  
+  /**
+   * This method sets this menuItem's UI to the UIManager's default for the
+   * current look and feel.
+   */
+  public void updateUI()
+  {
+    setUI((MenuItemUI) UIManager.getUI(this));
+  }
+
+  /**
+   * This method returns a name to identify which look and feel class will be
+   * the UI delegate for the menuItem.
+   *
+   * @return The Look and Feel classID. "MenuItemUI"
+   */
+  public String getUIClassID()
+  {
+    return "MenuItemUI";
+  }
+
+  /**
+   * Returns true if button's model is armed and false otherwise. The
+   * button model is armed if menu item has focus or it is selected.
+   *
+   * @return $boolean$ true if button's model is armed and false otherwise
+   */
+  public boolean isArmed()
+  {
+    return getModel().isArmed();
+  }
+
+  /**
+   * Sets menuItem's "ARMED" property
+   *
+   * @param armed DOCUMENT ME!
+   */
+  public void setArmed(boolean armed)
+  {
+    getModel().setArmed(armed);
+  }
+
+  /**
+   * Enable or disable menu item. When menu item is disabled,
+   * its text and icon are grayed out if they exist.
+   *
+   * @param enabled if true enable menu item, and disable otherwise.
+   */
+  public void setEnabled(boolean enabled)
+  {
+    super.setEnabled(enabled);
+  }
+
+  /**
+   * Return accelerator for this menu item.
+   *
+   * @return $KeyStroke$ accelerator for this menu item.
+   */
+  public KeyStroke getAccelerator()
+  {
+    return accelerator;
+  }
+
+  /**
+   * Sets the key combination which invokes the menu item's action 
+   * listeners without navigating the menu hierarchy. Note that when the 
+   * keyboard accelerator is typed, it will work whether or not the 
+   * menu is currently displayed.
+   * 
+   * @param keystroke accelerator for this menu item.
+   */
+  public void setAccelerator(KeyStroke keystroke)
+  {
+    KeyStroke old = this.accelerator;
+    this.accelerator = keystroke;
+    firePropertyChange ("accelerator", old, keystroke);
+  }
+
+  /**
+   * Configures menu items' properties from properties of the specified action.
+   * This method overrides configurePropertiesFromAction from AbstractButton
+   * to also set accelerator property.
+   *
+   * @param action action to configure properties from
+   */
+  protected void configurePropertiesFromAction(Action action)
+  {
+    super.configurePropertiesFromAction(action);
+
+    if (! (this instanceof JMenu) && action != null)
+      {
+        setAccelerator((KeyStroke) (action.getValue(Action.ACCELERATOR_KEY)));
+        if (accelerator != null)
+          super.registerKeyboardAction(action, accelerator, 
+                                       JComponent.WHEN_IN_FOCUSED_WINDOW);
+      }
+  }
+
+  /**
+   * Creates PropertyChangeListener to listen for the changes in action
+   * properties.
+   *
+   * @param action action to listen to for property changes
+   *
+   * @return $PropertyChangeListener$ Listener that listens to changes in
+   * action properties.
+   */
+  protected PropertyChangeListener createActionPropertyChangeListener(Action action)
+  {
+    return new PropertyChangeListener()
+      {
+	public void propertyChange(PropertyChangeEvent e)
+	{
+	  Action act = (Action) (e.getSource());
+	  configurePropertiesFromAction(act);
+	}
+      };
+  }
+
+  /**
+   * Process mouse events forwarded from MenuSelectionManager.
+   *
+   * @param event event forwarded from MenuSelectionManager
+   * @param path path to the menu element from which event was generated
+   * @param manager MenuSelectionManager for the current menu hierarchy
+   */
+  public void processMouseEvent(MouseEvent event, MenuElement[] path,
+                                MenuSelectionManager manager)
+  {
+    // Fire MenuDragMouseEvents if mouse is being dragged.
+    boolean dragged
+      = (event.getModifiersEx() & InputEvent.BUTTON1_DOWN_MASK) != 0;
+    if (dragged)
+      processMenuDragMouseEvent(createMenuDragMouseEvent(event, path, manager));
+
+    switch (event.getID())
+      {
+      case MouseEvent.MOUSE_CLICKED:
+	break;
+      case MouseEvent.MOUSE_ENTERED:
+	if (isRolloverEnabled())
+	  model.setRollover(true);
+	break;
+      case MouseEvent.MOUSE_EXITED:
+	if (isRolloverEnabled())
+	  model.setRollover(false);
+
+	// for JMenu last element on the path is its popupMenu.
+	// JMenu shouldn't me disarmed.	
+	if (! (path[path.length - 1] instanceof JPopupMenu) && ! dragged)
+	  setArmed(false);
+	break;
+      case MouseEvent.MOUSE_PRESSED:
+	if ((event.getModifiersEx() & InputEvent.BUTTON1_DOWN_MASK) != 0)
+	  {
+	    model.setArmed(true);
+	    model.setPressed(true);
+	  }
+	break;
+      case MouseEvent.MOUSE_RELEASED:
+	break;
+      case MouseEvent.MOUSE_MOVED:
+	break;
+      case MouseEvent.MOUSE_DRAGGED:
+	break;
+      }
+  }
+
+  /**
+   * Creates MenuDragMouseEvent.
+   *
+   * @param event MouseEvent that occured while mouse was pressed.
+   * @param path Path the the menu element where the dragging event was
+   *        originated
+   * @param manager MenuSelectionManager for the current menu hierarchy.
+   *
+   * @return new MenuDragMouseEvent
+   */
+  private MenuDragMouseEvent createMenuDragMouseEvent(MouseEvent event,
+                                                      MenuElement[] path,
+                                                      MenuSelectionManager manager)
+  {
+    return new MenuDragMouseEvent((Component) event.getSource(),
+                                  event.getID(), event.getWhen(),
+                                  event.getModifiers(), event.getX(),
+                                  event.getY(), event.getClickCount(),
+                                  event.isPopupTrigger(), path, manager);
+  }
+
+  /**
+   * Process key events forwarded from MenuSelectionManager.
+   *
+   * @param event event forwarded from MenuSelectionManager
+   * @param path path to the menu element from which event was generated
+   * @param manager MenuSelectionManager for the current menu hierarchy
+   */
+  public void processKeyEvent(KeyEvent event, MenuElement[] path,
+                              MenuSelectionManager manager)
+  {
+    MenuKeyEvent e = new MenuKeyEvent(event.getComponent(), event.getID(),
+                                      event.getWhen(), event.getModifiers(),
+                                      event.getKeyCode(), event.getKeyChar(),
+                                      path, manager);
+    processMenuKeyEvent(e);
+
+    // Consume original key event, if the menu key event has been consumed.
+    if (e.isConsumed())
+      event.consume();
+  }
+
+  /**
+   * This method fires MenuDragMouseEvents to registered listeners.
+   * Different types of MenuDragMouseEvents are fired depending
+   * on the observed mouse event.
+   *
+   * @param event Mouse
+   */
+  public void processMenuDragMouseEvent(MenuDragMouseEvent event)
+  {
+    switch (event.getID())
+      {
+      case MouseEvent.MOUSE_ENTERED:
+	fireMenuDragMouseEntered(event);
+	break;
+      case MouseEvent.MOUSE_EXITED:
+	fireMenuDragMouseExited(event);
+	break;
+      case MouseEvent.MOUSE_DRAGGED:
+	fireMenuDragMouseDragged(event);
+	break;
+      case MouseEvent.MOUSE_RELEASED:
+	fireMenuDragMouseReleased(event);
+	break;
+      }
+  }
+
+  /**
+   * This method fires MenuKeyEvent to registered listeners.
+   * Different types of MenuKeyEvents are fired depending
+   * on the observed key event.
+   *
+   * @param event DOCUMENT ME!
+   */
+  public void processMenuKeyEvent(MenuKeyEvent event)
+  {
+    switch (event.getID())
+    {
+      case KeyEvent.KEY_PRESSED:
+        fireMenuKeyPressed(event);
+        break;
+      case KeyEvent.KEY_RELEASED:
+        fireMenuKeyReleased(event);
+        break;
+      case KeyEvent.KEY_TYPED:
+        fireMenuKeyTyped(event);
+        break;
+      default:
+        break;
+    }
+  }
+
+  /**
+   * Fires MenuDragMouseEvent to all of the menuItem's MouseInputListeners.
+   *
+   * @param event The event signifying that mouse entered menuItem while it was dragged
+   */
+  protected void fireMenuDragMouseEntered(MenuDragMouseEvent event)
+  {
+    EventListener[] ll = listenerList.getListeners(MenuDragMouseListener.class);
+
+    for (int i = 0; i < ll.length; i++)
+      ((MenuDragMouseListener) ll[i]).menuDragMouseEntered(event);
+  }
+
+  /**
+   * Fires MenuDragMouseEvent to all of the menuItem's MouseInputListeners.
+   *
+   * @param event The event signifying that mouse has exited menu item, while it was dragged
+   */
+  protected void fireMenuDragMouseExited(MenuDragMouseEvent event)
+  {
+    EventListener[] ll = listenerList.getListeners(MenuDragMouseListener.class);
+
+    for (int i = 0; i < ll.length; i++)
+      ((MenuDragMouseListener) ll[i]).menuDragMouseExited(event);
+  }
+
+  /**
+   * Fires MenuDragMouseEvent to all of the menuItem's MouseInputListeners.
+   *
+   * @param event The event signifying that mouse is being dragged over the menuItem
+   */
+  protected void fireMenuDragMouseDragged(MenuDragMouseEvent event)
+  {
+    EventListener[] ll = listenerList.getListeners(MenuDragMouseListener.class);
+
+    for (int i = 0; i < ll.length; i++)
+      ((MenuDragMouseListener) ll[i]).menuDragMouseDragged(event);
+  }
+
+  /**
+   * This method fires a MenuDragMouseEvent to all the MenuItem's MouseInputListeners.
+   *
+   * @param event The event signifying that mouse was released while it was dragged over the menuItem
+   */
+  protected void fireMenuDragMouseReleased(MenuDragMouseEvent event)
+  {
+    EventListener[] ll = listenerList.getListeners(MenuDragMouseListener.class);
+
+    for (int i = 0; i < ll.length; i++)
+      ((MenuDragMouseListener) ll[i]).menuDragMouseReleased(event);
+  }
+
+  /**
+   * This method fires a MenuKeyEvent to all the MenuItem's MenuKeyListeners.
+   *
+   * @param event The event signifying that key associated with this menu was pressed
+   */
+  protected void fireMenuKeyPressed(MenuKeyEvent event)
+  {
+    EventListener[] ll = listenerList.getListeners(MenuKeyListener.class);
+
+    for (int i = 0; i < ll.length; i++)
+      ((MenuKeyListener) ll[i]).menuKeyPressed(event);
+  }
+
+  /**
+   * This method fires a MenuKeyEvent to all the MenuItem's MenuKeyListeners.
+   *
+   * @param event The event signifying that key associated with this menu was released
+   */
+  protected void fireMenuKeyReleased(MenuKeyEvent event)
+  {
+    EventListener[] ll = listenerList.getListeners(MenuKeyListener.class);
+
+    for (int i = 0; i < ll.length; i++)
+      ((MenuKeyListener) ll[i]).menuKeyTyped(event);
+  }
+
+  /**
+   * This method fires a MenuKeyEvent to all the MenuItem's MenuKeyListeners.
+   *
+   * @param event The event signifying that key associated with this menu was typed.
+   *        The key is typed when it was pressed and then released
+   */
+  protected void fireMenuKeyTyped(MenuKeyEvent event)
+  {
+    EventListener[] ll = listenerList.getListeners(MenuKeyListener.class);
+
+    for (int i = 0; i < ll.length; i++)
+      ((MenuKeyListener) ll[i]).menuKeyTyped(event);
+  }
+
+  /**
+   * Method of the MenuElement interface.
+   * This method is invoked by MenuSelectionManager when selection of
+   * this menu item has changed. If this menu item was selected then
+   * arm it's model, and disarm the model otherwise. The menu item
+   * is considered to be selected, and thus highlighted when its model
+   * is armed.
+   *
+   * @param changed indicates selection status of this menu item. If changed is
+   * true then menu item is selected and deselected otherwise.
+   */
+  public void menuSelectionChanged(boolean changed)
+  {
+    Component parent = this.getParent();
+    if (changed)
+      {
+	model.setArmed(true);
+
+	if (parent != null && parent instanceof JPopupMenu)
+	  ((JPopupMenu) parent).setSelected(this);
+      }
+    else
+      {
+	model.setArmed(false);
+
+	if (parent != null && parent instanceof JPopupMenu)
+	  ((JPopupMenu) parent).getSelectionModel().clearSelection();
+      }
+  }
+
+  /**
+   * Method of the MenuElement interface.
+   *
+   * @return $MenuElement[]$ Returns array of sub-components for this menu
+   *         item. By default menuItem doesn't have any subcomponents and so
+   *         empty array is returned instead.
+   */
+  public MenuElement[] getSubElements()
+  {
+    return new MenuElement[0];
+  }
+
+  /**
+   * Returns reference to the component that will paint this menu item.
+   *
+   * @return $Component$ Component that will paint this menu item.
+   *         Simply returns reference to this menu item.
+   */
+  public Component getComponent()
+  {
+    return this;
+  }
+
+  /**
+   * Adds a MenuDragMouseListener to this menu item. When mouse
+   * is dragged over the menu item the MenuDragMouseEvents will be
+   * fired, and these listeners will be called.
+   *
+   * @param listener The new listener to add
+   */
+  public void addMenuDragMouseListener(MenuDragMouseListener listener)
+  {
+    listenerList.add(MenuDragMouseListener.class, listener);
+  }
+
+  /**
+   * Removes a MenuDragMouseListener from the menuItem's listener list.
+   *
+   * @param listener The listener to remove
+   */
+  public void removeMenuDragMouseListener(MenuDragMouseListener listener)
+  {
+    listenerList.remove(MenuDragMouseListener.class, listener);
+  }
+
+  /**
+   * Returns all added MenuDragMouseListener objects.
+   *
+   * @return an array of listeners
+   *
+   * @since 1.4
+   */
+  public MenuDragMouseListener[] getMenuDragMouseListeners()
+  {
+    return (MenuDragMouseListener[]) listenerList.getListeners(MenuDragMouseListener.class);
+  }
+
+  /**
+   * Adds an MenuKeyListener to this menu item.  This listener will be
+   * invoked when MenuKeyEvents will be fired by this menu item.
+   *
+   * @param listener The new listener to add
+   */
+  public void addMenuKeyListener(MenuKeyListener listener)
+  {
+    listenerList.add(MenuKeyListener.class, listener);
+  }
+
+  /**
+   * Removes an MenuKeyListener from the menuItem's listener list.
+   *
+   * @param listener The listener to remove
+   */
+  public void removeMenuKeyListener(MenuKeyListener listener)
+  {
+    listenerList.remove(MenuKeyListener.class, listener);
+  }
+
+  /**
+   * Returns all added MenuKeyListener objects.
+   *
+   * @return an array of listeners
+   *
+   * @since 1.4
+   */
+  public MenuKeyListener[] getMenuKeyListeners()
+  {
+    return (MenuKeyListener[]) listenerList.getListeners(MenuKeyListener.class);
+  }
+
+  /**
+   * Returns a string describing the attributes for the <code>JMenuItem</code>
+   * component, for use in debugging.  The return value is guaranteed to be 
+   * non-<code>null</code>, but the format of the string may vary between
+   * implementations.
+   *
+   * @return A string describing the attributes of the <code>JMenuItem</code>.
+   */
+  protected String paramString()
+  {
+    // calling super seems to be sufficient here...
+    return super.paramString();
+  }
+
+  /**
+   * Returns the object that provides accessibility features for this
+   * <code>JMenuItem</code> component.
+   *
+   * @return The accessible context (an instance of 
+   *     {@link AccessibleJMenuItem}).
+   */
+  public AccessibleContext getAccessibleContext()
+  {
+    if (accessibleContext == null)
+      {
+        AccessibleJMenuItem ctx = new AccessibleJMenuItem(); 
+        addChangeListener(ctx);
+        accessibleContext = ctx;
+      }
+
+    return accessibleContext;
+  }
+
+  /**
+   * Provides the accessibility features for the <code>JMenuItem</code> 
+   * component.
+   * 
+   * @see JMenuItem#getAccessibleContext()
+   */
+  protected class AccessibleJMenuItem extends AccessibleAbstractButton
+    implements ChangeListener
+  {
+    private static final long serialVersionUID = 6748924232082076534L;
+
+    private boolean armed;
+    private boolean focusOwner;
+    private boolean pressed;
+    private boolean selected;
+
+    /**
+     * Creates a new <code>AccessibleJMenuItem</code> instance.
+     */
+    AccessibleJMenuItem()
+    {
+      //super(component);
+    }
+
+    /**
+     * Receives notification when the menu item's state changes and fires
+     * appropriate property change events to registered listeners.
+     *
+     * @param event the change event
+     */
+    public void stateChanged(ChangeEvent event)
+    {
+      // This is fired in all cases.
+      firePropertyChange(AccessibleContext.ACCESSIBLE_VISIBLE_DATA_PROPERTY,
+                         Boolean.FALSE, Boolean.TRUE);
+
+      ButtonModel model = getModel();
+
+      // Handle the armed property.
+      if (model.isArmed())
+        {
+          if (! armed)
+            {
+              armed = true;
+              firePropertyChange(AccessibleContext.ACCESSIBLE_STATE_PROPERTY,
+                                 AccessibleState.ARMED, null);
+            }
+        }
+      else
+        {
+          if (armed)
+            {
+              armed = false;
+              firePropertyChange(AccessibleContext.ACCESSIBLE_STATE_PROPERTY,
+                                 null, AccessibleState.ARMED);
+            }
+        }
+
+      // Handle the pressed property.
+      if (model.isPressed())
+        {
+          if (! pressed)
+            {
+              pressed = true;
+              firePropertyChange(AccessibleContext.ACCESSIBLE_STATE_PROPERTY,
+                                 AccessibleState.PRESSED, null);
+            }
+        }
+      else
+        {
+          if (pressed)
+            {
+              pressed = false;
+              firePropertyChange(AccessibleContext.ACCESSIBLE_STATE_PROPERTY,
+                                 null, AccessibleState.PRESSED);
+            }
+        }
+
+      // Handle the selected property.
+      if (model.isSelected())
+        {
+          if (! selected)
+            {
+              selected = true;
+              firePropertyChange(AccessibleContext.ACCESSIBLE_STATE_PROPERTY,
+                                 AccessibleState.SELECTED, null);
+            }
+        }
+      else
+        {
+          if (selected)
+            {
+              selected = false;
+              firePropertyChange(AccessibleContext.ACCESSIBLE_STATE_PROPERTY,
+                                 null, AccessibleState.SELECTED);
+            }
+        }
+
+      // Handle the focusOwner property.
+      if (isFocusOwner())
+        {
+          if (! focusOwner)
+            {
+              focusOwner = true;
+              firePropertyChange(AccessibleContext.ACCESSIBLE_STATE_PROPERTY,
+                                 AccessibleState.FOCUSED, null);
+            }
+        }
+      else
+        {
+          if (focusOwner)
+            {
+              focusOwner = false;
+              firePropertyChange(AccessibleContext.ACCESSIBLE_STATE_PROPERTY,
+                                 null, AccessibleState.FOCUSED);
+            }
+        }
+    }
+
+    /**
+     * Returns the accessible role for the <code>JMenuItem</code> component.
+     *
+     * @return {@link AccessibleRole#MENU_ITEM}.
+     */
+    public AccessibleRole getAccessibleRole()
+    {
+      return AccessibleRole.MENU_ITEM;
+    }
+  }
+}

Added: llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JOptionPane.java
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JOptionPane.java?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JOptionPane.java (added)
+++ llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JOptionPane.java Thu Nov  8 16:56:19 2007
@@ -0,0 +1,1637 @@
+/* JOptionPane.java
+   Copyright (C) 2004, 2005, 2006, 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;
+
+import java.awt.AWTEvent;
+import java.awt.ActiveEvent;
+import java.awt.Component;
+import java.awt.Container;
+import java.awt.EventQueue;
+import java.awt.Frame;
+import java.awt.MenuComponent;
+import java.awt.Toolkit;
+import java.awt.event.MouseAdapter;
+import java.awt.event.MouseMotionAdapter;
+import java.beans.PropertyChangeEvent;
+import java.beans.PropertyChangeListener;
+
+import javax.accessibility.Accessible;
+import javax.accessibility.AccessibleContext;
+import javax.accessibility.AccessibleRole;
+import javax.swing.plaf.OptionPaneUI;
+
+/**
+ * This class creates different types of JDialogs and JInternalFrames that can
+ * ask users for input or pass on information. JOptionPane can be used by
+ * calling one of the show static methods or  by creating an instance of
+ * JOptionPane and calling createDialog or createInternalFrame.
+ */
+public class JOptionPane extends JComponent implements Accessible
+{
+  /**
+   * Provides the accessibility features for the <code>JOptionPane</code>
+   * component.
+   */
+  protected class AccessibleJOptionPane extends JComponent.AccessibleJComponent
+  {
+    private static final long serialVersionUID = 686071432213084821L;
+    
+    /**
+     * Creates a new <code>AccessibleJOptionPane</code> instance.
+     */
+    protected AccessibleJOptionPane()
+    {
+      // Nothing to do here.
+    }
+
+    /**
+     * Returns the accessible role of this object, which is always
+     * {@link AccessibleRole#OPTION_PANE}.
+     *
+     * @return the accessible role of this object
+     */
+    public AccessibleRole getAccessibleRole()
+    {
+      return AccessibleRole.OPTION_PANE;
+    }
+  }
+
+  private static final long serialVersionUID = 5231143276678566796L;
+
+  /** The value returned when cancel option is selected. */
+  public static final int CANCEL_OPTION = 2;
+
+  /** The value returned when the dialog is closed without a selection. */
+  public static final int CLOSED_OPTION = -1;
+
+  /** An option used in confirmation dialog methods. */
+  public static final int DEFAULT_OPTION = -1;
+
+  /** The value returned when the no option is selected. */
+  public static final int NO_OPTION = 1;
+
+  /** An option used in confirmation dialog methods. */
+  public static final int OK_CANCEL_OPTION = 2;
+
+  /** The value returned when the ok option is selected. */
+  public static final int OK_OPTION = 0;
+
+  /** An option used in confirmation dialog methods. */
+  public static final int YES_NO_CANCEL_OPTION = 1;
+
+  /** An option used in confirmation dialog methods. */
+  public static final int YES_NO_OPTION = 0;
+
+  /** The value returned when the yes option is selected. */
+  public static final int YES_OPTION = 0;
+
+  /** Identifier for the error message type. */
+  public static final int ERROR_MESSAGE = 0;
+
+  /** Identifier for the information message type. */
+  public static final int INFORMATION_MESSAGE = 1;
+
+  /** Identifier for the plain message type. */
+  public static final int PLAIN_MESSAGE = -1;
+
+  /** Identifier for the question message type. */
+  public static final int QUESTION_MESSAGE = 3;
+
+  /** Identifier for the warning message type. */
+  public static final int WARNING_MESSAGE = 2;
+
+  /**
+   * The identifier for the propertyChangeEvent when the icon property
+   * changes.
+   */
+  public static final String ICON_PROPERTY = "icon";
+
+  /**
+   * The identifier for the propertyChangeEvent when the initialSelectionValue
+   * property changes.
+   */
+  public static final String INITIAL_SELECTION_VALUE_PROPERTY = "initialSelectionValue";
+
+  /**
+   * The identifier for the propertyChangeEvent when the initialValue property
+   * changes.
+   */
+  public static final String INITIAL_VALUE_PROPERTY = "initialValue";
+
+  /**
+   * The identifier for the propertyChangeEvent when the inputValue property
+   * changes.
+   */
+  public static final String INPUT_VALUE_PROPERTY = "inputValue";
+
+  /**
+   * The identifier for the propertyChangeEvent when the message property
+   * changes.
+   */
+  public static final String MESSAGE_PROPERTY = "message";
+
+  /**
+   * The identifier for the propertyChangeEvent when the messageType property
+   * changes.
+   */
+  public static final String MESSAGE_TYPE_PROPERTY = "messageType";
+
+  /**
+   * The identifier for the propertyChangeEvent when the optionType property
+   * changes.
+   */
+  public static final String OPTION_TYPE_PROPERTY = "optionType";
+
+  /**
+   * The identifier for the propertyChangeEvent when the options property
+   * changes.
+   */
+  public static final String OPTIONS_PROPERTY = "options";
+
+  /**
+   * The identifier for the propertyChangeEvent when the selectionValues
+   * property changes.
+   */
+  public static final String SELECTION_VALUES_PROPERTY = "selectionValues";
+
+  /**
+   * The identifier for the propertyChangeEvent when the value property
+   * changes.
+   */
+  public static final String VALUE_PROPERTY = "value";
+
+  /**
+   * The identifier for the propertyChangeEvent when the wantsInput property
+   * changes.
+   */
+  public static final String WANTS_INPUT_PROPERTY = "wantsInput";
+
+  /** The value returned when the inputValue is uninitialized. */
+  public static final Object UNINITIALIZED_VALUE = "uninitializedValue";
+
+  /** The icon displayed in the dialog/internal frame. */
+  protected Icon icon;
+
+  /** The initial selected value in the input component. */
+  protected Object initialSelectionValue;
+
+  /** The object that is initially selected for options. */
+  protected Object initialValue;
+
+  /** The value the user inputs. */
+  protected Object inputValue = UNINITIALIZED_VALUE;
+
+  /** The message displayed in the dialog/internal frame. */
+  protected Object message;
+
+  /** The type of message displayed. */
+  protected int messageType = PLAIN_MESSAGE;
+
+  /**
+   * The options (usually buttons) aligned at the bottom for the user to
+   * select.
+   */
+  protected Object[] options;
+
+  /** The type of options to display. */
+  protected int optionType = DEFAULT_OPTION;
+
+  /** The input values the user can select. */
+  protected Object[] selectionValues;
+
+  /** The value returned by selecting an option. */
+  protected Object value = UNINITIALIZED_VALUE;
+
+  /** Whether the Dialog/InternalFrame needs input. */
+  protected boolean wantsInput;
+
+  /** The common frame used when no parent is provided. */
+  private static Frame privFrame = (Frame) SwingUtilities.getOwnerFrame(null);
+
+  /**
+   * Creates a new JOptionPane object using a message of "JOptionPane
+   * message", using the PLAIN_MESSAGE type and DEFAULT_OPTION.
+   */
+  public JOptionPane()
+  {
+    this("JOptionPane message", PLAIN_MESSAGE, DEFAULT_OPTION, null, null, null);
+  }
+
+  /**
+   * Creates a new JOptionPane object using the given message using the
+   * PLAIN_MESSAGE type and DEFAULT_OPTION.
+   *
+   * @param message The message to display.
+   */
+  public JOptionPane(Object message)
+  {
+    this(message, PLAIN_MESSAGE, DEFAULT_OPTION, null, null, null);
+  }
+
+  /**
+   * Creates a new JOptionPane object using the given message and messageType
+   * and DEFAULT_OPTION.
+   *
+   * @param message The message to display.
+   * @param messageType The type of message.
+   */
+  public JOptionPane(Object message, int messageType)
+  {
+    this(message, messageType, DEFAULT_OPTION, null, null, null);
+  }
+
+  /**
+   * Creates a new JOptionPane object using the given message, messageType and
+   * optionType.
+   *
+   * @param message The message to display.
+   * @param messageType The type of message.
+   * @param optionType The type of options.
+   */
+  public JOptionPane(Object message, int messageType, int optionType)
+  {
+    this(message, messageType, optionType, null, null, null);
+  }
+
+  /**
+   * Creates a new JOptionPane object using the given message, messageType,
+   * optionType and icon.
+   *
+   * @param message The message to display.
+   * @param messageType The type of message.
+   * @param optionType The type of options.
+   * @param icon The icon to display.
+   */
+  public JOptionPane(Object message, int messageType, int optionType, Icon icon)
+  {
+    this(message, messageType, optionType, icon, null, null);
+  }
+
+  /**
+   * Creates a new JOptionPane object using the given message, messageType,
+   * optionType, icon and options.
+   *
+   * @param message The message to display.
+   * @param messageType The type of message.
+   * @param optionType The type of options.
+   * @param icon The icon to display.
+   * @param options The options given.
+   */
+  public JOptionPane(Object message, int messageType, int optionType,
+                     Icon icon, Object[] options)
+  {
+    this(message, messageType, optionType, icon, options, null);
+  }
+
+  /**
+   * Creates a new JOptionPane object using the given message, messageType,
+   * optionType, icon, options and initialValue. The initialValue will be
+   * focused initially.
+   *
+   * @param message The message to display.
+   * @param messageType The type of message.
+   * @param optionType The type of options.
+   * @param icon The icon to display.
+   * @param options The options given.
+   * @param initialValue The component to focus on initially.
+   *
+   * @throws IllegalArgumentException If the messageType or optionType are not
+   *         legal values.
+   */
+  public JOptionPane(Object message, int messageType, int optionType,
+                     Icon icon, Object[] options, Object initialValue)
+  {
+    this.message = message;
+    if (! validMessageType(messageType))
+      throw new IllegalArgumentException("Message Type not legal value.");
+    this.messageType = messageType;
+    if (! validOptionType(optionType))
+      throw new IllegalArgumentException("Option Type not legal value.");
+    this.optionType = optionType;
+    this.icon = icon;
+    this.options = options;
+    this.initialValue = initialValue;
+
+    setLayout(new BoxLayout(this, BoxLayout.Y_AXIS));
+
+    updateUI();
+  }
+
+  /**
+   * This method creates a new JDialog that is either centered around the
+   * parent's frame or centered on the screen (if the parent is null). The
+   * JDialog will not be resizable and will be modal. Once the JDialog is
+   * disposed, the inputValue and value properties will  be set by the
+   * optionPane.
+   *
+   * @param parentComponent The parent of the Dialog.
+   * @param title The title in the bar of the JDialog.
+   *
+   * @return A new JDialog based on the JOptionPane configuration.
+   */
+  public JDialog createDialog(Component parentComponent, String title)
+  {
+    Frame toUse = getFrameForComponent(parentComponent);
+    if (toUse == null)
+      toUse = getRootFrame();
+
+    JDialog dialog = new JDialog(toUse, title);
+    inputValue = UNINITIALIZED_VALUE;
+    value = UNINITIALIZED_VALUE;
+
+    dialog.getContentPane().add(this);
+    dialog.setModal(true);
+    dialog.setResizable(false);
+    dialog.pack();
+    dialog.setLocationRelativeTo(parentComponent);
+
+    addPropertyChangeListener(new ValuePropertyHandler(dialog));
+    return dialog;
+  }
+
+  /**
+   * Handles changes of the value property. Whenever this property changes,
+   * the JOptionPane dialog should be closed.
+   */
+  private static class ValuePropertyHandler
+    implements PropertyChangeListener
+  {
+    /**
+     * The dialog to close.
+     */
+    JDialog dialog;
+
+    /**
+     * Creates a new instance.
+     *
+     * @param d the dialog to be closed
+     */
+    ValuePropertyHandler(JDialog d)
+    {
+      dialog = d;
+    }
+
+    /**
+     * Receives notification when any of the properties change.
+     */
+    public void propertyChange(PropertyChangeEvent p)
+    {
+      String prop = p.getPropertyName();
+      Object val = p.getNewValue();
+      if (prop.equals(VALUE_PROPERTY) && val != null
+          && val != UNINITIALIZED_VALUE)
+        {
+          dialog.setVisible(false);
+        }
+    }
+  }
+
+  /**
+   * This method creates a new JInternalFrame that is in the JLayeredPane
+   * which contains the parentComponent given. If no suitable JLayeredPane
+   * can be found from the parentComponent given, a RuntimeException will be
+   * thrown.
+   *
+   * @param parentComponent The parent to find a JDesktopPane from.
+   * @param title The title of the JInternalFrame.
+   *
+   * @return A new JInternalFrame based on the JOptionPane configuration.
+   *
+   * @throws RuntimeException If no suitable JDesktopPane is found.
+   *
+   * @specnote The specification says that the internal frame is placed
+   *           in the nearest <code>JDesktopPane</code> that is found in
+   *           <code>parent</code>'s ancestors. The behaviour of the JDK
+   *           is that it actually looks up the nearest
+   *           <code>JLayeredPane</code> in <code>parent</code>'s ancestors.
+   *           So do we.
+   */
+  public JInternalFrame createInternalFrame(Component parentComponent,
+                                            String title)
+                                     throws RuntimeException
+  {
+    // Try to find a JDesktopPane.
+    JLayeredPane toUse = getDesktopPaneForComponent(parentComponent);
+    // If we don't have a JDesktopPane, we try to find a JLayeredPane.
+    if (toUse == null)
+      toUse = JLayeredPane.getLayeredPaneAbove(parentComponent);
+    // If this still fails, we throw a RuntimeException.
+    if (toUse == null)
+      throw new RuntimeException
+        ("parentComponent does not have a valid parent");
+
+    JInternalFrame frame = new JInternalFrame(title);
+
+    inputValue = UNINITIALIZED_VALUE;
+    value = UNINITIALIZED_VALUE;
+
+    frame.setContentPane(this);
+    frame.setClosable(true);
+
+    toUse.add(frame);
+    frame.setLayer(JLayeredPane.MODAL_LAYER);
+
+    frame.pack();
+    frame.setVisible(true);
+
+    return frame;
+  }
+
+  /**
+   * Returns the object that provides accessibility features for this
+   * <code>JOptionPane</code> component.
+   *
+   * @return The accessible context (an instance of 
+   *     {@link AccessibleJOptionPane}).
+   */
+  public AccessibleContext getAccessibleContext()
+  {
+    if (accessibleContext == null)
+      accessibleContext = new AccessibleJOptionPane();
+    return accessibleContext;
+  }
+
+  /**
+   * This method returns the JDesktopPane for the given parentComponent or
+   * null if none can be found.
+   *
+   * @param parentComponent The component to look in.
+   *
+   * @return The JDesktopPane for the given component or null if none can be
+   *         found.
+   */
+  public static JDesktopPane getDesktopPaneForComponent(Component parentComponent)
+  {
+    return (JDesktopPane) SwingUtilities.getAncestorOfClass(JDesktopPane.class,
+                                                            parentComponent);
+  }
+
+  /**
+   * This method returns the Frame for the given parentComponent or null if
+   * none can be found.
+   *
+   * @param parentComponent The component to look in.
+   *
+   * @return The Frame for the given component or null if none can be found.
+   */
+  public static Frame getFrameForComponent(Component parentComponent)
+  {
+    return (Frame) SwingUtilities.getAncestorOfClass(Frame.class,
+                                                     parentComponent);
+  }
+
+  /**
+   * This method returns the icon displayed.
+   *
+   * @return The icon displayed.
+   */
+  public Icon getIcon()
+  {
+    return icon;
+  }
+
+  /**
+   * This method returns the value initially selected from the list of values
+   * the user can input.
+   *
+   * @return The initial selection value.
+   */
+  public Object getInitialSelectionValue()
+  {
+    return initialSelectionValue;
+  }
+
+  /**
+   * This method returns the value that is focused from the list of options.
+   *
+   * @return The initial value from options.
+   */
+  public Object getInitialValue()
+  {
+    return initialValue;
+  }
+
+  /**
+   * This method returns the value that the user input.
+   *
+   * @return The user's input value.
+   */
+  public Object getInputValue()
+  {
+    if (getValue().equals(new Integer(CANCEL_OPTION)))
+      setInputValue(null);
+    return inputValue;
+  }
+
+  /**
+   * This method returns the maximum characters per line. By default, this is
+   * Integer.MAX_VALUE.
+   *
+   * @return The maximum characters per line.
+   */
+  public int getMaxCharactersPerLineCount()
+  {
+    return Integer.MAX_VALUE;
+  }
+
+  /**
+   * This method returns the message displayed.
+   *
+   * @return The message displayed.
+   */
+  public Object getMessage()
+  {
+    return message;
+  }
+
+  /**
+   * This method returns the message type.
+   *
+   * @return The message type.
+   */
+  public int getMessageType()
+  {
+    return messageType;
+  }
+
+  /**
+   * This method returns the options.
+   *
+   * @return The options.
+   */
+  public Object[] getOptions()
+  {
+    return options;
+  }
+
+  /**
+   * This method returns the option type.
+   *
+   * @return The option type.
+   */
+  public int getOptionType()
+  {
+    return optionType;
+  }
+
+  /**
+   * This method returns the Frame used by JOptionPane dialog's that have no
+   * parent.
+   *
+   * @return The Frame used by dialogs that have no parent.
+   */
+  public static Frame getRootFrame()
+  {
+    return privFrame;
+  }
+
+  /**
+   * This method returns the selection values.
+   *
+   * @return The selection values.
+   */
+  public Object[] getSelectionValues()
+  {
+    return selectionValues;
+  }
+
+  /**
+   * This method returns the UI used by the JOptionPane.
+   *
+   * @return The UI used by the JOptionPane.
+   */
+  public OptionPaneUI getUI()
+  {
+    return (OptionPaneUI) ui;
+  }
+
+  /**
+   * This method returns an identifier to determine which UI class will act as
+   * the UI.
+   *
+   * @return The UI identifier.
+   */
+  public String getUIClassID()
+  {
+    return "OptionPaneUI";
+  }
+
+  /**
+   * This method returns the value that the user selected out of options.
+   *
+   * @return The value that the user selected out of options.
+   */
+  public Object getValue()
+  {
+    return value;
+  }
+
+  /**
+   * This method returns whether this JOptionPane wants input.
+   *
+   * @return Whether this JOptionPane wants input.
+   */
+  public boolean getWantsInput()
+  {
+    return wantsInput;
+  }
+
+  /**
+   * This method returns a String that describes this JOptionPane.
+   *
+   * @return A String that describes this JOptionPane.
+   */
+  protected String paramString()
+  {
+    return "JOptionPane";
+  }
+
+  /**
+   * This method requests focus for the initial value.
+   */
+  public void selectInitialValue()
+  {
+    if (ui != null)
+      ((OptionPaneUI) ui).selectInitialValue(this);
+  }
+
+  /**
+   * This method changes the icon property.
+   *
+   * @param newIcon The new icon to use.
+   */
+  public void setIcon(Icon newIcon)
+  {
+    if (icon != newIcon)
+      {
+	Icon old = icon;
+	icon = newIcon;
+	firePropertyChange(ICON_PROPERTY, old, icon);
+      }
+  }
+
+  /**
+   * This method changes the initial selection property.
+   *
+   * @param newValue The new initial selection.
+   */
+  public void setInitialSelectionValue(Object newValue)
+  {
+    if (initialSelectionValue != newValue)
+      {
+	Object old = initialSelectionValue;
+	initialSelectionValue = newValue;
+	firePropertyChange(INITIAL_SELECTION_VALUE_PROPERTY, old,
+	                   initialSelectionValue);
+      }
+  }
+
+  /**
+   * This method changes the initial value property.
+   *
+   * @param newValue The new initial value.
+   */
+  public void setInitialValue(Object newValue)
+  {
+    if (initialValue != newValue)
+      {
+	Object old = initialValue;
+	initialValue = newValue;
+	firePropertyChange(INITIAL_VALUE_PROPERTY, old, initialValue);
+      }
+  }
+
+  /**
+   * This method changes the inputValue property.
+   *
+   * @param newValue The new inputValue.
+   */
+  public void setInputValue(Object newValue)
+  {
+    if (inputValue != newValue)
+      {
+	Object old = inputValue;
+	inputValue = newValue;
+	firePropertyChange(INPUT_VALUE_PROPERTY, old, inputValue);
+      }
+  }
+
+  /**
+   * This method changes the message property.
+   *
+   * @param newMessage The new message.
+   */
+  public void setMessage(Object newMessage)
+  {
+    if (message != newMessage)
+      {
+	Object old = message;
+	message = newMessage;
+	firePropertyChange(MESSAGE_PROPERTY, old, message);
+      }
+  }
+
+  /**
+   * This method changes the messageType property.
+   *
+   * @param newType The new messageType.
+   *
+   * @throws IllegalArgumentException If the messageType is not valid.
+   */
+  public void setMessageType(int newType)
+  {
+    if (! validMessageType(newType))
+      throw new IllegalArgumentException("Message Type not legal value.");
+    if (newType != messageType)
+      {
+	int old = messageType;
+	messageType = newType;
+	firePropertyChange(MESSAGE_TYPE_PROPERTY, old, messageType);
+      }
+  }
+
+  /**
+   * This method changes the options property.
+   *
+   * @param newOptions The new options.
+   */
+  public void setOptions(Object[] newOptions)
+  {
+    if (options != newOptions)
+      {
+	Object[] old = options;
+	options = newOptions;
+	firePropertyChange(OPTIONS_PROPERTY, old, options);
+      }
+  }
+
+  /**
+   * This method changes the optionType property.
+   *
+   * @param newType The new optionType.
+   *
+   * @throws IllegalArgumentException If the optionType is not valid.
+   */
+  public void setOptionType(int newType)
+  {
+    if (! validOptionType(newType))
+      throw new IllegalArgumentException("Option Type not legal value.");
+    if (newType != optionType)
+      {
+	int old = optionType;
+	optionType = newType;
+	firePropertyChange(OPTION_TYPE_PROPERTY, old, optionType);
+      }
+  }
+
+  /**
+   * This method changes the Frame used for JOptionPane dialogs that have no
+   * parent.
+   *
+   * @param newRootFrame The Frame to use for dialogs that have no parent.
+   */
+  public static void setRootFrame(Frame newRootFrame)
+  {
+    privFrame = newRootFrame;
+  }
+
+  /**
+   * This method changes the selectionValues property.
+   *
+   * @param newValues The new selectionValues.
+   */
+  public void setSelectionValues(Object[] newValues)
+  {
+    if (newValues != selectionValues)
+      {
+	if (newValues != null)
+	  wantsInput = true;
+	Object[] old = selectionValues;
+	selectionValues = newValues;
+	firePropertyChange(SELECTION_VALUES_PROPERTY, old, selectionValues);
+      }
+  }
+
+  /**
+   * This method sets the UI used with the JOptionPane.
+   *
+   * @param ui The UI used with the JOptionPane.
+   */
+  public void setUI(OptionPaneUI ui)
+  {
+    super.setUI(ui);
+  }
+
+  /**
+   * This method sets the value has been selected out of options.
+   *
+   * @param newValue The value that has been selected out of options.
+   */
+  public void setValue(Object newValue)
+  {
+    if (value != newValue)
+      {
+	Object old = value;
+	value = newValue;
+	firePropertyChange(VALUE_PROPERTY, old, value);
+      }
+  }
+
+  /**
+   * This method changes the wantsInput property.
+   *
+   * @param newValue Whether this JOptionPane requires input.
+   */
+  public void setWantsInput(boolean newValue)
+  {
+    if (wantsInput != newValue)
+      {
+	boolean old = wantsInput;
+	wantsInput = newValue;
+	firePropertyChange(WANTS_INPUT_PROPERTY, old, wantsInput);
+      }
+  }
+
+  /**
+   * This method shows a confirmation dialog with the title "Select an Option"
+   * and displays the given message. The parent frame will be the same as the
+   * parent frame of the given parentComponent. This method returns the
+   * option chosen by the user.
+   *
+   * @param parentComponent The parentComponent to find a frame in.
+   * @param message The message to display.
+   *
+   * @return The option that was selected.
+   */
+  public static int showConfirmDialog(Component parentComponent, Object message)
+  {
+    JOptionPane pane = new JOptionPane(message, QUESTION_MESSAGE);
+    JDialog dialog = pane.createDialog(parentComponent, "Select an Option");
+    dialog.show();
+    
+    if (pane.getValue() instanceof Integer)
+      return ((Integer) pane.getValue()).intValue();
+    return -1;
+  }
+
+  /**
+   * This method shows a confirmation dialog with the given message,
+   * optionType and title. The frame that owns the dialog will be the same
+   * frame that holds the given parentComponent. This method returns the
+   * option that was chosen.
+   *
+   * @param parentComponent The component to find a frame in.
+   * @param message The message displayed.
+   * @param title The title of the dialog.
+   * @param optionType The optionType.
+   *
+   * @return The option that was chosen.
+   */
+  public static int showConfirmDialog(Component parentComponent,
+                                      Object message, String title,
+                                      int optionType)
+  {
+    JOptionPane pane = new JOptionPane(message, PLAIN_MESSAGE, optionType);
+    JDialog dialog = pane.createDialog(parentComponent, title);
+    dialog.show();
+
+    if (pane.getValue() instanceof Integer)
+      return ((Integer) pane.getValue()).intValue();
+    return -1;
+  }
+
+  /**
+   * This method shows a confirmation dialog with the given message, title,
+   * messageType and optionType. The frame owner will be the same frame as
+   * the one that holds the given parentComponent. This method returns the
+   * option selected by the user.
+   *
+   * @param parentComponent The component to find a frame in.
+   * @param message The message displayed.
+   * @param title The title of the dialog.
+   * @param optionType The optionType.
+   * @param messageType The messageType.
+   *
+   * @return The selected option.
+   */
+  public static int showConfirmDialog(Component parentComponent,
+                                      Object message, String title,
+                                      int optionType, int messageType)
+  {
+    JOptionPane pane = new JOptionPane(message, messageType, optionType);
+    JDialog dialog = pane.createDialog(parentComponent, title);
+    dialog.show();
+
+    if (pane.getValue() instanceof Integer)
+      return ((Integer) pane.getValue()).intValue();
+    return -1;
+  }
+
+  /**
+   * This method shows a confirmation dialog with the given message, title,
+   * optionType, messageType and icon. The frame owner will be the same as
+   * the one that holds the given parentComponent. This method returns the
+   * option selected by the user.
+   *
+   * @param parentComponent The component to find a frame in.
+   * @param message The message displayed.
+   * @param title The title of the dialog.
+   * @param optionType The optionType.
+   * @param messageType The messsageType.
+   * @param icon The icon displayed.
+   *
+   * @return The selected option.
+   */
+  public static int showConfirmDialog(Component parentComponent,
+                                      Object message, String title,
+                                      int optionType, int messageType,
+                                      Icon icon)
+  {
+    JOptionPane pane = new JOptionPane(message, messageType, optionType, icon);
+    JDialog dialog = pane.createDialog(parentComponent, title);
+    dialog.show();
+
+    if (pane.getValue() instanceof Integer)
+      return ((Integer) pane.getValue()).intValue();
+    return -1;
+  }
+
+  /**
+   * This method will show a QUESTION_MESSAGE input dialog with the given
+   * message. No selectionValues is set so the Look and Feel will usually
+   * give the user a TextField to fill out. The frame owner will be the same
+   * frame that holds the given parentComponent. This method will return the
+   * value entered by the user.
+   *
+   * @param parentComponent The component to find a frame in.
+   * @param message The message displayed.
+   *
+   * @return The value entered by the user.
+   */
+  public static String showInputDialog(Component parentComponent,
+                                       Object message)
+  {
+    JOptionPane pane = new JOptionPane(message, QUESTION_MESSAGE);
+    pane.setWantsInput(true);
+    JDialog dialog = pane.createDialog(parentComponent, null);
+    dialog.show();
+    
+    return (String) pane.getInputValue();
+  }
+
+  /**
+   * This method will show a QUESTION_MESSAGE type input dialog with the given
+   * message and initialSelectionValue. Since there is no selectionValues
+   * set, the Look and Feel will usually give a TextField to fill out. The
+   * frame owner will be the same as the one that holds the given
+   * parentComponent. This method will return the value entered by the user.
+   *
+   * @param parentComponent The component to find a frame in.
+   * @param message The message to display.
+   * @param initialSelectionValue The initially selected value.
+   *
+   * @return The value the user input.
+   */
+  public static String showInputDialog(Component parentComponent,
+                                       Object message,
+                                       Object initialSelectionValue)
+  {
+    JOptionPane pane = new JOptionPane(message, QUESTION_MESSAGE);
+    pane.setInitialSelectionValue(initialSelectionValue);
+    pane.setWantsInput(true);
+    JDialog dialog = pane.createDialog(parentComponent, null);
+    dialog.show();
+    
+    return (String) pane.getInputValue();
+  }
+
+  /**
+   * This method displays a new input dialog with the given message, title and
+   * messageType. Since no selectionValues value is given, the Look and Feel
+   * will usually give the user a TextField to input data to. This method
+   * returns the value the user inputs.
+   *
+   * @param parentComponent The component to find a frame in.
+   * @param message The message to display.
+   * @param title The title of the dialog.
+   * @param messageType The messageType.
+   *
+   * @return The value the user input.
+   */
+  public static String showInputDialog(Component parentComponent,
+                                       Object message, String title,
+                                       int messageType)
+  {
+    JOptionPane pane = new JOptionPane(message, messageType);
+    pane.setWantsInput(true);
+    JDialog dialog = pane.createDialog(parentComponent, title);
+    dialog.show();
+    
+    return (String) pane.getInputValue();
+  }
+
+  /**
+   * This method shows an input dialog with the given message, title,
+   * messageType, icon, selectionValues, and initialSelectionValue. This
+   * method returns the value that the user selects.
+   *
+   * @param parentComponent The component to find a frame in.
+   * @param message The message displayed.
+   * @param title The title of the dialog.
+   * @param messageType The messageType.
+   * @param icon The icon displayed.
+   * @param selectionValues The list of values to select from.
+   * @param initialSelectionValue The initially selected value.
+   *
+   * @return The user selected value.
+   */
+  public static Object showInputDialog(Component parentComponent,
+                                       Object message, String title,
+                                       int messageType, Icon icon,
+                                       Object[] selectionValues,
+                                       Object initialSelectionValue)
+  {
+    JOptionPane pane = new JOptionPane(message, messageType);
+    pane.setWantsInput(true);
+    pane.setIcon(icon);
+    pane.setSelectionValues(selectionValues);
+    pane.setInitialSelectionValue(initialSelectionValue);
+    JDialog dialog = pane.createDialog(parentComponent, title);
+    dialog.show();
+    
+    return pane.getInputValue();
+  }
+
+  /**
+   * This method shows a QUESTION_MESSAGE type input dialog. Since no
+   * selectionValues is set, the Look and Feel will usually give the user a
+   * TextField to input data to. This method returns the value the user
+   * inputs.
+   *
+   * @param message The message to display.
+   *
+   * @return The user selected value.
+   */
+  public static String showInputDialog(Object message)
+  {
+    JOptionPane pane = new JOptionPane(message, QUESTION_MESSAGE);
+    pane.setWantsInput(true);
+    JDialog dialog = pane.createDialog(null, null);
+    dialog.show();
+    
+    return (String) pane.getInputValue();
+  }
+
+  /**
+   * This method shows a QUESTION_MESSAGE type input dialog. Since no
+   * selectionValues is set, the Look and Feel will usually give the user a
+   * TextField to input data to. The input component will be initialized with
+   * the initialSelectionValue. This method returns the value the user
+   * inputs.
+   *
+   * @param message The message to display.
+   * @param initialSelectionValue The initialSelectionValue.
+   *
+   * @return The user selected value.
+   */
+  public static String showInputDialog(Object message,
+                                       Object initialSelectionValue)
+  {
+    JOptionPane pane = new JOptionPane(message, QUESTION_MESSAGE);
+    pane.setWantsInput(true);
+    pane.setInitialSelectionValue(initialSelectionValue);
+    JDialog dialog = pane.createDialog(null, null);
+    dialog.show();
+    
+    return (String) pane.getInputValue();
+  }
+
+  /**
+   * This method shows an internal confirmation dialog with the given message.
+   * The internal frame dialog will be placed in the first JDesktopPane
+   * ancestor of the given parentComponent. This method will return the value
+   * selected.
+   *
+   * @param parentComponent The parent to find a JDesktopPane in.
+   * @param message The message to display.
+   *
+   * @return The value selected.
+   */
+  public static int showInternalConfirmDialog(Component parentComponent,
+                                              Object message)
+  {
+    JOptionPane pane = new JOptionPane(message);
+    JInternalFrame frame = pane.createInternalFrame(parentComponent, null);
+
+    startModal(frame);
+    
+    if (pane.getValue() instanceof Integer)
+      return ((Integer) pane.getValue()).intValue();
+    return -1;
+  }
+
+  /**
+   * This method shows an internal confirmation dialog with the given message,
+   * optionType and title. The internal frame dialog will be placed in the
+   * first JDesktopPane ancestor of the given parentComponent.  This method
+   * will return the selected value.
+   *
+   * @param parentComponent The parent to find a JDesktopPane in.
+   * @param message The message to display.
+   * @param title The title to display.
+   * @param optionType The option type.
+   *
+   * @return The selected value.
+   */
+  public static int showInternalConfirmDialog(Component parentComponent,
+                                              Object message, String title,
+                                              int optionType)
+  {
+    JOptionPane pane = new JOptionPane(message, PLAIN_MESSAGE, optionType);
+    JInternalFrame frame = pane.createInternalFrame(parentComponent, title);
+
+    startModal(frame);
+
+    if (pane.getValue() instanceof Integer)
+      return ((Integer) pane.getValue()).intValue();
+    return -1;
+  }
+
+  /**
+   * This method shows an internal confirmation dialog with the given message,
+   * title, optionTypes and icon for the given message type. The internal
+   * confirmation dialog will be placed in the first  instance of
+   * JDesktopPane ancestor of the given parentComponent.
+   *
+   * @param parentComponent The component to find a JDesktopPane in.
+   * @param message The message to display.
+   * @param title The title of the dialog.
+   * @param optionType The option type.
+   * @param messageType The message type.
+   *
+   * @return The selected value.
+   */
+  public static int showInternalConfirmDialog(Component parentComponent,
+                                              Object message, String title,
+                                              int optionType, int messageType)
+  {
+    JOptionPane pane = new JOptionPane(message, messageType, optionType);
+    JInternalFrame frame = pane.createInternalFrame(parentComponent, title);
+
+    startModal(frame);
+
+    if (pane.getValue() instanceof Integer)
+      return ((Integer) pane.getValue()).intValue();
+    return -1;
+  }
+
+  /**
+   * This method shows an internal confirmation dialog with the given message,
+   * title, option type, message type, and icon. The internal frame dialog
+   * will be placed in the first JDesktopPane ancestor  that is found in the
+   * given parentComponent. This method returns  the selected value.
+   *
+   * @param parentComponent The parent to find a JDesktopPane in.
+   * @param message The message to display.
+   * @param title The title to display.
+   * @param optionType The option type.
+   * @param messageType The message type.
+   * @param icon The icon to display.
+   *
+   * @return The selected value.
+   */
+  public static int showInternalConfirmDialog(Component parentComponent,
+                                              Object message, String title,
+                                              int optionType, int messageType,
+                                              Icon icon)
+  {
+    JOptionPane pane = new JOptionPane(message, messageType, optionType, icon);
+    JInternalFrame frame = pane.createInternalFrame(parentComponent, title);
+
+    startModal(frame);
+
+    if (pane.getValue() instanceof Integer)
+      return ((Integer) pane.getValue()).intValue();
+    return -1;
+  }
+
+  /**
+   * This method shows an internal input dialog with the given message. The
+   * internal frame dialog will be placed in the first JDesktopPane ancestor
+   * of the given parent component. This method returns the value input by
+   * the user.
+   *
+   * @param parentComponent The parent to find a JDesktopPane in.
+   * @param message The message to display.
+   *
+   * @return The user selected value.
+   */
+  public static String showInternalInputDialog(Component parentComponent,
+                                               Object message)
+  {
+    JOptionPane pane = new JOptionPane(message);
+    pane.setWantsInput(true);
+    JInternalFrame frame = pane.createInternalFrame(parentComponent, null);
+
+    startModal(frame);
+    
+    return (String) pane.getInputValue();
+  }
+
+  /**
+   * This method shows an internal input dialog with the given message,  title
+   * and message type. The internal input dialog will be placed in the first
+   * JDesktopPane ancestor found in the given parent component. This method
+   * will return the input value given by the user.
+   *
+   * @param parentComponent The component to find a JDesktopPane in.
+   * @param message The message to display.
+   * @param title The title to display.
+   * @param messageType The message type.
+   *
+   * @return The user input value.
+   */
+  public static String showInternalInputDialog(Component parentComponent,
+                                               Object message, String title,
+                                               int messageType)
+  {
+    JOptionPane pane = new JOptionPane(message, messageType);
+    pane.setWantsInput(true);
+    JInternalFrame frame = pane.createInternalFrame(parentComponent, title);
+
+    startModal(frame);
+    
+    return (String) pane.getInputValue();
+  }
+
+  /**
+   * This method shows an internal input dialog with the given message, title
+   * message type, icon, selection value list and initial selection value.
+   * The internal frame dialog will be placed in the first JDesktopPane
+   * ancestor found in the given parent component. This method returns the
+   * input value from the user.
+   *
+   * @param parentComponent The parent to find a JDesktopPane in.
+   * @param message The message to display.
+   * @param title The title to display.
+   * @param messageType The message type.
+   * @param icon The icon to display.
+   * @param selectionValues The selection value list.
+   * @param initialSelectionValue The initial selection value.
+   *
+   * @return The user input value.
+   */
+  public static Object showInternalInputDialog(Component parentComponent,
+                                               Object message, String title,
+                                               int messageType, Icon icon,
+                                               Object[] selectionValues,
+                                               Object initialSelectionValue)
+  {
+    JOptionPane pane = new JOptionPane(message, messageType);
+    pane.setWantsInput(true);
+    pane.setIcon(icon);
+    pane.setSelectionValues(selectionValues);
+    pane.setInitialSelectionValue(initialSelectionValue);
+    JInternalFrame frame = pane.createInternalFrame(parentComponent, title);
+
+    startModal(frame);
+    
+    return pane.getInputValue();
+  }
+
+  /**
+   * This method shows an internal message dialog with the given message. The
+   * internal frame dialog will be placed in the first JDesktopPane ancestor
+   * found in the given parent component.
+   *
+   * @param parentComponent The component to find a JDesktopPane in.
+   * @param message The message to display.
+   */
+  public static void showInternalMessageDialog(Component parentComponent,
+                                               Object message)
+  {
+    JOptionPane pane = new JOptionPane(message);
+    JInternalFrame frame = pane.createInternalFrame(parentComponent, null);
+
+    startModal(frame);
+  }
+
+  /**
+   * This method shows an internal message dialog with the given message,
+   * title and message type. The internal message dialog is placed in the
+   * first JDesktopPane ancestor found in the given parent component.
+   *
+   * @param parentComponent The parent component to find a JDesktopPane in.
+   * @param message The message to display.
+   * @param title The title to display.
+   * @param messageType The message type.
+   */
+  public static void showInternalMessageDialog(Component parentComponent,
+                                               Object message, String title,
+                                               int messageType)
+  {
+    JOptionPane pane = new JOptionPane(message, messageType);
+    JInternalFrame frame = pane.createInternalFrame(parentComponent, title);
+
+    startModal(frame);
+  }
+
+  /**
+   * This method shows an internal message dialog with the given message,
+   * title, message type and icon. The internal message dialog is placed in
+   * the first JDesktopPane ancestor found in the given parent component.
+   *
+   * @param parentComponent The component to find a JDesktopPane in.
+   * @param message The message to display.
+   * @param title The title to display.
+   * @param messageType The message type.
+   * @param icon The icon to display.
+   */
+  public static void showInternalMessageDialog(Component parentComponent,
+                                               Object message, String title,
+                                               int messageType, Icon icon)
+  {
+    JOptionPane pane = new JOptionPane(message, messageType);
+    pane.setIcon(icon);
+    JInternalFrame frame = pane.createInternalFrame(parentComponent, title);
+
+    startModal(frame);
+  }
+
+  /**
+   * This method displays an internal option dialog with the given message,
+   * title, option type, message type, icon, option list, and initial option
+   * value. The internal option dialog is placed in the first JDesktopPane
+   * ancestor found in the parent component. This method returns the option
+   * selected.
+   *
+   * @param parentComponent The parent to find a JDesktopPane in.
+   * @param message The message displayed.
+   * @param title The title displayed.
+   * @param optionType The option type.
+   * @param messageType The message type.
+   * @param icon The icon to display.
+   * @param options The array of options.
+   * @param initialValue The initial value selected.
+   *
+   * @return The option that was selected.
+   */
+  public static int showInternalOptionDialog(Component parentComponent,
+                                             Object message, String title,
+                                             int optionType, int messageType,
+                                             Icon icon, Object[] options,
+                                             Object initialValue)
+  {
+    JOptionPane pane = new JOptionPane(message, messageType, optionType, icon,
+                                       options, initialValue);
+
+    JInternalFrame frame = pane.createInternalFrame(parentComponent, title);
+
+    startModal(frame);
+ 
+    if (pane.getValue() instanceof Integer)
+      return ((Integer) pane.getValue()).intValue();
+    return -1;
+  }
+
+  /**
+   * This method shows an INFORMATION_MESSAGE type message dialog.
+   *
+   * @param parentComponent The component to find a frame in.
+   * @param message The message displayed.
+   */
+  public static void showMessageDialog(Component parentComponent,
+                                       Object message)
+  {
+    JOptionPane pane = new JOptionPane(message, INFORMATION_MESSAGE);
+    JDialog dialog = pane.createDialog(parentComponent, null);
+    dialog.show();   
+  }
+
+  /**
+   * This method shows a message dialog with the given message, title and
+   * messageType.
+   *
+   * @param parentComponent The component to find a frame in.
+   * @param message The message displayed.
+   * @param title The title of the dialog.
+   * @param messageType The messageType.
+   */
+  public static void showMessageDialog(Component parentComponent,
+                                       Object message, String title,
+                                       int messageType)
+  {
+    JOptionPane pane = new JOptionPane(message, messageType);
+    JDialog dialog = pane.createDialog(parentComponent, title);
+    dialog.show();
+  }
+
+  /**
+   * This method shows a message dialog with the given message, title,
+   * messageType and icon.
+   *
+   * @param parentComponent The component to find a frame in.
+   * @param message The message displayed.
+   * @param title The title of the dialog.
+   * @param messageType The messageType.
+   * @param icon The icon displayed.
+   */
+  public static void showMessageDialog(Component parentComponent,
+                                       Object message, String title,
+                                       int messageType, Icon icon)
+  {
+    JOptionPane pane = new JOptionPane(message, messageType);
+    pane.setIcon(icon);
+    JDialog dialog = pane.createDialog(parentComponent, title);
+    dialog.show();
+  }
+
+  /**
+   * This method shows an option dialog with the given message, title,
+   * optionType, messageType, icon, options and initialValue. This method
+   * returns the option that was selected.
+   *
+   * @param parentComponent The component to find a frame in.
+   * @param message The message displayed.
+   * @param title The title of the dialog.
+   * @param optionType The optionType.
+   * @param messageType The messageType.
+   * @param icon The icon displayed.
+   * @param options The options to choose from.
+   * @param initialValue The initial value.
+   *
+   * @return The selected option.
+   */
+  public static int showOptionDialog(Component parentComponent,
+                                     Object message, String title,
+                                     int optionType, int messageType,
+                                     Icon icon, Object[] options,
+                                     Object initialValue)
+  {
+    JOptionPane pane = new JOptionPane(message, messageType, optionType, icon,
+                                       options, initialValue);
+
+    JDialog dialog = pane.createDialog(parentComponent, title);
+    dialog.show();
+
+    if (pane.getValue() instanceof Integer)
+      return ((Integer) pane.getValue()).intValue();
+    return -1;
+  }
+
+  /**
+   * This method resets the UI to the Look and Feel default.
+   */
+  public void updateUI()
+  {
+    setUI((OptionPaneUI) UIManager.getUI(this));
+  }
+
+  /**
+   * This method returns true if the key is a valid messageType.
+   *
+   * @param key The key to check.
+   *
+   * @return True if key is valid.
+   */
+  private boolean validMessageType(int key)
+  {
+    switch (key)
+      {
+      case ERROR_MESSAGE:
+      case INFORMATION_MESSAGE:
+      case PLAIN_MESSAGE:
+      case QUESTION_MESSAGE:
+      case WARNING_MESSAGE:
+	return true;
+      }
+    return false;
+  }
+
+  /**
+   * This method returns true if the key is a valid optionType.
+   *
+   * @param key The key to check.
+   *
+   * @return True if key is valid.
+   */
+  private boolean validOptionType(int key)
+  {
+    switch (key)
+      {
+      case DEFAULT_OPTION:
+      case OK_CANCEL_OPTION:
+      case YES_NO_CANCEL_OPTION:
+      case YES_NO_OPTION:
+	return true;
+      }
+    return false;
+  }
+
+  /**
+   * This helper method makes the JInternalFrame wait until it is notified by
+   * an InternalFrameClosing event. This method also adds the given
+   * JOptionPane to the JInternalFrame and sizes it according to the
+   * JInternalFrame's preferred size.
+   *
+   * @param f The JInternalFrame to make modal.
+   */
+  private static void startModal(JInternalFrame f)
+  {
+    // We need to add an additional glasspane-like component directly
+    // below the frame, which intercepts all mouse events that are not
+    // directed at the frame itself.
+    JPanel modalInterceptor = new JPanel();
+    modalInterceptor.setOpaque(false);
+    JLayeredPane lp = JLayeredPane.getLayeredPaneAbove(f);
+    lp.setLayer(modalInterceptor, JLayeredPane.MODAL_LAYER.intValue());
+    modalInterceptor.setBounds(0, 0, lp.getWidth(), lp.getHeight());
+    modalInterceptor.addMouseListener(new MouseAdapter(){});
+    modalInterceptor.addMouseMotionListener(new MouseMotionAdapter(){});
+    lp.add(modalInterceptor);
+    f.toFront();
+
+    // We need to explicitly dispatch events when we are blocking the event
+    // dispatch thread.
+    EventQueue queue = Toolkit.getDefaultToolkit().getSystemEventQueue();
+    try
+      {
+        while (! f.isClosed())
+          {
+            if (EventQueue.isDispatchThread())
+              {
+                // The getNextEventMethod() issues wait() when no
+                // event is available, so we don't need do explicitly wait().
+                AWTEvent ev = queue.getNextEvent();
+                // This mimics EventQueue.dispatchEvent(). We can't use
+                // EventQueue.dispatchEvent() directly, because it is
+                // protected, unfortunately.
+                if (ev instanceof ActiveEvent)
+                  ((ActiveEvent) ev).dispatch();
+                else if (ev.getSource() instanceof Component)
+                  ((Component) ev.getSource()).dispatchEvent(ev);
+                else if (ev.getSource() instanceof MenuComponent)
+                  ((MenuComponent) ev.getSource()).dispatchEvent(ev);
+                // Other events are ignored as per spec in
+                // EventQueue.dispatchEvent
+              }
+            else
+              {
+                // Give other threads a chance to become active.
+                Thread.yield();
+              }
+          }
+      }
+    catch (InterruptedException ex)
+      {
+        // If we get interrupted, then leave the modal state.
+      }
+    finally
+      {
+        // Clean up the modal interceptor.
+        lp.remove(modalInterceptor);
+
+        // Remove the internal frame from its parent, so it is no longer
+        // lurking around and clogging memory.
+        Container parent = f.getParent();
+        if (parent != null)
+          parent.remove(f);
+      }
+  }
+}

Added: llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JPanel.java
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JPanel.java?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JPanel.java (added)
+++ llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JPanel.java Thu Nov  8 16:56:19 2007
@@ -0,0 +1,203 @@
+/* JPanel.java --
+   Copyright (C) 2002, 2004, 2006, 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;
+
+import java.awt.FlowLayout;
+import java.awt.LayoutManager;
+
+import javax.accessibility.Accessible;
+import javax.accessibility.AccessibleContext;
+import javax.accessibility.AccessibleRole;
+import javax.swing.plaf.PanelUI;
+
+/**
+ * An instance of JPanel can be added to a panel, frame etc
+ *
+ * @author Ronald Veldema (rveldema at cs.vu.nl)
+ */
+public class JPanel extends JComponent implements Accessible
+{
+  /**
+   * Provides accessibility support for <code>JPanel</code>.
+   *
+   * @author Roman Kennke (roman at kennke.org)
+   */
+  protected class AccessibleJPanel extends AccessibleJComponent
+  {
+    /**
+     * Creates a new instance of <code>AccessibleJPanel</code>.
+     */
+    protected AccessibleJPanel()
+    {
+      // Nothing to do here.
+    }
+
+    /**
+     * Returns the accessible role for <code>JPanel</code>, which is
+     * {@link AccessibleRole#PANEL}.
+     *
+     * @return the accessible role for <code>JPanel</code>
+     */
+    public AccessibleRole getAccessibleRole()
+    {
+      return AccessibleRole.PANEL;
+    }
+  }
+
+  /**
+   * Creates a new panel with a new instance of {@link FlowLayout} as the
+   * layout manager and double-buffering enabled.
+   */
+  public JPanel()
+  {
+    this(new FlowLayout(), true);
+  }
+
+  /**
+   * Creates a new panel with double-buffering enabled or disabled as
+   * specified.  The default layout manager is an instance of 
+   * {@link FlowLayout}.
+   * 
+   * @param isDoubleBuffered  a flag that controls whether or not 
+   *     double-buffering is enabled.
+   */
+  public JPanel(boolean isDoubleBuffered)
+  {
+    this(new FlowLayout(), isDoubleBuffered);
+  }
+
+  /**
+   * Creates a new panel with the specified layout manager.  Double-buffering
+   * is enabled by default.
+   * 
+   * @param layout  the layout manager (<code>null</code> permitted).
+   */
+  public JPanel(LayoutManager layout)
+  {
+    this(layout, true);
+  }
+
+  /**
+   * Creates a new panel with the specified layout manager and 
+   * double-buffering.
+   * 
+   * @param layout  the layout manager (<code>null</code> permitted).
+   * @param isDoubleBuffered  a flag that controls whether or not 
+   *     double-buffering is enabled.
+   */
+  public JPanel(LayoutManager layout, boolean isDoubleBuffered)
+  {
+    setLayout(layout); 
+    setOpaque(true);
+    setDoubleBuffered(isDoubleBuffered);
+    updateUI();	
+  } 
+
+  /**
+   * Returns the suffix (<code>"PanelUI"</code> in this case) used to 
+   * determine the class name for a UI delegate that can provide the look and 
+   * feel for a <code>JPanel</code>.
+   *
+   * @return <code>"PanelUI"</code>.
+   */
+  public String getUIClassID()
+  {
+    return "PanelUI";
+  }
+
+  /**
+   * Sets the UI delegate for the <code>JPanel</code> component.
+   * 
+   * @param ui  the UI delegate.
+   * 
+   * @since 1.4
+   * @see #getUI()
+   */
+  public void setUI(PanelUI ui)
+  {
+    super.setUI(ui);
+  }
+
+  /**
+   * Returns the UI delegate for the <code>JPanel</code> component.
+   * 
+   * @return The UI delegate.
+   * 
+   * @since 1.4
+   * @see #setUI(PanelUI)
+   */
+  public PanelUI getUI()
+  {
+    return (PanelUI) ui;
+  }
+
+  /**
+   * Sets this panel's UI delegate to the default (obtained from the
+   * {@link UIManager}) for the current look and feel.
+   */
+  public void updateUI()
+  {
+    setUI((PanelUI) UIManager.getUI(this));
+  }
+
+  /**
+   * Returns the object that provides accessibility features for this
+   * <code>JPanel</code> component.
+   *
+   * @return The accessible context (an instance of {@link AccessibleJPanel}).
+   */
+  public AccessibleContext getAccessibleContext()
+  {
+    if (accessibleContext == null)
+      accessibleContext = new AccessibleJPanel();
+    return accessibleContext;
+  }
+    
+  /**
+   * Returns an implementation-dependent string describing the attributes of
+   * this <code>JPanel</code>.
+   *
+   * @return A string describing the attributes of this <code>JPanel</code>
+   *         (never <code>null</code>).
+   */
+  protected String paramString()
+  {
+	return super.paramString();
+  }
+}

Added: llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JPasswordField.java
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JPasswordField.java?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JPasswordField.java (added)
+++ llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JPasswordField.java Thu Nov  8 16:56:19 2007
@@ -0,0 +1,297 @@
+/* JPasswordField.java --
+   Copyright (C) 2002, 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., 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;
+
+import java.io.IOException;
+import java.io.ObjectOutputStream;
+
+import javax.accessibility.AccessibleContext;
+import javax.accessibility.AccessibleRole;
+import javax.swing.text.BadLocationException;
+import javax.swing.text.Document;
+
+/**
+ * class JPasswordField
+ * 
+ * @author Andrew Selkirk
+ * @author Lillian Angel
+ * @version 1.0
+ */
+public class JPasswordField extends JTextField
+{
+  /**
+   * AccessibleJPasswordField
+   */
+  protected class AccessibleJPasswordField extends AccessibleJTextField
+  {
+    private static final long serialVersionUID = -8477039424200681086L;
+
+    /**
+     * Constructor AccessibleJPasswordField
+     */
+    protected AccessibleJPasswordField()
+    {
+      // Nothing to do here.
+    }
+
+    /**
+     * getAccessibleRole
+     * 
+     * @return AccessibleRole
+     */
+    public AccessibleRole getAccessibleRole()
+    {
+      return AccessibleRole.PASSWORD_TEXT;
+    }
+  }
+
+  /**
+   * echoChar.  Default is 0.
+   */
+  private char echoChar = 0;
+
+  /**
+   * Creates a <code>JPasswordField</code> object.
+   */
+  public JPasswordField()
+  {
+    this(null, null, 0);
+  }
+
+  /**
+   * Creates a <code>JPasswordField</code> object.
+   * 
+   * @param text the initial text
+   */
+  public JPasswordField(String text)
+  {
+    this(null, text, 0);
+  }
+
+  /**
+   * Creates a <code>JPasswordField</code> object.
+   * 
+   * @param columns the number of columns
+   */
+  public JPasswordField(int columns)
+  {
+    this(null, null, columns);
+  }
+
+  /**
+   * Creates a <code>JPasswordField</code> object.
+   * 
+   * @param text the initial text
+   * @param columns the number of columns
+   */
+  public JPasswordField(String text, int columns)
+  {
+    this(null, text, columns);
+  }
+
+  /**
+   * Creates a <code>JPasswordField</code> object.
+   * 
+   * @param document the document to use
+   * @param text the initial text
+   * @param columns the number of columns
+   */
+  public JPasswordField(Document document, String text, int columns)
+  {
+    super(document, text, columns);
+  }
+
+  /**
+   * writeObject
+   * 
+   * @param stream the stream to write to
+   * 
+   * @exception IOException if an error occurs
+   */
+  private void writeObject(ObjectOutputStream stream) throws IOException
+  {
+    // TODO: Implement me.
+  }
+
+  /**
+   * Returns the <code>UIClassID</code>
+   * 
+   * @return the string "PasswordFieldUI"
+   */
+  public String getUIClassID()
+  {
+    return "PasswordFieldUI";
+  }
+
+  /**
+   * getEchoChar
+   * 
+   * @return the echo char
+   */
+  public char getEchoChar()
+  {
+    return echoChar;
+  }
+
+  /**
+   * setEchoChar
+   * 
+   * @param echo the echo char
+   */
+  public void setEchoChar(char echo)
+  {
+    this.echoChar = echo;
+  }
+
+  /**
+   * Returns true if this JPasswordField has a character set for echoing. 
+   * A character is considered to be set if the echo character is not 0.
+   * 
+   * @return <code>true</code> if the echo char is set,
+   * <code>false</code> otherwise.
+   */
+  public boolean echoCharIsSet()
+  {
+    return echoChar != 0;
+  }
+
+  /**
+   * Copies the selected text into the clipboard. This operation is not
+   * allowed in a password input field.
+   */
+  public void copy()
+  {
+    UIManager.getLookAndFeel().provideErrorFeedback(this);
+  }
+
+  /**
+   * Cuts the selected text and puts it into the clipboard. This operation
+   * is not allowed in a password input field.
+   */
+  public void cut()
+  {
+    UIManager.getLookAndFeel().provideErrorFeedback(this);
+  }
+
+  /**
+   * Returns the text contained in this TextComponent. If the 
+   * underlying document is null, will give a NullPointerException.
+   * 
+   * @return String
+   * 
+   * @deprecated
+   */
+  public String getText()
+  {
+    try
+      {
+        return getDocument().getText(0, getDocument().getLength());
+      }
+    catch (BadLocationException ble)
+      {
+        // This should never happen.
+        throw new AssertionError(ble);
+      }
+  }
+
+  /**
+   * Fetches a portion of the text represented by the component. 
+   * Returns an empty string if length is 0. If the 
+   * underlying document is null, will give a NullPointerException.
+   * 
+   * @param offset TODO
+   * @param length TODO
+   * 
+   * @return String
+   * 
+   * @exception BadLocationException TODO
+   *
+   * @deprecated
+   */
+  public String getText(int offset, int length) throws BadLocationException
+  {
+    return getDocument().getText(offset, length);
+  }
+
+  /**
+   * Returns the text contained in this TextComponent. If the underlying 
+   * document is null, will give a NullPointerException. 
+   * For stronger security, it is recommended that the returned character 
+   * array be cleared after use by setting each character to zero.
+   * 
+   * @return char[]
+   */
+  public char[] getPassword()
+  {
+    return getText().toCharArray();
+  }
+
+  /**
+   * Returns a string representation of this JPasswordField. This method is 
+   * intended to be used only for debugging purposes, 
+   * and the content and format of the returned string may vary between 
+   * implementations. The returned string may be empty but may not be null.
+   * 
+   * @return String
+   */
+  protected String paramString()
+  {
+    try
+      {
+        return getText();
+      }
+    catch (NullPointerException npe)
+      {
+        return "";
+      }
+  }
+
+  /**
+   * getAccessibleContext
+   * 
+   * @return the <code>AccessibleContext</code> object
+   */
+  public AccessibleContext getAccessibleContext()
+  {
+    if (accessibleContext == null)
+      accessibleContext = new AccessibleJPasswordField();
+
+    return accessibleContext;
+  }
+}

Added: llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JPopupMenu.java
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JPopupMenu.java?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JPopupMenu.java (added)
+++ llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JPopupMenu.java Thu Nov  8 16:56:19 2007
@@ -0,0 +1,924 @@
+/* JPopupMenu.java --
+   Copyright (C) 2002, 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;
+
+import java.awt.Component;
+import java.awt.Dimension;
+import java.awt.Insets;
+import java.awt.Point;
+import java.awt.event.KeyEvent;
+import java.awt.event.MouseEvent;
+import java.beans.PropertyChangeEvent;
+import java.beans.PropertyChangeListener;
+import java.util.ArrayList;
+import java.util.EventListener;
+
+import javax.accessibility.Accessible;
+import javax.accessibility.AccessibleContext;
+import javax.accessibility.AccessibleRole;
+import javax.swing.event.MenuKeyListener;
+import javax.swing.event.PopupMenuEvent;
+import javax.swing.event.PopupMenuListener;
+import javax.swing.plaf.PopupMenuUI;
+
+/**
+ * JPopupMenu is a container that is used to display popup menu's menu
+ * items. By default JPopupMenu is a lightweight container, however if it
+ * is the case that JPopupMenu's bounds are outside of main window, then
+ * heawyweight container will be used to display menu items. It is also
+ * possible to change JPopupMenu's default  behavior and set JPopupMenu
+ * to always use heavyweight container.
+ *
+ * JPopupMenu can be displayed anywhere; it is a floating free popup menu.
+ * However before JPopupMenu is diplayed, its invoker property should be set.
+ * JPopupMenu's invoker is a component relative to which popup menu is
+ * displayed.
+ *
+ * JPopupMenu fires PopupMenuEvents to its registered listeners. Whenever
+ * JPopupMenu becomes visible on the screen then PopupMenuEvent indicating
+ * that popup menu became visible will be fired. In the case when
+ * JPopupMenu becomes invisible or cancelled without selection, then
+ * popupMenuBecomeInvisible() or popupMenuCancelled() methods of
+ * PopupMenuListeners will be invoked.
+ *
+ * JPopupMenu also fires PropertyChangeEvents when its bound properties 
+ * change.In addittion to inheritted bound properties, JPopupMenu has 
+ * 'visible' bound property. When JPopupMenu becomes visible/invisible on
+ * the screen it fires PropertyChangeEvents to its registered 
+ * PropertyChangeListeners.
+ */
+public class JPopupMenu extends JComponent implements Accessible, MenuElement
+{
+  private static final long serialVersionUID = -8336996630009646009L;
+
+  /* indicates if popup's menu border should be painted*/
+  private boolean borderPainted = true;
+
+  /** Flag indicating whether lightweight, mediumweight or heavyweight popup
+     is used to display menu items.
+
+     These are the possible cases:
+
+     1. if DefaultLightWeightPopupEnabled true
+         (i)  use lightweight container if popup feets inside top-level window
+         (ii) only use heavyweight container (JDialog) if popup doesn't fit.
+
+     2. if DefaultLightWeightPopupEnabled false
+         (i) if popup fits, use awt.Panel (mediumWeight)
+         (ii) if popup doesn't fit, use JDialog (heavyWeight)
+  */
+  private static boolean DefaultLightWeightPopupEnabled = true;
+
+  /* Component that invokes popup menu. */
+  transient Component invoker;
+
+  /* Label for this popup menu. It is not used in most of the look and feel themes. */
+  private String label;
+
+  /*Amount of space between menuItem's in JPopupMenu and JPopupMenu's border */
+  private Insets margin;
+
+  /** Indicates whether ligthWeight container can be used to display popup
+     menu. This flag is the same as DefaultLightWeightPopupEnabled, but setting
+     this flag can change popup menu after creation of the object */
+  private boolean lightWeightPopupEnabled;
+
+  /** SelectionModel that keeps track of menu selection. */
+  protected SingleSelectionModel selectionModel;
+
+  /* Popup that is used to display JPopupMenu */
+  private transient Popup popup;
+
+  /**
+   * Location of the popup, X coordinate.
+   */
+  private int popupLocationX;
+
+  /**
+   * Location of the popup, Y coordinate.
+   */
+  private int popupLocationY;
+
+  /* Field indicating if popup menu is visible or not */
+  private boolean visible = false;
+  
+  /**
+   * Creates a new JPopupMenu object.
+   */
+  public JPopupMenu()
+  {
+    this(null);
+  }
+
+  /**
+   * Creates a new JPopupMenu with specified label
+   *
+   * @param label Label for popup menu.
+   */
+  public JPopupMenu(String label)
+  {
+    lightWeightPopupEnabled = getDefaultLightWeightPopupEnabled();
+    setLabel(label);
+    setSelectionModel(new DefaultSingleSelectionModel());
+    super.setVisible(false);
+    updateUI();
+  }
+
+  /**
+  * Adds given menu item to the popup menu
+  *
+  * @param item menu item to add to the popup menu
+  *
+  * @return menu item that was added to the popup menu
+  */
+  public JMenuItem add(JMenuItem item)
+  {
+    this.insert(item, -1);
+    return item;
+  }
+
+  /**
+   * Constructs menu item with a specified label and adds it to
+   * popup menu
+   *
+   * @param text label for the menu item to be added
+   *
+   * @return constructed menu item that was added to the popup menu
+   */
+  public JMenuItem add(String text)
+  {
+    JMenuItem item = new JMenuItem(text);
+    return add(item);
+  }
+
+  /**
+   * Constructs menu item associated with the specified action
+   * and adds it to the popup menu
+   *
+   * @param action Action for the new menu item
+   *
+   * @return menu item that was added to the menu
+   */
+  public JMenuItem add(Action action)
+  {
+    JMenuItem item = createActionComponent(action);
+
+    if (action != null)
+      action.addPropertyChangeListener(createActionChangeListener(item));
+
+    return add(item);
+  }
+
+  /**
+   * Revomes component at the given index from the menu.
+   *
+   * @param index index of the component that will be removed in the menu
+   */
+  public void remove(int index)
+  {
+    super.remove(index);
+    revalidate();
+  }
+
+  /**
+   * Create menu item associated with the given action
+   * and inserts it into the popup menu at the specified index
+   *
+   * @param action Action for the new menu item
+   * @param index index in the popup menu at which to insert new menu item.
+   */
+  public void insert(Action action, int index)
+  {
+    JMenuItem item = new JMenuItem(action);
+    this.insert(item, index);
+  }
+
+  /**
+   * Insert given component to the popup menu at the
+   * specified index
+   *
+   * @param component Component to insert
+   * @param index Index at which to insert given component
+   */
+  public void insert(Component component, int index)
+  {
+    super.add(component, index);
+  }
+
+  /**
+   * Returns flag indicating if newly created JPopupMenu will use
+   * heavyweight or lightweight container to display its menu items
+   *
+   * @return true if JPopupMenu will use lightweight container to display
+   * menu items by default, and false otherwise.
+   */
+  public static boolean getDefaultLightWeightPopupEnabled()
+  {
+    return DefaultLightWeightPopupEnabled;
+  }
+
+  /**
+   * Sets whether JPopupMenu should use ligthWeight container to
+   * display it menu items by default
+   *
+   * @param enabled true if JPopupMenu should use lightweight container
+   * for displaying its menu items, and false otherwise.
+   */
+  public static void setDefaultLightWeightPopupEnabled(boolean enabled)
+  {
+    DefaultLightWeightPopupEnabled = enabled;
+  }
+
+  /**
+   * This method returns the UI used to display the JPopupMenu.
+   *
+   * @return The UI used to display the JPopupMenu.
+   */
+  public PopupMenuUI getUI()
+  {
+    return (PopupMenuUI) ui;
+  }
+
+  /**
+   * Set the "UI" property of the menu item, which is a look and feel class
+   * responsible for handling popupMenu's input events and painting it.
+   *
+   * @param ui The new "UI" property
+   */
+  public void setUI(PopupMenuUI ui)
+  {
+    super.setUI(ui);
+  }
+
+  /**
+   * This method sets this menuItem's UI to the UIManager's default for the
+   * current look and feel.
+   */
+  public void updateUI()
+  {
+    setUI((PopupMenuUI) UIManager.getUI(this));
+  }
+
+  /**
+   * This method returns a name to identify which look and feel class will be
+   * the UI delegate for the menuItem.
+   *
+   * @return The Look and Feel classID. "PopupMenuUI"
+   */
+  public String getUIClassID()
+  {
+    return "PopupMenuUI";
+  }
+
+  /**
+   * Returns selectionModel used by this popup menu to keep
+   * track of the selection.
+   *
+   * @return popup menu's selection model
+   */
+  public SingleSelectionModel getSelectionModel()
+  {
+    return selectionModel;
+  }
+
+  /**
+   * Sets selection model for this popup menu
+   *
+   * @param model new selection model of this popup menu
+   */
+  public void setSelectionModel(SingleSelectionModel model)
+  {
+	selectionModel = model;
+  }
+
+  /**
+   * Creates new menu item associated with a given action.
+   *
+   * @param action Action used to create new menu item
+   *
+   * @return new created menu item associated with a given action.
+   */
+  protected JMenuItem createActionComponent(Action action)
+  {
+    return new JMenuItem(action);
+  }
+
+  /**
+   * Creates PropertyChangeListener that listens to PropertyChangeEvents
+   * occuring in the Action associated with given menu item in this popup menu.
+   *
+   * @param item MenuItem
+   *
+   * @return The PropertyChangeListener
+   */
+  protected PropertyChangeListener createActionChangeListener(JMenuItem item)
+  {
+    return new ActionChangeListener();
+  }
+
+  /**
+   * Returns true if this popup menu will display its menu item in
+   * a lightweight container and false otherwise.
+   *
+   * @return true if this popup menu will display its menu items
+   * in a lightweight container and false otherwise.
+   */
+  public boolean isLightWeightPopupEnabled()
+  {
+    return lightWeightPopupEnabled;
+  }
+
+  /**
+   * DOCUMENT ME!
+   *
+   * @param enabled DOCUMENT ME!
+   */
+  public void setLightWeightPopupEnabled(boolean enabled)
+  {
+    lightWeightPopupEnabled = enabled;
+  }
+
+  /**
+   * Returns label for this popup menu
+   *
+   * @return label for this popup menu
+   */
+  public String getLabel()
+  {
+    return label;
+  }
+
+  /**
+   * Sets label for this popup menu. This method fires PropertyChangeEvent
+   * when the label property is changed. Please note that most
+   * of the Look & Feel will ignore this property.
+   *
+   * @param label label for this popup menu
+   */
+  public void setLabel(String label)
+  {
+    if (label != this.label)
+      {
+	String oldLabel = this.label;
+	this.label = label;
+	firePropertyChange("label", oldLabel, label);
+      }
+  }
+
+  /**
+   * Adds separator to this popup menu
+   */
+  public void addSeparator()
+  {
+    // insert separator at the end of the list of menu items    
+    this.insert(new Separator(), -1);
+  }
+
+  /**
+   * Adds a MenuKeyListener to the popup.
+   * 
+   * @param l - the listener to add.
+   */
+  public void addMenuKeyListener(MenuKeyListener l)
+  {
+    listenerList.add(MenuKeyListener.class, l);
+  }
+  
+  /**
+   * Removes a MenuKeyListener from the popup.
+   * 
+   * @param l - the listener to remove.
+   */
+  public void removeMenuKeyListener(MenuKeyListener l)
+  {
+    listenerList.remove(MenuKeyListener.class, l);
+  }
+  
+  /**
+   * Returns array of getMenuKeyListeners that are listening to JPopupMenu.
+   * 
+   * @return array of getMenuKeyListeners that are listening to JPopupMenu
+   */
+  public MenuKeyListener[] getMenuKeyListeners()
+  {
+    return ((MenuKeyListener[]) listenerList.getListeners(MenuKeyListener.class));
+  }
+  
+  /**
+   * Adds popupMenuListener to listen for PopupMenuEvents fired
+   * by the JPopupMenu
+   *
+   * @param listener PopupMenuListener to add to JPopupMenu
+   */
+  public void addPopupMenuListener(PopupMenuListener listener)
+  {
+    listenerList.add(PopupMenuListener.class, listener);
+  }
+
+  /**
+   * Removes PopupMenuListener from JPopupMenu's list of listeners
+   *
+   * @param listener PopupMenuListener which needs to be removed
+   */
+  public void removePopupMenuListener(PopupMenuListener listener)
+  {
+    listenerList.remove(PopupMenuListener.class, listener);
+  }
+
+  /**
+   * Returns array of PopupMenuListeners that are listening to JPopupMenu
+   *
+   * @return Array of PopupMenuListeners that are listening to JPopupMenu
+   */
+  public PopupMenuListener[] getPopupMenuListeners()
+  {
+    return ((PopupMenuListener[]) listenerList.getListeners(PopupMenuListener.class));
+  }
+
+  /**
+   * This method calls popupMenuWillBecomeVisible() of popup menu's
+   * PopupMenuListeners. This method is invoked just before popup menu
+   * will appear on the screen.
+   */
+  protected void firePopupMenuWillBecomeVisible()
+  {
+    EventListener[] ll = listenerList.getListeners(PopupMenuListener.class);
+
+    for (int i = 0; i < ll.length; i++)
+      ((PopupMenuListener) ll[i]).popupMenuWillBecomeVisible(new PopupMenuEvent(this));
+  }
+
+  /**
+   * This method calls popupMenuWillBecomeInvisible() of popup
+   * menu's PopupMenuListeners. This method is invoked just before popup
+   * menu will disappear from the screen
+   */
+  protected void firePopupMenuWillBecomeInvisible()
+  {
+    EventListener[] ll = listenerList.getListeners(PopupMenuListener.class);
+
+    for (int i = 0; i < ll.length; i++)
+      ((PopupMenuListener) ll[i]).popupMenuWillBecomeInvisible(new PopupMenuEvent(this));
+  }
+
+  /**
+   * This method calls popupMenuCanceled() of popup menu's PopupMenuListeners.
+   * This method is invoked just before popup menu is cancelled. This happens
+   * when popup menu is closed without selecting any of its menu items. This
+   * usually happens when the top-level window is resized or moved.
+   */
+  protected void firePopupMenuCanceled()
+  {
+    EventListener[] ll = listenerList.getListeners(PopupMenuListener.class);
+
+    for (int i = 0; i < ll.length; i++)
+      ((PopupMenuListener) ll[i]).popupMenuCanceled(new PopupMenuEvent(this));
+  }
+
+  /**
+   * This methods sets popup menu's size to its' preferred size. If the
+   * popup menu's size is previously set it will be ignored.
+   */
+  public void pack()
+  {
+    // Hook up this call so that it gets executed on the event thread in order
+    // to avoid synchronization problems when calling the layout manager.
+    if (! SwingUtilities.isEventDispatchThread())
+      {
+        SwingUtilities.invokeLater(new Runnable()
+          {
+            public void run()
+            {
+              show();
+            }
+          });
+      }
+
+    setSize(getPreferredSize());
+  }
+
+  /**
+   * Return visibility of the popup menu
+   *
+   * @return true if popup menu is visible on the screen and false otherwise.
+   */
+  public boolean isVisible()
+  {
+    return visible;
+  }
+
+  /**
+   * Sets visibility property of this popup menu. If the property is
+   * set to true then popup menu will be dispayed and popup menu will
+   * hide itself if visible property is set to false.
+   *
+   * @param visible true if popup menu will become visible and false otherwise.
+   */
+  public void setVisible(final boolean visible)
+  {
+    // Hook up this call so that it gets executed on the event thread in order
+    // to avoid synchronization problems when calling the layout manager.
+    if (! SwingUtilities.isEventDispatchThread())
+      {
+        SwingUtilities.invokeLater(new Runnable()
+          {
+            public void run()
+            {
+              setVisible(visible);
+            }
+          });
+      }
+
+    if (visible == isVisible())
+      return;
+
+    boolean old = isVisible();
+    this.visible = visible;
+    if (old != isVisible())
+      {
+        if (visible)
+          {
+            if (invoker != null && !(invoker instanceof JMenu))
+              {
+                MenuElement[] menuEls;
+                if (getSubElements().length > 0)
+                  {
+                    menuEls = new MenuElement[2];
+                    menuEls[0] = this;
+                    menuEls[1] = getSubElements()[0];
+                }
+                else
+                  {
+                    menuEls = new MenuElement[1];
+                    menuEls[0] = this;
+                  }
+                MenuSelectionManager.defaultManager().setSelectedPath(menuEls);
+              }
+            firePopupMenuWillBecomeVisible();
+            PopupFactory pf = PopupFactory.getSharedInstance();
+            pack();
+            popup = pf.getPopup(invoker, this, popupLocationX, popupLocationY);
+            popup.show();
+          }
+        else
+          {
+            getSelectionModel().clearSelection();
+            firePopupMenuWillBecomeInvisible();
+            popup.hide();
+          }
+        firePropertyChange("visible", old, isVisible());
+      }
+  }
+
+  /**
+   * Sets location of the popup menu.
+   *
+   * @param x X coordinate of the popup menu's location
+   * @param y Y coordinate of the popup menu's location
+   */
+  public void setLocation(int x, int y)
+  {
+    popupLocationX = x;
+    popupLocationY = y;
+    // Handle the case when the popup is already showing. In this case we need
+    // to fetch a new popup from PopupFactory and use this. See the general
+    // contract of the PopupFactory.
+  }
+
+  /**
+   * Returns popup menu's invoker.
+   *
+   * @return popup menu's invoker
+   */
+  public Component getInvoker()
+  {
+    return invoker;
+  }
+
+  /**
+   * Sets popup menu's invoker.
+   *
+   * @param component The new invoker of this popup menu
+   */
+  public void setInvoker(Component component)
+  {
+    invoker = component;
+  }
+
+  /**
+   * This method displays JPopupMenu on the screen at the specified
+   * location. Note that x and y coordinates given to this method
+   * should be expressed in terms of the popup menus' invoker.
+   *
+   * @param component Invoker for this popup menu
+   * @param x x-coordinate of the popup menu relative to the specified invoker
+   * @param y y-coordiate of the popup menu relative to the specified invoker
+   */
+  public void show(Component component, int x, int y)
+  {
+    if (component.isShowing())
+      {
+        setInvoker(component);
+        Point p = new Point(x, y);
+        SwingUtilities.convertPointToScreen(p, component);
+        setLocation(p.x, p.y);
+        setVisible(true);
+      }
+  }
+
+  /**
+   * Returns component located at the specified index in the popup menu
+   *
+   * @param index index of the component to return
+   *
+   * @return component located at the specified index in the popup menu
+   *
+   * @deprecated Replaced by getComponent(int)
+   */
+  public Component getComponentAtIndex(int index)
+  {
+    return getComponent(index);
+  }
+
+  /**
+   * Returns index of the specified component in the popup menu
+   *
+   * @param component Component to look for
+   *
+   * @return index of the specified component in the popup menu
+   */
+  public int getComponentIndex(Component component)
+  {
+    Component[] items = getComponents();
+
+    for (int i = 0; i < items.length; i++)
+      {
+	if (items[i].equals(component))
+	  return i;
+      }
+
+    return -1;
+  }
+
+  /**
+   * Sets size of the popup
+   *
+   * @param size Dimensions representing new size of the popup menu
+   */
+  public void setPopupSize(Dimension size)
+  {
+    super.setSize(size);
+  }
+
+  /**
+   * Sets size of the popup menu
+   *
+   * @param width width for the new size
+   * @param height height for the new size
+   */
+  public void setPopupSize(int width, int height)
+  {
+    super.setSize(width, height);
+  }
+
+  /**
+   * Selects specified component in this popup menu.
+   *
+   * @param selected component to select
+   */
+  public void setSelected(Component selected)
+  {
+    int index = getComponentIndex(selected);
+    selectionModel.setSelectedIndex(index);
+  }
+
+  /**
+   * Checks if this popup menu paints its border.
+   *
+   * @return true if this popup menu paints its border and false otherwise.
+   */
+  public boolean isBorderPainted()
+  {
+    return borderPainted;
+  }
+
+  /**
+   * Sets if the border of the popup menu should be
+   * painter or not.
+   *
+   * @param painted true if the border should be painted and false otherwise
+   */
+  public void setBorderPainted(boolean painted)
+  {
+    borderPainted = painted;
+  }
+
+  /**
+   * Returns margin for this popup menu.
+   *
+   * @return margin for this popup menu.
+   */
+  public Insets getMargin()
+  {
+    return margin;
+  }
+
+  /**
+   * A string that describes this JPopupMenu. Normally only used
+   * for debugging.
+   *
+   * @return A string describing this JMenuItem
+   */
+  protected String paramString()
+  {
+    StringBuffer sb = new StringBuffer();
+    sb.append(super.paramString());
+    sb.append(",label=");
+    if (getLabel() != null)
+      sb.append(getLabel());
+    sb.append(",lightWeightPopupEnabled=").append(isLightWeightPopupEnabled());
+    sb.append(",margin=");
+    if (getMargin() != null)
+      sb.append(margin);
+    sb.append(",paintBorder=").append(isBorderPainted());
+    return sb.toString();
+  }
+
+  /**
+  * Process mouse events forwarded from MenuSelectionManager. This method 
+  * doesn't do anything. It is here to conform to the MenuElement interface.
+  *
+  * @param event event forwarded from MenuSelectionManager
+  * @param path path to the menu element from which event was generated
+  * @param manager MenuSelectionManager for the current menu hierarchy
+  */
+  public void processMouseEvent(MouseEvent event, MenuElement[] path,
+                                MenuSelectionManager manager)
+  {
+    // Empty Implementation. This method is needed for the implementation
+    // of MenuElement interface
+  }
+
+  /**
+   * Process key events forwarded from MenuSelectionManager. This method
+   * doesn't do anything. It is here to conform to the MenuElement interface.
+   *
+   * @param event event forwarded from MenuSelectionManager
+   * @param path path to the menu element from which event was generated
+   * @param manager MenuSelectionManager for the current menu hierarchy
+   *
+   */
+  public void processKeyEvent(KeyEvent event, MenuElement[] path,
+                              MenuSelectionManager manager)
+  {
+    // Empty Implementation. This method is needed for the implementation
+    // of MenuElement interface
+  }
+
+  /**
+   * Method of MenuElement Interface. It is invoked when
+   * popupMenu's selection has changed
+   *
+   * @param changed true if this popupMenu is part of current menu
+   * hierarchy and false otherwise.
+   */
+  public void menuSelectionChanged(boolean changed)
+  {
+    if (! changed)
+      setVisible(false);
+  }
+
+  /**
+   * Return subcomonents of this popup menu. This method returns only
+   * components that implement the <code>MenuElement</code> interface.
+   *
+   * @return array of menu items belonging to this popup menu
+   */
+  public MenuElement[] getSubElements()
+  {
+    Component[] items = getComponents();
+    ArrayList subElements = new ArrayList();
+
+    for (int i = 0; i < items.length; i++)
+      if (items[i] instanceof MenuElement)
+	subElements.add(items[i]);
+
+    return (MenuElement[])
+      subElements.toArray(new MenuElement[subElements.size()]);
+  }
+
+  /**
+   * Method of the MenuElement interface. Returns reference to itself.
+   *
+   * @return Returns reference to itself
+   */
+  public Component getComponent()
+  {
+    return this;
+  }
+
+  /**
+   * Checks if observing mouse event should trigger popup
+   * menu to show on the screen.
+   *
+   * @param event MouseEvent to check
+   *
+   * @return true if the observing mouse event is popup trigger and false otherwise
+   */
+  public boolean isPopupTrigger(MouseEvent event)
+  {
+    return ((PopupMenuUI) getUI()).isPopupTrigger(event);
+  }
+
+  /**
+   * DOCUMENT ME!
+   *
+   * @return DOCUMENT ME!
+   */
+  public AccessibleContext getAccessibleContext()
+  {
+    if (accessibleContext == null)
+      accessibleContext = new AccessibleJPopupMenu();
+
+    return accessibleContext;
+  }
+
+  /**
+   * This is the separator that can be used in popup menu.
+   */
+  public static class Separator extends JSeparator
+  {
+    public Separator()
+    {
+      super();
+    }
+
+    public String getUIClassID()
+    {
+      return "PopupMenuSeparatorUI";
+    }
+  }
+
+  protected class AccessibleJPopupMenu extends AccessibleJComponent
+  {
+    private static final long serialVersionUID = 7423261328879849768L;
+
+    protected AccessibleJPopupMenu()
+    {
+      // Nothing to do here.
+    }
+
+    public AccessibleRole getAccessibleRole()
+    {
+      return AccessibleRole.POPUP_MENU;
+    }
+  }
+
+  /* This class resizes popup menu and repaints popup menu appropriately if one
+   of item's action has changed */
+  private class ActionChangeListener implements PropertyChangeListener
+  {
+    public void propertyChange(PropertyChangeEvent evt)
+    {
+      // We used to have a revalidate() and repaint() call here. However I think
+      // this is not needed. Instead, a new Popup has to be fetched from the
+      // PopupFactory and used here.
+    }
+  }
+}

Added: llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JProgressBar.java
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JProgressBar.java?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JProgressBar.java (added)
+++ llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JProgressBar.java Thu Nov  8 16:56:19 2007
@@ -0,0 +1,859 @@
+/* JProgressBar.java --
+   Copyright (C) 2002, 2004, 2005, 2006  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;
+
+import java.awt.Graphics;
+import java.beans.PropertyChangeEvent;
+
+import javax.accessibility.Accessible;
+import javax.accessibility.AccessibleContext;
+import javax.accessibility.AccessibleRole;
+import javax.accessibility.AccessibleState;
+import javax.accessibility.AccessibleStateSet;
+import javax.accessibility.AccessibleValue;
+import javax.swing.border.Border;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;
+import javax.swing.plaf.ProgressBarUI;
+
+/**
+ * A component that displays a visual indicator of the progress of a task. The
+ * component has two modes: determinate and indeterminate.  In determinate mode,
+ * the <code>JProgressBar</code> fills a percentage of its bar based on its 
+ * current value. In indeterminate mode, it creates box and bounces it between 
+ * its bounds.
+ * <p>
+ * This component has the following properties:
+ * </p>
+ * <table>
+ * <tr><th> Property         </th><th> Stored in   </th><th> Bound? </th></tr>
+ * <tr><td> borderPainted    </td><td> progressBar </td><td> yes    </td></tr>
+ * <tr><td> changeListeners  </td><td> progressBar </td><td> no     </td></tr>
+ * <tr><td> indeterminate    </td><td> progressBar </td><td> yes    </td></tr> 
+ * <tr><td> maximum          </td><td> model       </td><td> no     </td></tr>
+ * <tr><td> minimum          </td><td> model       </td><td> no     </td></tr>
+ * <tr><td> model            </td><td> progressBar </td><td> no     </td></tr> 
+ * <tr><td> orientation      </td><td> progressBar </td><td> yes    </td></tr>
+ * <tr><td> percentComplete  </td><td> progressBar </td><td> no     </td></tr>
+ * <tr><td> string           </td><td> progressBar </td><td> yes    </td></tr>
+ * <tr><td> stringPainted    </td><td> progressBar </td><td> yes    </td></tr>
+ * <tr><td> value            </td><td> model       </td><td> no     </td></tr>
+ * </table>
+ */
+public class JProgressBar extends JComponent implements SwingConstants,
+                                                        Accessible
+{
+  /**
+   * Provides the accessibility features for the <code>JProgressBar</code>
+   * component.
+   */
+  protected class AccessibleJProgressBar extends AccessibleJComponent
+    implements AccessibleValue
+  {
+    private static final long serialVersionUID = -2938130009392721813L;
+  
+    /**
+     * Creates a new <code>AccessibleJProgressBar</code> instance.
+     */
+    protected AccessibleJProgressBar()
+    {
+      // Nothing to do here.
+    } 
+
+    /**
+     * Returns a set containing the current state of the {@link JProgressBar} 
+     * component.
+     *
+     * @return The accessible state set.
+     */
+    public AccessibleStateSet getAccessibleStateSet()
+    {
+      AccessibleStateSet result = super.getAccessibleStateSet();
+      if (orientation == JProgressBar.HORIZONTAL)
+        result.add(AccessibleState.HORIZONTAL);
+      else if (orientation == JProgressBar.VERTICAL)
+        result.add(AccessibleState.VERTICAL);
+      return result;
+    } 
+
+    /**
+     * Returns the accessible role for the <code>JProgressBar</code> component.
+     *
+     * @return {@link AccessibleRole#PROGRESS_BAR}.
+     */
+    public AccessibleRole getAccessibleRole()
+    {
+      return AccessibleRole.PROGRESS_BAR;
+    } 
+
+    /**
+     * Returns an object that provides access to the current, minimum and 
+     * maximum values.
+     *
+     * @return The accessible value.
+     */
+    public AccessibleValue getAccessibleValue()
+    {
+      return this;
+    } 
+
+    /**
+     * Returns the current value of the {@link JProgressBar} component, as an
+     * {@link Integer}.
+     *
+     * @return The current value of the {@link JProgressBar} component.
+     */
+    public Number getCurrentAccessibleValue()
+    {
+      return new Integer(getValue());
+    }
+
+    /**
+     * Sets the current value of the {@link JProgressBar} component and sends a
+     * {@link PropertyChangeEvent} (with the property name 
+     * {@link AccessibleContext#ACCESSIBLE_VALUE_PROPERTY}) to all registered
+     * listeners.  If the supplied value is <code>null</code>, this method 
+     * does nothing and returns <code>false</code>.
+     *
+     * @param value  the new progress bar value (<code>null</code> permitted).
+     *
+     * @return <code>true</code> if the slider value is updated, and 
+     *     <code>false</code> otherwise.
+     */
+    public boolean setCurrentAccessibleValue(Number value)
+    {
+      if (value == null)
+        return false;
+      Number oldValue = getCurrentAccessibleValue();
+      setValue(value.intValue());
+      firePropertyChange(AccessibleContext.ACCESSIBLE_VALUE_PROPERTY, oldValue, 
+                         new Integer(getValue()));
+      return true;
+    }
+
+    /**
+     * Returns the minimum value of the {@link JProgressBar} component, as an
+     * {@link Integer}.
+     *
+     * @return The minimum value of the {@link JProgressBar} component.
+     */
+    public Number getMinimumAccessibleValue()
+    {
+      return new Integer(getMinimum());
+    }
+
+    /**
+     * Returns the maximum value of the {@link JProgressBar} component, as an
+     * {@link Integer}.
+     *
+     * @return The maximum value of the {@link JProgressBar} component.
+     */
+    public Number getMaximumAccessibleValue()
+    {
+      return new Integer(getMaximum());
+    }
+  } 
+
+  private static final long serialVersionUID = 1980046021813598781L;
+  
+  /** 
+   * A flag that determines the mode (<code>true</code> for indeterminate, 
+   * <code>false</code> for determinate).
+   */
+  private transient boolean indeterminate = false;
+
+  /** 
+   * The orientation of the <code>JProgressBar</code> 
+   * ({@link SwingConstants#HORIZONTAL} or {@link SwingConstants#VERTICAL}). 
+   * Defaults to {@link SwingConstants#HORIZONTAL}.
+   * @see #setOrientation(int)
+   */
+  protected int orientation;
+
+  /** 
+   * A flag the controls whether or not the component's border is painted.
+   * The default is <code>true</code>. 
+   * @see #setBorderPainted(boolean)
+   */
+  protected boolean paintBorder = true;
+
+  /** 
+   * The model defining the bounds and current value for the progress bar.
+   * @see #setModel(BoundedRangeModel) 
+   */
+  protected BoundedRangeModel model;
+
+  /** 
+   * A custom string for display in the progress bar.  If this is 
+   * <code>null</code>, a default string will be generated. 
+   * @see #setString(String)
+   */
+  protected String progressString;
+
+  /** 
+   * A flag that controls whether a string is displayed within the progress 
+   * bar. 
+   * @see #setStringPainted(boolean)
+   */
+  protected boolean paintString = false;
+
+  /** 
+   * A single change event reused for all events.
+   * @see #fireStateChanged() 
+   */
+  protected transient ChangeEvent changeEvent;
+
+  /** 
+   * The listener that is registered with the model. */
+  protected ChangeListener changeListener;
+
+  /**
+   * Creates a new <code>JProgressBar</code> with default attributes.  The 
+   * following defaults are used:
+   * <p>
+   * <ul>
+   * <li><code>value</code>: 0;</li>
+   * <li><code>minimum</code>: 0;</li>
+   * <li><code>maximum</code>: 100;</li>
+   * <li><code>orientation</code>: {@link SwingConstants#HORIZONTAL}.</li>
+   * </ul>  
+   */
+  public JProgressBar()
+  {
+    this(HORIZONTAL, 0, 100);
+  }
+
+  /**
+   * Creates a new <code>JProgressBar</code> with the specified 
+   * <code>orientation</code>.  The following defaults are used:
+   * <p>
+   * <ul>
+   * <li><code>value</code>: 0;</li>
+   * <li><code>minimum</code>: 0;</li>
+   * <li><code>maximum</code>: 100;</li>
+   * </ul>  
+   * 
+   * @param orientation  the orientation ({@link #HORIZONTAL} or 
+   *     {@link #VERTICAL}).
+   * 
+   * @throws IllegalArgumentException if <code>orientation</code> is not one of
+   *     the specified values.
+   */
+  public JProgressBar(int orientation)
+  {
+    this(orientation, 0, 100);
+  }
+
+  /**
+   * Creates a new <code>JProgressBar</code> with the specified value range.
+   * The following defaults are used:
+   * <p>
+   * <ul>
+   * <li><code>value</code>: <code>minimum</code>;</li>
+   * <li><code>orientation</code>: {@link SwingConstants#HORIZONTAL}.</li>
+   * </ul>  
+   * 
+   * @param minimum  the lower bound of the value range.
+   * @param maximum  the upper bound of the value range.
+   */
+  public JProgressBar(int minimum, int maximum)
+  {
+    this(HORIZONTAL, minimum, maximum);
+  }
+
+  /**
+   * Creates a new <code>JProgressBar</code> with the specified range and
+   * orientation.  The following defaults are used:
+   * <p>
+   * <ul>
+   * <li><code>value</code>: <code>minimum</code>;</li>
+   * </ul>  
+   * 
+   * @param minimum  the lower bound of the value range.
+   * @param maximum  the upper bound of the value range.
+   * @param orientation  the orientation ({@link #HORIZONTAL} or 
+   *     {@link #VERTICAL}).
+   * 
+   * @throws IllegalArgumentException if <code>orientation</code> is not one of
+   *     the specified values.
+   */
+  public JProgressBar(int orientation, int minimum, int maximum)
+  {
+    model = new DefaultBoundedRangeModel(minimum, 0, minimum, maximum);
+    if (orientation != HORIZONTAL && orientation != VERTICAL)
+      throw new IllegalArgumentException(orientation
+                                         + " is not a legal orientation");    
+    this.orientation = orientation;
+    changeListener = createChangeListener();
+    model.addChangeListener(changeListener);
+    updateUI();
+  }
+
+  /**
+   * Creates a new <code>JProgressBar</code> with the specified model.  The
+   * following defaults are used:
+   * <p>
+   * <ul>
+   * <li><code>orientation</code>: {@link SwingConstants#HORIZONTAL}.</li>
+   * </ul>  
+   * 
+   * @param model  the model (<code>null</code> not permitted).
+   */
+  public JProgressBar(BoundedRangeModel model)
+  {
+    this.model = model;
+    changeListener = createChangeListener();
+    if (model != null)
+      model.addChangeListener(changeListener);
+    updateUI();    
+  }
+
+  /**
+   * Returns the current value for the <code>JProgressBar</code>.  This value 
+   * is fetched from the model.
+   *
+   * @return The current value.
+   * 
+   * @see #setValue(int)
+   */
+  public int getValue()
+  {
+    return model.getValue();
+  }
+
+  /**
+   * Sets the current value for the <code>JProgressBar</code>.  The value is
+   * stored in the component's <code>model</code> (see {@link #getModel()}).  
+   * If the new value is different to the old value, a {@link ChangeEvent} is 
+   * sent to the model's registered listeners.  In turn, this triggers a call 
+   * to {@link #fireStateChanged()} which will send a <code>ChangeEvent</code> 
+   * to this component's registered listeners.
+   * <p>
+   * If <code>value</code> is outside the range <code>minimum</code> to 
+   * <code>maximum</code>, it will be set to the nearest of those boundary 
+   * values.
+   *
+   * @param value  the new value.
+   * 
+   * @see #getValue()
+   */
+  public void setValue(int value)
+  {
+    model.setValue(value);
+  }
+
+  /**
+   * Paints the component's border, but only if {@link #isBorderPainted()}
+   * returns <code>true</code>.
+   *
+   * @param graphics  the graphics object to paint with.
+   * 
+   * @see #setBorderPainted(boolean)
+   */
+  protected void paintBorder(Graphics graphics)
+  {
+    Border border = getBorder();
+    if (paintBorder && border != null)
+      border.paintBorder(this, graphics, 0, 0, getWidth(), getHeight());
+  }
+
+  /**
+   * Returns the orientation of the <code>JProgressBar</code> component, which
+   * is either {@link SwingConstants#HORIZONTAL} or 
+   * {@link SwingConstants#VERTICAL}.  The default orientation is 
+   * <code>HORIZONTAL</code>.
+   *
+   * @return The orientation.
+   * 
+   * @see #setOrientation(int)
+   */
+  public int getOrientation()
+  {
+    return orientation;
+  }
+
+  /**
+   * Sets the orientation for this <code>JProgressBar</code> component and,
+   * if the value changes, sends a {@link PropertyChangeEvent} (with the 
+   * property name <code>"orientation"</code>) to all registered listeners.
+   *
+   * @param orientation  the orientation ({@link #HORIZONTAL} or 
+   *     {@link #VERTICAL}).
+   * 
+   * @throws IllegalArgumentException if <code>orientation</code> is not
+   *     one of the listed values.
+   *     
+   * @see #getOrientation()
+   */
+  public void setOrientation(int orientation)
+  {
+    if (orientation != VERTICAL && orientation != HORIZONTAL)
+      throw new IllegalArgumentException(orientation
+                                         + " is not a legal orientation");    
+    if (this.orientation != orientation)
+      {
+        int oldOrientation = this.orientation;
+        this.orientation = orientation;
+        firePropertyChange("orientation", oldOrientation, this.orientation);
+      }
+  }
+
+  /**
+   * Returns the flag that controls whether or not the string returned by
+   * {@link #getString()} is displayed by the <code>JProgressBar</code> 
+   * component.
+   *
+   * @return <code>true</code> if the string should be displayed, and 
+   *     <code>false</code> otherwise.
+   * 
+   * @see #setStringPainted(boolean)
+   */
+  public boolean isStringPainted()
+  {
+    return paintString;
+  }
+
+  /**
+   * Sets the flag that controls whether or not the string returned by
+   * {@link #getString()} is displayed by the <code>JProgressBar</code> 
+   * component.  If the flag value changes, a {@link PropertyChangeEvent} (with 
+   * the property name <code>"stringPainted"</code>) is sent to all registered 
+   * listeners.
+   *
+   * @param painted  the new flag value.
+   * 
+   * @see #isStringPainted()
+   * @see #setString(String)
+   */
+  public void setStringPainted(boolean painted)
+  {
+    if (paintString != painted)
+      {
+        boolean oldPainted = paintString;
+        paintString = painted;
+        firePropertyChange("stringPainted", oldPainted, paintString);
+      }
+  }
+
+  /**
+   * Returns the string that is painted on the <code>JProgressBar</code> if 
+   * {@link #isStringPainted()} returns <code>true</code>.  If no string has 
+   * been explicitly set, this method will return a string displaying the 
+   * value of {@link #getPercentComplete()}.
+   *
+   * @return The string.
+   * 
+   * @see #setString(String)
+   * @see #setStringPainted(boolean)
+   */
+  public String getString()
+  {
+    if (progressString != null)
+      return progressString;
+    else
+      return (int) (getPercentComplete() * 100) + "%";
+  }
+
+  /**
+   * Sets the string to display within the progress bar and, if the new value
+   * is different to the old value, sends a {@link PropertyChangeEvent} (with 
+   * the property name <code>"string"</code>) to all registered listeners. If 
+   * the string is set to <code>null</code>, {@link #getString()} will return
+   * a default string.
+   *
+   * @param string  the string (<code>null</code> permitted).
+   * 
+   * @see #getString()
+   * @see #setStringPainted(boolean)
+   */
+  public void setString(String string)
+  {
+    if (((string == null || progressString == null) &&
+        string != progressString) || (string != null &&
+	! string.equals(progressString)))
+      {
+        String oldString = progressString;
+        progressString = string;
+        firePropertyChange("string", oldString, progressString);
+      }
+  }
+
+  /**
+   * Returns the current value expressed as a percentage.  This is calculated 
+   * as <code>(value - min) / (max - min)</code>.
+   *
+   * @return The percentage (a value in the range 0.0 to 1.0).
+   */
+  public double getPercentComplete()
+  {
+    if (getMaximum() == getMinimum())
+      return 1.0;
+    else
+      return (double) (model.getValue() - model.getMinimum()) 
+          / (model.getMaximum() - model.getMinimum());
+  }
+
+  /**
+   * Returns a flag that controls whether or not the component's border is
+   * painted.  The default value is <code>true</code>.
+   *
+   * @return <code>true</code> if the component's border should be painted,
+   *     and <code>false</code> otherwise.
+   *     
+   * @see #setBorderPainted(boolean)
+   */
+  public boolean isBorderPainted()
+  {
+    return paintBorder;
+  }
+
+  /**
+   * Sets the flag that controls whether or not the component's border is
+   * painted.  If the flag value is changed, this method sends a 
+   * {@link PropertyChangeEvent} (with the property name "borderPainted") to 
+   * all registered listeners.
+   *
+   * @param painted  the new flag value.
+   * 
+   * @see #isBorderPainted()
+   * @see #paintBorder
+   */
+  public void setBorderPainted(boolean painted)
+  {
+    if (painted != paintBorder)
+      {
+        boolean oldPainted = paintBorder;
+        paintBorder = painted;
+        firePropertyChange("borderPainted", oldPainted, paintBorder);
+      }
+  }
+
+  /**
+   * Returns the UI delegate for this <code>JProgressBar</code>.
+   *
+   * @return The UI delegate.
+   */
+  public ProgressBarUI getUI()
+  {
+    return (ProgressBarUI) ui;
+  }
+
+  /**
+   * Sets the UI delegate for this component.
+   *
+   * @param ui  the new UI delegate.
+   */
+  public void setUI(ProgressBarUI ui)
+  {
+    super.setUI(ui);
+  }
+
+  /**
+   * Sets this <code>JProgressBar</code>'s UI delegate to the default 
+   * (obtained from the {@link UIManager}) for the current look and feel.
+   */
+  public void updateUI()
+  {
+    setUI((ProgressBarUI) UIManager.getUI(this));
+  }
+
+  /**
+   * Returns the suffix (<code>"ProgressBarUI"</code> in this case) used to 
+   * determine the class name for a UI delegate that can provide the look and 
+   * feel for a <code>JProgressBar</code>.
+   *
+   * @return <code>"ProgressBarUI"</code>.
+   */
+  public String getUIClassID()
+  {
+    return "ProgressBarUI";
+  }
+
+  /**
+   * Creates a new {@link ChangeListener} that calls 
+   * {@link #fireStateChanged()} whenever it receives a {@link ChangeEvent}
+   * (typically from the component's <code>model</code>).  This listener is 
+   * registered with the progress bar's model, so that changes made to the 
+   * model directly will automatically result in the progress bar's listeners 
+   * being notified also.
+   *
+   * @return A new listener.
+   */
+  protected ChangeListener createChangeListener()
+  {
+    return new ChangeListener()
+      {
+        public void stateChanged(ChangeEvent ce)
+        {
+          fireStateChanged();
+	    }
+      };
+  }
+
+  /**
+   * Registers a listener with this component so that it will receive 
+   * notification of component state changes.
+   *
+   * @param listener  the listener.
+   * 
+   * @see #removeChangeListener(ChangeListener)
+   */
+  public void addChangeListener(ChangeListener listener)
+  {
+    listenerList.add(ChangeListener.class, listener);
+  }
+
+  /**
+   * Deregisters a listener so that it no longer receives notification of
+   * component state changes.
+   *
+   * @param listener  the listener.
+   * 
+   * @see #addChangeListener(ChangeListener)
+   */
+  public void removeChangeListener(ChangeListener listener)
+  {
+    listenerList.remove(ChangeListener.class, listener);
+  }
+  
+  /**
+   * Returns an array of the listeners that are registered with this component.
+   * The array may be empty, but is never <code>null</code>.
+   *
+   * @return An array of listeners.
+   * 
+   * @since 1.4
+   */
+  public ChangeListener[] getChangeListeners()
+  {
+    return (ChangeListener[]) listenerList.getListeners(ChangeListener.class);
+  }  
+
+  /**
+   * Sends a {@link ChangeEvent} to all registered listeners to indicate that
+   * the state of the <code>JProgressBar</code> has changed.  
+   * 
+   * @see #createChangeListener()
+   */
+  protected void fireStateChanged()
+  {
+    Object[] changeListeners = listenerList.getListenerList();
+    if (changeEvent == null)
+      changeEvent = new ChangeEvent(this);
+    for (int i = changeListeners.length - 2; i >= 0; i -= 2)
+      {
+        if (changeListeners[i] == ChangeListener.class)
+          ((ChangeListener) changeListeners[i + 1]).stateChanged(changeEvent);
+      }
+  }
+
+  /**
+   * Returns the model for the <code>JProgressBar</code>.
+   *
+   * @return The model (never <code>null</code>).
+   * 
+   * @see #setModel(BoundedRangeModel)
+   */
+  public BoundedRangeModel getModel()
+  {
+    return model;
+  }
+
+  /**
+   * Sets the model for the <code>JProgressBar</code> and sends a 
+   * {@link ChangeEvent} to all registered listeners.
+   *
+   * @param model  the model (<code>null</code> not permitted).
+   * 
+   * @see #getModel()
+   */
+  public void setModel(BoundedRangeModel model)
+  {
+    if (model != this.model)
+      {
+        this.model.removeChangeListener(changeListener);
+        this.model = model;
+        this.model.addChangeListener(changeListener);
+        fireStateChanged();
+      }
+  }
+
+  /**
+   * Returns the minimum value for the <code>JProgressBar</code>. This defines 
+   * the lower bound for the current value, and is stored in the component's 
+   * <code>model</code>.
+   *
+   * @return The minimum value.
+   * 
+   * @see #setMinimum(int)
+   */
+  public int getMinimum()
+  {
+    return model.getMinimum();
+  }
+
+  /**
+   * Sets the minimum value for the <code>JProgressBar</code>.  The value is
+   * stored in the component's <code>model</code> (see {@link #getModel()}).  
+   * If the new value is different to the old value, a {@link ChangeEvent} is 
+   * sent to the model's registered listeners.  In turn, this triggers a call 
+   * to {@link #fireStateChanged()} which will send a <code>ChangeEvent</code> 
+   * to this component's registered listeners.
+   * 
+   * @param minimum  the minimum value.
+   * 
+   * @see #getMinimum()
+   */
+  public void setMinimum(int minimum)
+  {
+    model.setMinimum(minimum);
+  }
+
+  /**
+   * Returns the maximum value for the <code>JProgressBar</code>.  This defines 
+   * the upper bound for the current value, and is stored in the component's 
+   * <code>model</code>.
+   *
+   * @return The maximum value.
+   * 
+   * @see #setMaximum(int)
+   */
+  public int getMaximum()
+  {
+    return model.getMaximum();
+  }
+
+  /**
+   * Sets the maximum value for the <code>JProgressBar</code>.  The value is
+   * stored in the component's <code>model</code> (see {@link #getModel()}).  
+   * If the new value is different to the old value, a {@link ChangeEvent} is 
+   * sent to the model's registered listeners.  In turn, this triggers a call 
+   * to {@link #fireStateChanged()} which will send a <code>ChangeEvent</code> 
+   * to this component's registered listeners.
+   *
+   * @param maximum  the maximum value.
+   * 
+   * @see #getMaximum()
+   */
+  public void setMaximum(int maximum)
+  {
+    model.setMaximum(maximum);
+  }
+
+  /**
+   * Returns an implementation-dependent string describing the attributes of
+   * this <code>JProgressBar</code>.
+   *
+   * @return A string describing the attributes of this 
+   *     <code>JProgressBar</code> (never <code>null</code>).
+   */
+  protected String paramString()
+  {
+    String superParamStr = super.paramString();
+    StringBuffer sb = new StringBuffer();
+    sb.append(",orientation=");
+    if (orientation == HORIZONTAL)
+      sb.append("HORIZONTAL");
+    else
+      sb.append("VERTICAL");
+    sb.append(",paintBorder=").append(isBorderPainted());
+    sb.append(",paintString=").append(isStringPainted());
+    sb.append(",progressString=");
+    if (progressString != null)
+      sb.append(progressString);
+    sb.append(",indeterminateString=").append(isIndeterminate());
+    return superParamStr + sb.toString();
+  }
+
+  /**
+   * Sets the flag that controls the mode for this <code>JProgressBar</code>
+   * (<code>true</code> for indeterminate mode, and <code>false</code> for
+   * determinate mode).  If the flag value changes, this method sends a 
+   * {@link PropertyChangeEvent} (with the property name 
+   * <code>"indeterminate"</code>) to all registered listeners.
+   * <p>
+   * If the <code>JProgressBar</code> is determinate, it paints a percentage
+   * of the bar described by its value. If it is indeterminate, it simply 
+   * bounces a box between the ends of the bar; the value of the 
+   * <code>JProgressBar</code> is ignored.
+   *
+   * @param flag  the new flag value.
+   * 
+   * @see #isIndeterminate()
+   * @since 1.4
+   */
+  public void setIndeterminate(boolean flag)
+  {
+    if (indeterminate != flag)
+      {
+        indeterminate = flag;
+        firePropertyChange("indeterminate", !flag, indeterminate);
+      }
+  }
+
+  /**
+   * Returns a flag that indicates the mode for this <code>JProgressBar</code>
+   * (<code>true</code> for indeterminate mode, and <code>false</code> for 
+   * determinate mode).  
+   *
+   * @return A flag indicating the mode for the <code>JProgressBar</code>.
+   * 
+   * @see #setIndeterminate(boolean)
+   * @since 1.4
+   */
+  public boolean isIndeterminate()
+  {
+    return indeterminate;
+  }
+
+  /**
+   * Returns the object that provides accessibility features for this
+   * <code>JProgressBar</code> component.
+   *
+   * @return The accessible context (an instance of 
+   *     {@link AccessibleJProgressBar}).
+   */
+  public AccessibleContext getAccessibleContext()
+  {
+    if (accessibleContext == null)
+      accessibleContext = new AccessibleJProgressBar();
+    
+    return accessibleContext;
+  } 
+}

Added: llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JRadioButton.java
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JRadioButton.java?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JRadioButton.java (added)
+++ llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JRadioButton.java Thu Nov  8 16:56:19 2007
@@ -0,0 +1,259 @@
+/* JRadioButton.java -- 
+   Copyright (C) 2002, 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;
+
+import javax.accessibility.AccessibleContext;
+import javax.accessibility.AccessibleRole;
+import javax.swing.plaf.ButtonUI;
+
+/**
+ * The <code>JRadioButton</code> component provides a visually selectable
+ * button with mutually exclusive behaviour within a <code>ButtonGroup</code>.
+ * A series of radio buttons can be used to provide options to the user,
+ * where the user can only select one of the available options.  The state
+ * of the button is provided by the superclass, <code>JToggleButton</code>.
+ * <code>JRadioButton</code> adds the additional behaviour, that if two
+ * or more radio buttons are grouped together, the selection of one implies
+ * the deselection of the other buttons within the group.
+ * <p>
+ *
+ * Buttons are grouped by adding each instance to a <code>ButtonGroup</code>.
+ * The existence of such a grouping is not reflected visually, so other means
+ * should be used to denote this.  For instance, the grouped buttons can be placed
+ * within the same panel, possibly with an appropriate border to denote
+ * the connection between the components.
+ *
+ * @author Michael Koch  (konqueror at gmx.de)
+ * @author Graydon Hoare  (graydon at redhat.com)
+ * @author Andrew John Hughes  (gnu_andrew at member.fsf.org)
+ * @see JToggleButton
+ * @see ButtonGroup
+ * @since 1.2
+ */
+public class JRadioButton extends JToggleButton
+{
+  /**
+   * Compatible with Sun's JDK.
+   */
+  private static final long serialVersionUID = 7751949583255506856L;
+
+  /**
+   * This class provides accessibility support for the toggle button.
+   */
+  protected class AccessibleJRadioButton
+    extends AccessibleJToggleButton
+  {
+    private static final long serialVersionUID = 4850967637026120674L;
+
+    /**
+     * Constructor for the accessible toggle button.
+     */
+    protected AccessibleJRadioButton()
+    {
+        /* Call the superclass to register for events */
+        super();
+    }
+
+    /**
+     * Returns the accessible role for the toggle button.
+     *
+     * @return An instance of <code>AccessibleRole</code>, describing
+     *         the role of the toggle button.
+     */
+    public AccessibleRole getAccessibleRole()
+    {
+      return AccessibleRole.RADIO_BUTTON;
+    }
+
+  }
+
+  /**
+   * Constructs an unselected radio button with no text or icon.
+   */ 
+  public JRadioButton()
+  {
+    this(null, null, false);
+  }
+    
+  /**
+   * Constructs a radio button using the labelling, state
+   * and icon specified by the supplied action.
+   *
+   * @param a the action to use to define the properties of the button.
+   */
+  public JRadioButton(Action a)
+  {
+    this();
+    setAction(a);
+  }
+
+  /**
+   * Constructs an unselected radio button with the supplied icon
+   * and no text.
+   *
+   * @param icon the icon to use.
+   */
+  public JRadioButton(Icon icon)
+  { 
+    this(null, icon, false);
+  }    
+  
+  /**
+   * Constructs a radio button with the supplied icon and state.
+   *
+   * @param icon the icon to use.
+   * @param selected if true, the radio button is initially in the
+   *        selected state.  Otherwise, the button is unselected.
+   */
+  public JRadioButton(Icon icon, boolean selected)
+  { 
+    this(null, icon, selected);
+  }    
+  
+  /**
+   * Constructs an unselected radio button using the supplied text
+   * and no icon.
+   *
+   * @param text the text to use.
+   */
+  public JRadioButton(String text)
+  {
+    this(text, null, false);
+  }
+
+  /**
+   * Constructs a radio button with the supplied text and state.
+   *
+   * @param text the text to use.
+   * @param selected if true, the radio button is initially in the
+   *        selected state.  Otherwise, the button is unselected.
+   */
+  public JRadioButton(String text, boolean selected)
+  {
+    this(text, null, selected);
+  }
+      
+  /**
+   * Constructs an unselected radio button with the supplied text
+   * and icon.
+   *
+   * @param text the text to use.
+   * @param icon the icon to use.
+   */
+  public JRadioButton(String text, Icon icon)
+  {
+    this(text, icon, false);
+  }
+  
+  /**
+   * Constructs a radio button with the supplied text, icon and state.
+   *
+   * @param text the text to use.
+   * @param icon the icon to use.
+   * @param selected if true, the radio button is initially in the
+   *        selected state.  Otherwise, the button is unselected.
+   */
+  public JRadioButton(String text, Icon icon, boolean selected)
+  {
+    super(text, icon, selected);
+    setBorderPainted(false);
+    setHorizontalAlignment(LEADING);
+  }
+      
+  /**
+   * Returns the accessible context for this <code>JRadioButton</code>,
+   * in the form of an instance of <code>AccessibleJRadioButton</code>.
+   * The context is created, if necessary.
+   *
+   * @return the associated context
+   */
+  public AccessibleContext getAccessibleContext()
+  {
+    /* Create the context if this is the first request */
+    if (accessibleContext == null)
+      {
+        /* Create the context */
+	accessibleContext = new AccessibleJRadioButton();
+      }
+    return accessibleContext;
+  }
+  
+  /**
+   * Returns a string specifying the name of the Look and Feel UI class
+   * that renders this component.
+   *
+   * @return the Look and Feel UI class for <code>JRadioButton</code>s
+   *         as a <code>String</code>.
+   */  
+  public String getUIClassID()
+  {
+    return "RadioButtonUI";
+  }
+  
+  /**
+   * Returns a string representation of this component for debugging use.
+   * Users should not depend on anything as regards the content or formatting
+   * of this string, except for the fact that the returned string may never be
+   * null (only empty).
+   *
+   * @return the component in <code>String</code> form for debugging.
+   */  
+  protected  String paramString()
+  {
+    return super.paramString();
+  }
+  
+  /**
+   * This method resets the radio button's UI delegate to the default UI for
+   * the current look and feel.
+   */
+  public void updateUI()
+  {
+    /* 
+       I can't see any difference between this and the superclass one,
+       but Sun reimplements it... there is no RadioButtonUI class for it
+       to be cast to.
+    */
+    setUI((ButtonUI) UIManager.getUI(this));
+  }
+
+}
+
+
+

Added: llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JRadioButtonMenuItem.java
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JRadioButtonMenuItem.java?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JRadioButtonMenuItem.java (added)
+++ llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JRadioButtonMenuItem.java Thu Nov  8 16:56:19 2007
@@ -0,0 +1,230 @@
+/* JRadioButtonMenuItem.java --
+   Copyright (C) 2002, 2004, 2006, 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;
+
+import javax.accessibility.Accessible;
+import javax.accessibility.AccessibleContext;
+import javax.accessibility.AccessibleRole;
+
+/**
+ * This class represents JRadioButtonMenuItem. Its behaviour is very similar
+ * to JRadioButton. Just like JRadioButton, user can check and uncheck this
+ * menu item by clicking on it. JRadioButtonMenuItem uses ToggleButtonModel
+ * to keep track of its selection. If the JRadioButtonMenuItem is included in
+ * the button group, then only one JRadioButtonMenuItem can be selected at
+ * one time.
+ */
+public class JRadioButtonMenuItem extends JMenuItem implements Accessible
+{
+  private static final long serialVersionUID = 8482658191548521743L;
+
+  /** name for the UI delegate for this radio button menu item. */
+  private static final String uiClassID = "RadioButtonMenuItemUI";
+
+  /**
+   * Creates a new JRadioButtonMenuItem object.
+   */
+  public JRadioButtonMenuItem()
+  {
+    this(null, null);
+  }
+
+  /**
+   * Creates a new JRadioButtonMenuItem with specified icon
+   *
+   * @param icon Icon to be used for this menu item
+   */
+  public JRadioButtonMenuItem(Icon icon)
+  {
+    this(null, icon);
+  }
+
+  /**
+   * Creates a new JRadioButtonMenuItem with specified label
+   *
+   * @param text Label for this menu item
+   */
+  public JRadioButtonMenuItem(String text)
+  {
+    this(text, null);
+  }
+
+  /**
+   * Creates a new JRadioButtonMenuItem using specified action
+   *
+   * @param action Action for this menu item
+   */
+  public JRadioButtonMenuItem(Action action)
+  {
+    this();
+    setAction(action);
+  }
+
+  /**
+   * Creates a new JRadioButtonMenuItem with specified label and icon
+   *
+   * @param text Label for this menu item
+   * @param icon Icon for this menu item
+   */
+  public JRadioButtonMenuItem(String text, Icon icon)
+  {
+    this(text, icon, false);
+  }
+
+  /**
+   * Creates a new JRadioButtonMenuItem with specified label
+   * and marked selected if 'selected' is true.
+   *
+   * @param text Text for this menu item
+   * @param selected Selected state of this menu item
+   */
+  public JRadioButtonMenuItem(String text, boolean selected)
+  {
+    this(text, null, selected);
+  }
+
+  /**
+   * Creates a new JRadioButtonMenuItem with specified icon
+   * and given selected state
+   *
+   * @param icon Icon for this menu item
+   * @param selected Selected state for this menu item
+   */
+  public JRadioButtonMenuItem(Icon icon, boolean selected)
+  {
+    this(null, icon, selected);
+  }
+
+  /**
+   * Creates a new JRadioButtonMenuItem with specified label,
+   * icon and selected state.
+   *
+   * @param text Label for this menu item
+   * @param icon Icon to be use for this menu item
+   * @param selected selected state of this menu item
+   */
+  public JRadioButtonMenuItem(String text, Icon icon, boolean selected)
+  {
+    super(text, icon);
+    setModel(new JToggleButton.ToggleButtonModel());
+    model.setSelected(selected);
+    setFocusable(false);
+  }
+
+  /**
+   * This method returns a name to identify which look and feel class will be
+   * the UI delegate for the menuItem.
+   *
+   * @return The Look and Feel classID. "JRadioButtonMenuItemUI"
+   */
+  public String getUIClassID()
+  {
+    return uiClassID;
+  }
+
+  /**
+   * This method overrides JComponent.requestFocus with an empty
+   * implementation, since JRadioButtonMenuItems should not
+   * receve focus in general.
+   */
+  public void requestFocus()
+  {
+    //  Should do nothing here
+  }
+
+  /**
+   * Returns a string describing the attributes for the 
+   * <code>JRadioButtonMenuItem</code> component, for use in debugging.  The 
+   * return value is guaranteed to be non-<code>null</code>, but the format of 
+   * the string may vary between implementations.
+   *
+   * @return A string describing the attributes of the 
+   *     <code>JRadioButtonMenuItem</code>.
+   */
+  protected String paramString()
+  {
+    // calling super seems to be sufficient here...
+    return super.paramString();
+  }
+
+  /**
+   * Returns the object that provides accessibility features for this
+   * <code>JRadioButtonMenuItem</code> component.
+   *
+   * @return The accessible context (an instance of 
+   *     {@link AccessibleJRadioButtonMenuItem}).
+   */
+  public AccessibleContext getAccessibleContext()
+  {
+    if (accessibleContext == null)
+      accessibleContext = new AccessibleJRadioButtonMenuItem();
+
+    return accessibleContext;
+  }
+
+  /**
+   * Provides the accessibility features for the 
+   * <code>JRadioButtonMenuItem</code> component.
+   * 
+   * @see JRadioButtonMenuItem#getAccessibleContext()
+   */
+  protected class AccessibleJRadioButtonMenuItem extends AccessibleJMenuItem
+  {
+    private static final long serialVersionUID = 4381471510145292179L;
+
+    /**
+     * Creates a new <code>AccessibleJRadioButtonMenuItem</code> instance.
+     */
+    protected AccessibleJRadioButtonMenuItem()
+    {
+      // Nothing to do here.
+    }
+
+    /**
+     * Returns the accessible role for the <code>JRadioButtonMenuItem</code> 
+     * component.
+     *
+     * @return {@link AccessibleRole#RADIO_BUTTON}.
+     */
+    public AccessibleRole getAccessibleRole()
+    {
+      return AccessibleRole.RADIO_BUTTON;
+    }
+  }
+}

Added: llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JRootPane.java
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JRootPane.java?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JRootPane.java (added)
+++ llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JRootPane.java Thu Nov  8 16:56:19 2007
@@ -0,0 +1,694 @@
+/* JRootPane.java --
+   Copyright (C) 2002, 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., 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;
+
+import java.awt.BorderLayout;
+import java.awt.Component;
+import java.awt.Container;
+import java.awt.Dimension;
+import java.awt.IllegalComponentStateException;
+import java.awt.Insets;
+import java.awt.LayoutManager;
+import java.awt.LayoutManager2;
+import java.awt.Rectangle;
+import java.io.Serializable;
+
+import javax.accessibility.Accessible;
+import javax.accessibility.AccessibleContext;
+import javax.accessibility.AccessibleRole;
+import javax.swing.plaf.RootPaneUI;
+
+/**
+ * This class is where JComponents are added to. Unlike awt where you could
+ * just say frame.add(), with swing you need to say frame.getRootPane()
+ * (which delivers an instance of this class) and add your components to
+ * that. It is implemented by several 'layers' (pane() should be read as
+ * plane()) each on top of the others where you can add components to.
+ * (getContentPane(), getGlassPane(), getLayeredPane())
+ *
+ * @author Ronald Veldema (rveldema at cs.vu.nl)
+ */
+public class JRootPane extends JComponent implements Accessible
+{
+  //  The class used to obtain the accessible role for this object.
+  protected class AccessibleJRootPane extends AccessibleJComponent
+  {
+    /**
+     * For compatability with Sun's JDK
+     */
+    private static final long serialVersionUID = 1082432482784468088L;
+
+    /**
+     * Creates a new <code>AccessibleJRootPane</code> object.
+     */
+    protected AccessibleJRootPane()
+    {
+      // Nothing to do here.
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @return DOCUMENT ME!
+     */
+    public AccessibleRole getAccessibleRole()
+    {
+      return AccessibleRole.ROOT_PANE;
+    }
+  }
+
+  // Custom Layout Manager for JRootPane. It positions contentPane and 
+  // menuBar withing its layeredPane.
+  protected class RootLayout implements LayoutManager2, Serializable
+  {
+    /** DOCUMENT ME! */
+    private static final long serialVersionUID = -4100116998559815027L;
+
+    /**
+     * The cached layout info for the glass pane.
+     */
+    private Rectangle glassPaneBounds;
+
+    /**
+     * The cached layout info for the layered pane.
+     */
+    private Rectangle layeredPaneBounds;
+
+    /**
+     * The cached layout info for the content pane.
+     */
+    private Rectangle contentPaneBounds;
+
+    /**
+     * The cached layout info for the menu bar.
+     */
+    private Rectangle menuBarBounds;
+
+    /**
+     * Creates a new <code>RootLayout</code> object.
+     */
+    protected RootLayout()
+    {
+      // Nothing to do here. 
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @param comp DOCUMENT ME!
+     * @param constraints DOCUMENT ME!
+     */
+    public void addLayoutComponent(Component comp, Object constraints)
+    {
+      // Nothing to do here.
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @param name DOCUMENT ME!
+     * @param comp DOCUMENT ME!
+     */
+    public void addLayoutComponent(String name, Component comp)
+    {
+      // Nothing to do here.
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @param target DOCUMENT ME!
+     *
+     * @return DOCUMENT ME!
+     */
+    public float getLayoutAlignmentX(Container target)
+    {
+      return 0.0F;
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @param target DOCUMENT ME!
+     *
+     * @return DOCUMENT ME!
+     */
+    public float getLayoutAlignmentY(Container target)
+    {
+      return 0.0F;
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @param target DOCUMENT ME!
+     */
+    public void invalidateLayout(Container target)
+    {
+      synchronized (this)
+        {
+          glassPaneBounds = null;
+          layeredPaneBounds = null;
+          contentPaneBounds = null;
+          menuBarBounds = null;
+        }
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @param c DOCUMENT ME!
+     */
+    public void layoutContainer(Container c)
+    {
+      if (glassPaneBounds == null || layeredPaneBounds == null
+          || contentPaneBounds == null || menuBarBounds == null)
+        {
+          Insets i = getInsets();
+          int containerWidth = c.getBounds().width - i.left - i.right;
+          int containerHeight = c.getBounds().height - i.top - i.bottom;
+
+          // 1. the glassPane fills entire viewable region (bounds - insets).
+          // 2. the layeredPane filles entire viewable region.
+          // 3. the menuBar is positioned at the upper edge of layeredPane.
+          // 4. the contentPane fills viewable region minus menuBar, if present.
+      
+
+          // +-------------------------------+
+          // |  JLayeredPane                 |
+          // |  +--------------------------+ |
+          // |  | menuBar                  | |
+          // |  +--------------------------+ |
+          // |  +--------------------------+ |
+          // |  |contentPane               | |
+          // |  |                          | |
+          // |  |                          | |
+          // |  |                          | |
+          // |  +--------------------------+ |
+          // +-------------------------------+
+
+          if (menuBar != null)
+            {
+              Dimension menuBarSize = menuBar.getPreferredSize();
+              if (menuBarSize.height > containerHeight)
+                menuBarSize.height = containerHeight;
+              menuBarBounds = new Rectangle(0, 0, containerWidth,
+                                            menuBarSize.height);
+              contentPaneBounds = new Rectangle(0, menuBarSize.height,
+                                                containerWidth,
+                                         containerHeight - menuBarSize.height);
+            }
+          else
+            contentPaneBounds = new Rectangle(0, 0, containerWidth,
+                                              containerHeight);
+              
+          glassPaneBounds = new Rectangle(i.left, i.top, containerWidth, containerHeight);
+          layeredPaneBounds = new Rectangle(i.left, i.top, containerWidth, containerHeight);
+        }
+
+      glassPane.setBounds(glassPaneBounds);
+      layeredPane.setBounds(layeredPaneBounds);
+      if (menuBar != null)
+        menuBar.setBounds(menuBarBounds);
+      getContentPane().setBounds(contentPaneBounds);
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @param target DOCUMENT ME!
+     *
+     * @return DOCUMENT ME!
+     */
+    public Dimension maximumLayoutSize(Container target)
+    {
+      return preferredLayoutSize(target);
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @param target DOCUMENT ME!
+     *
+     * @return DOCUMENT ME!
+     */
+    public Dimension minimumLayoutSize(Container target)
+    {
+      return preferredLayoutSize(target);
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @param c DOCUMENT ME!
+     *
+     * @return DOCUMENT ME!
+     */
+    public Dimension preferredLayoutSize(Container c)
+    {
+      Dimension prefSize = new Dimension();
+      Insets i = getInsets();
+      prefSize = new Dimension(i.left + i.right, i.top + i.bottom);
+      Dimension contentPrefSize = getContentPane().getPreferredSize();
+      prefSize.width += contentPrefSize.width;
+      prefSize.height += contentPrefSize.height;
+      if (menuBar != null)
+        {
+          Dimension menuBarSize = menuBar.getPreferredSize();
+          if (menuBarSize.width > contentPrefSize.width)
+            prefSize.width += menuBarSize.width - contentPrefSize.width;
+          prefSize.height += menuBarSize.height;
+        }
+      return prefSize;
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @param comp DOCUMENT ME!
+     */
+    public void removeLayoutComponent(Component comp)
+    {
+      // Nothing to do here.
+    }
+  }
+
+  /** DOCUMENT ME! */
+  private static final long serialVersionUID = 8690748000348575668L;
+
+  public static final int NONE = 0;
+  public static final int FRAME = 1;
+  public static final int PLAIN_DIALOG = 2;
+  public static final int INFORMATION_DIALOG = 3;
+  public static final int ERROR_DIALOG = 4;
+  public static final int COLOR_CHOOSER_DIALOG = 5;
+  public static final int FILE_CHOOSER_DIALOG = 6;
+  public static final int QUESTION_DIALOG = 7;
+  public static final int WARNING_DIALOG = 8;
+          
+  /** DOCUMENT ME! */
+  protected Component glassPane;
+
+  /** DOCUMENT ME! */
+  protected JLayeredPane layeredPane;
+
+  /** DOCUMENT ME! */
+  protected JMenuBar menuBar;
+
+  /** DOCUMENT ME! */
+  protected Container contentPane;
+
+  protected JButton defaultButton;
+
+  /**
+   * This field is unused since JDK1.3. To override the default action you
+   * should modify the JRootPane's ActionMap.
+   *
+   * @deprecated since JDK1.3
+   *
+   * @specnote the specs indicate that the type of this field is
+   *           a package private inner class
+   *           javax.swing.JRootPane.DefaultAction. I assume that the closest
+   *           public superclass is javax.swing.Action.
+   */
+  protected Action defaultPressAction;
+
+  /**
+   * This field is unused since JDK1.3. To override the default action you
+   * should modify the JRootPane's ActionMap.
+   *
+   * @deprecated since JDK1.3
+   *
+   * @specnote the specs indicate that the type of this field is
+   *           a package private inner class
+   *           javax.swing.JRootPane.DefaultAction. I assume that the closest
+   *           public superclass is javax.swing.Action.
+   */
+  protected Action defaultReleaseAction;
+
+  /**
+   * @since 1.4
+   */
+  private int windowDecorationStyle = NONE;
+  
+  /**
+   * DOCUMENT ME!
+   *
+   * @param m DOCUMENT ME!
+   */
+  public void setJMenuBar(JMenuBar m)
+  {
+    JLayeredPane jlPane = getLayeredPane();
+    if (menuBar != null)
+      jlPane.remove(menuBar);
+    menuBar = m;
+    if (menuBar != null)
+      jlPane.add(menuBar, JLayeredPane.FRAME_CONTENT_LAYER);
+  }
+
+  /**
+   * @deprecated Replaced by <code>setJMenuBar()</code>
+   */
+  public void setMenuBar(JMenuBar m)
+  {
+    setJMenuBar(m);
+  }
+
+  /**
+   * DOCUMENT ME!
+   *
+   * @return DOCUMENT ME!
+   */
+  public JMenuBar getJMenuBar()
+  {
+    return menuBar;
+  }
+
+  /**
+   * @deprecated Replaced by <code>getJMenuBar()</code>
+   */
+  public JMenuBar getMenuBar()
+  {
+    return getJMenuBar();
+  }
+
+  /**
+   * DOCUMENT ME!
+   *
+   * @return DOCUMENT ME!
+   */
+  public boolean isValidateRoot()
+  {
+    return true;
+  }
+
+  /**
+   * DOCUMENT ME!
+   *
+   * @return DOCUMENT ME!
+   */
+  public Container getContentPane()
+  {
+    if (contentPane == null)
+      setContentPane(createContentPane());
+    return contentPane;
+  }
+
+  /**
+   * Sets the JRootPane's content pane.  The content pane should typically be
+   * opaque for painting to work properly.  This method also 
+   * removes the old content pane from the layered pane.
+   *
+   * @param p the Container that will be the content pane
+   * @throws IllegalComponentStateException if p is null
+   */
+  public void setContentPane(Container p)
+  {
+    if (p == null)
+      throw new IllegalComponentStateException ("cannot " +
+            "have a null content pane");
+    else
+      {
+        if (contentPane != null && contentPane.getParent() == layeredPane)
+          layeredPane.remove(contentPane);
+        contentPane = p;
+        getLayeredPane().add(contentPane, JLayeredPane.FRAME_CONTENT_LAYER);
+      }
+  }
+
+  /**
+   * DOCUMENT ME!
+   *
+   * @param comp DOCUMENT ME!
+   * @param constraints DOCUMENT ME!
+   * @param index DOCUMENT ME!
+   */
+  protected void addImpl(Component comp, Object constraints, int index)
+  {
+    super.addImpl(comp, constraints, index);
+  }
+
+  /**
+   * DOCUMENT ME!
+   *
+   * @return DOCUMENT ME!
+   */
+  public Component getGlassPane()
+  {
+    if (glassPane == null)
+      setGlassPane(createGlassPane());
+    return glassPane;
+  }
+
+  /**
+   * DOCUMENT ME!
+   *
+   * @param f DOCUMENT ME!
+   */
+  public void setGlassPane(Component f)
+  {
+    if (glassPane != null)
+      remove(glassPane);
+
+    glassPane = f;
+
+    glassPane.setVisible(false);
+    add(glassPane, 0);
+  }
+
+  /**
+   * DOCUMENT ME!
+   *
+   * @return DOCUMENT ME!
+   */
+  public JLayeredPane getLayeredPane()
+  {
+    if (layeredPane == null)
+      setLayeredPane(createLayeredPane());
+    return layeredPane;
+  }
+
+  /**
+   * DOCUMENT ME!
+   *
+   * @param f DOCUMENT ME!
+   */
+  public void setLayeredPane(JLayeredPane f)
+  {
+    if (layeredPane != null)
+      remove(layeredPane);
+
+    layeredPane = f;
+    add(f, -1);
+  }
+
+  /**
+   * Creates a new <code>JRootPane</code> object.
+   */
+  public JRootPane()
+  {
+    setLayout(createRootLayout());
+    getGlassPane();
+    getLayeredPane();
+    getContentPane();
+    setOpaque(true);
+    updateUI();
+  }
+
+  /**
+   * DOCUMENT ME!
+   *
+   * @return DOCUMENT ME!
+   */
+  protected LayoutManager createRootLayout()
+  {
+    return new RootLayout();
+  }
+
+  /**
+   * DOCUMENT ME!
+   *
+   * @return DOCUMENT ME!
+   */
+  protected Container createContentPane()
+  {
+    JPanel p = new JPanel();
+    p.setName(this.getName() + ".contentPane");
+    p.setLayout(new BorderLayout());
+    return p;
+  }
+
+  /**
+   * DOCUMENT ME!
+   *
+   * @return DOCUMENT ME!
+   */
+  protected Component createGlassPane()
+  {
+    JPanel p = new JPanel();
+    p.setName(this.getName() + ".glassPane");
+    p.setVisible(false);
+    p.setOpaque(false);
+    return p;
+  }
+
+  /**
+   * DOCUMENT ME!
+   *
+   * @return DOCUMENT ME!
+   */
+  protected JLayeredPane createLayeredPane()
+  {
+    JLayeredPane l = new JLayeredPane();
+    l.setLayout(null);
+    return l;
+  }
+
+  /**
+   * DOCUMENT ME!
+   *
+   * @return DOCUMENT ME!
+   */
+  public RootPaneUI getUI()
+  {
+    return (RootPaneUI) ui;
+  }
+
+  /**
+   * DOCUMENT ME!
+   *
+   * @param ui DOCUMENT ME!
+   */
+  public void setUI(RootPaneUI ui)
+  {
+    super.setUI(ui);
+  }
+
+  /**
+   * DOCUMENT ME!
+   */
+  public void updateUI()
+  {
+    setUI((RootPaneUI) UIManager.getUI(this));
+  }
+
+  /**
+   * DOCUMENT ME!
+   *
+   * @return DOCUMENT ME!
+   */
+  public String getUIClassID()
+  {
+    return "RootPaneUI";
+  }
+
+  public JButton getDefaultButton()
+  {
+    return defaultButton;
+  }
+  
+  public void setDefaultButton(JButton newButton)
+  {
+    // We only change the default button if the new button is defaultCapable
+    // or null and the old and new button are different objects.
+    if (defaultButton != newButton
+        && (newButton == null || newButton.isDefaultCapable()))
+      {
+        JButton oldButton = defaultButton;
+        defaultButton = newButton;
+        firePropertyChange("defaultButton", oldButton, newButton);
+      }
+  }
+
+  /**
+   * @since 1.4
+   */
+  public int getWindowDecorationStyle()
+  {
+    return windowDecorationStyle;
+  }
+
+  /**
+   * @since 1.4
+   */
+  public void setWindowDecorationStyle(int style)
+  {
+    if (style != NONE
+        && style != FRAME
+        && style != INFORMATION_DIALOG
+        && style != ERROR_DIALOG
+        && style != COLOR_CHOOSER_DIALOG
+        && style != FILE_CHOOSER_DIALOG
+        && style != QUESTION_DIALOG
+        && style != WARNING_DIALOG
+        && style != PLAIN_DIALOG)
+      throw new IllegalArgumentException("invalid style");
+    
+    int oldStyle = windowDecorationStyle;
+    windowDecorationStyle = style;
+    firePropertyChange("windowDecorationStyle", oldStyle, style);
+  }
+
+  /**
+   * This returns <code>true</code> if the <code>glassPane</code> is not
+   * visible because then the root pane can guarantee to tile its children
+   * (the only other direct child is a JLayeredPane which must figure its
+   * <code>optimizeDrawingEnabled</code> state on its own).
+   *
+   * @return <code>true</code> if the <code>glassPane</code> is not
+   *         visible
+   */
+  public boolean isOptimizedDrawingEnable()
+  {
+    return ! glassPane.isVisible();
+  }
+
+  /**
+   * Returns the accessible context for this JRootPane. This will be
+   * an instance of {@link AccessibleJRootPane}.
+   *
+   * @return the accessible context for this JRootPane
+   */
+  public AccessibleContext getAccessibleContext()
+  {
+    if (accessibleContext == null)
+      accessibleContext = new AccessibleJRootPane();
+    return accessibleContext;
+  }
+}

Added: llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JScrollBar.java
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JScrollBar.java?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JScrollBar.java (added)
+++ llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JScrollBar.java Thu Nov  8 16:56:19 2007
@@ -0,0 +1,679 @@
+/* JScrollBar.java --
+   Copyright (C) 2002, 2004, 2005, 2006,  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;
+
+import java.awt.Adjustable;
+import java.awt.Dimension;
+import java.awt.event.AdjustmentEvent;
+import java.awt.event.AdjustmentListener;
+import java.beans.PropertyChangeEvent;
+
+import javax.accessibility.Accessible;
+import javax.accessibility.AccessibleContext;
+import javax.accessibility.AccessibleRole;
+import javax.accessibility.AccessibleState;
+import javax.accessibility.AccessibleStateSet;
+import javax.accessibility.AccessibleValue;
+import javax.swing.plaf.ScrollBarUI;
+
+/**
+ * The JScrollBar. Two buttons control how the values that the 
+ * scroll bar can take. You can also drag the thumb or click the track
+ * to move the scroll bar. Typically, the JScrollBar is used with
+ * other components to translate the value of the bar to the viewable
+ * contents of the other components.
+ */
+public class JScrollBar extends JComponent implements Adjustable, Accessible
+{
+  /**
+   * Provides the accessibility features for the <code>JScrollBar</code>
+   * component.
+   */
+  protected class AccessibleJScrollBar extends JComponent.AccessibleJComponent
+    implements AccessibleValue
+  {
+    private static final long serialVersionUID = -7758162392045586663L;
+    
+    /**
+     * Creates a new <code>AccessibleJScrollBar</code> instance.
+     */
+    protected AccessibleJScrollBar()
+    {
+      super();
+    }
+
+    /**
+     * Returns a set containing the current state of the {@link JScrollBar} 
+     * component.
+     *
+     * @return The accessible state set.
+     */
+    public AccessibleStateSet getAccessibleStateSet()
+    {
+      AccessibleStateSet result = super.getAccessibleStateSet();
+      if (orientation == JScrollBar.HORIZONTAL)
+        result.add(AccessibleState.HORIZONTAL);
+      else if (orientation == JScrollBar.VERTICAL)
+        result.add(AccessibleState.VERTICAL);
+      return result;
+    }
+
+    /**
+     * Returns the accessible role for the <code>JScrollBar</code> component.
+     *
+     * @return {@link AccessibleRole#SCROLL_BAR}.
+     */
+    public AccessibleRole getAccessibleRole()
+    {
+      return AccessibleRole.SCROLL_BAR;
+    }
+
+    /**
+     * Returns an object that provides access to the current, minimum and 
+     * maximum values.
+     *
+     * @return The accessible value.
+     */
+    public AccessibleValue getAccessibleValue()
+    {
+      return this;
+    }
+
+    /**
+     * Returns the current value of the {@link JScrollBar} component, as an
+     * {@link Integer}.
+     *
+     * @return The current value of the {@link JScrollBar} component.
+     */
+    public Number getCurrentAccessibleValue()
+    {
+      return new Integer(getValue());
+    }
+
+    /**
+     * Sets the current value of the {@link JScrollBar} component and sends a
+     * {@link PropertyChangeEvent} (with the property name 
+     * {@link AccessibleContext#ACCESSIBLE_VALUE_PROPERTY}) to all registered
+     * listeners.  If the supplied value is <code>null</code>, this method 
+     * does nothing and returns <code>false</code>.
+     *
+     * @param value  the new slider value (<code>null</code> permitted).
+     *
+     * @return <code>true</code> if the slider value is updated, and 
+     *     <code>false</code> otherwise.
+     */
+    public boolean setCurrentAccessibleValue(Number value)
+    {
+      if (value == null)
+        return false;
+      Number oldValue = getCurrentAccessibleValue();
+      setValue(value.intValue());
+      firePropertyChange(AccessibleContext.ACCESSIBLE_VALUE_PROPERTY, oldValue, 
+                         new Integer(getValue()));
+      return true;
+    }
+
+    /**
+     * Returns the minimum value of the {@link JScrollBar} component, as an
+     * {@link Integer}.
+     *
+     * @return The minimum value of the {@link JScrollBar} component.
+     */
+    public Number getMinimumAccessibleValue()
+    {
+      return new Integer(getMinimum());
+    }
+
+    /**
+     * Returns the maximum value of the {@link JScrollBar} component, as an
+     * {@link Integer}.
+     *
+     * @return The maximum value of the {@link JScrollBar} component.
+     */
+    public Number getMaximumAccessibleValue()
+    {
+      return new Integer(getMaximum() - model.getExtent());
+    }
+  }
+
+  private static final long serialVersionUID = -8195169869225066566L;
+  
+  /** How much the thumb moves when moving in a block. */
+  protected int blockIncrement = 10;
+
+  /** The model that holds the scroll bar's data. */
+  protected BoundedRangeModel model;
+
+  /** The orientation of the scroll bar. */
+  protected int orientation = SwingConstants.VERTICAL;
+
+  /** How much the thumb moves when moving in a unit. */
+  protected int unitIncrement = 1;
+
+  /** 
+   * Creates a new horizontal JScrollBar object with a minimum
+   * of 0, a maxmium of 100, a value of 0 and an extent of 10.
+   */
+  public JScrollBar()
+  {
+    this(SwingConstants.VERTICAL, 0, 10, 0, 100);
+  }
+
+  /**
+   * Creates a new JScrollBar object with a minimum of 0, a 
+   * maximum of 100, a value of 0, an extent of 10 and the given
+   * orientation.
+   *
+   * @param orientation The orientation of the JScrollBar.
+   */
+  public JScrollBar(int orientation)
+  {
+    this(orientation, 0, 10, 0, 100);
+  }
+
+  /**
+   * Creates a new JScrollBar object with the given orientation, 
+   * value, min, max, and extent.
+   *
+   * @param orientation The orientation to use.
+   * @param value The value to use.
+   * @param extent The extent to use.
+   * @param min The minimum value of the scrollbar.
+   * @param max The maximum value of the scrollbar.
+   */
+  public JScrollBar(int orientation, int value, int extent, int min, int max)
+  {
+    model = new DefaultBoundedRangeModel(value, extent, min, max);
+    if (orientation != SwingConstants.HORIZONTAL
+        && orientation != SwingConstants.VERTICAL)
+      throw new IllegalArgumentException(orientation
+                                         + " is not a legal orientation");
+    this.orientation = orientation;
+    updateUI();
+  }
+
+  /**
+   * This method sets the UI of this scrollbar to
+   * the given UI.
+   *
+   * @param ui The UI to use with this scrollbar.
+   */
+  public void setUI(ScrollBarUI ui)
+  {
+    super.setUI(ui);
+  }
+
+  /**
+   * This method returns the UI that is being used
+   * with this scrollbar.
+   *
+   * @return The scrollbar's current UI.
+   */
+  public ScrollBarUI getUI()
+  {
+    return (ScrollBarUI) ui;
+  }
+
+  /**
+   * This method changes the UI to be the
+   * default for the current look and feel.
+   */
+  public void updateUI()
+  {
+    setUI((ScrollBarUI) UIManager.getUI(this));
+  }
+
+  /**
+   * This method returns an identifier to 
+   * choose the correct UI delegate for the
+   * scrollbar.
+   *
+   * @return The identifer to choose the UI delegate; "ScrollBarUI"
+   */
+  public String getUIClassID()
+  {
+    return "ScrollBarUI";
+  }
+
+  /**
+   * This method returns the orientation of the scrollbar.
+   *
+   * @return The orientation of the scrollbar.
+   */
+  public int getOrientation()
+  {
+    return orientation;
+  }
+
+  /**
+   * This method sets the orientation of the scrollbar.
+   *
+   * @param orientation The orientation of the scrollbar.
+   */
+  public void setOrientation(int orientation)
+  {
+    if (orientation != SwingConstants.HORIZONTAL
+        && orientation != SwingConstants.VERTICAL)
+      throw new IllegalArgumentException("orientation must be one of HORIZONTAL or VERTICAL");
+    if (orientation != this.orientation)
+      {
+	int oldOrientation = this.orientation;
+	this.orientation = orientation;
+	firePropertyChange("orientation", oldOrientation,
+	                   this.orientation);
+      }
+  }
+
+  /**
+   * This method returns the model being used with 
+   * the scrollbar.
+   *
+   * @return The scrollbar's model.
+   */
+  public BoundedRangeModel getModel()
+  {
+    return model;
+  }
+
+  /**
+   * This method sets the model to use with
+   * the scrollbar.
+   *
+   * @param newModel The new model to use with the scrollbar.
+   */
+  public void setModel(BoundedRangeModel newModel)
+  {
+    if (model != newModel)
+      {
+	BoundedRangeModel oldModel = model;
+	model = newModel;
+	firePropertyChange("model", oldModel, model);
+      }
+  }
+
+  /**
+   * This method returns how much the scrollbar's value
+   * should change for a unit increment depending on the 
+   * given direction.
+   *
+   * @param direction The direction to scroll in.
+   *
+   * @return The amount the scrollbar's value will change given the direction.
+   */
+  public int getUnitIncrement(int direction)
+  {
+    return direction * unitIncrement;
+  }
+
+  /**
+   * This method sets the unitIncrement property.
+   *
+   * @param unitIncrement The new unitIncrement.
+   */
+  public void setUnitIncrement(int unitIncrement)
+  {
+    if (unitIncrement != this.unitIncrement)
+      {
+	int oldInc = this.unitIncrement;
+	this.unitIncrement = unitIncrement;
+	firePropertyChange("unitIncrement", oldInc,
+	                   this.unitIncrement);
+      }
+  }
+
+  /**
+   * The method returns how much the scrollbar's value
+   * should change for a block increment depending on
+   * the given direction.
+   *
+   * @param direction The direction to scroll in.
+   *
+   * @return The amount the scrollbar's value will change given the direction.
+   */
+  public int getBlockIncrement(int direction)
+  {
+    return direction * blockIncrement;
+  }
+
+  /**
+   * This method sets the blockIncrement property.
+   *
+   * @param blockIncrement The new blockIncrement.
+   */
+  public void setBlockIncrement(int blockIncrement)
+  {
+    if (blockIncrement != this.blockIncrement)
+      {
+	int oldInc = this.blockIncrement;
+	this.blockIncrement = blockIncrement;
+	firePropertyChange("blockIncrement", oldInc,
+	                   this.blockIncrement);
+      }
+  }
+
+  /**
+   * This method returns the unitIncrement.
+   *
+   * @return The unitIncrement.
+   */
+  public int getUnitIncrement()
+  {
+    return unitIncrement;
+  }
+
+  /**
+   * This method returns the blockIncrement.
+   *
+   * @return The blockIncrement.
+   */
+  public int getBlockIncrement()
+  {
+    return blockIncrement;
+  }
+
+  /**
+   * This method returns the value of the scrollbar.
+   *
+   * @return The value of the scrollbar.
+   */
+  public int getValue()
+  {
+    return model.getValue();
+  }
+
+  /**
+   * This method changes the value of the scrollbar.
+   *
+   * @param value The new value of the scrollbar.
+   */
+  public void setValue(int value)
+  {
+    if (isEnabled() && value != getValue())
+    {
+      model.setValue(value);
+      fireAdjustmentValueChanged(AdjustmentEvent.ADJUSTMENT_VALUE_CHANGED,
+                                 AdjustmentEvent.TRACK, value);
+    }
+  }
+
+  /**
+   * This method returns the visible amount (AKA extent). 
+   * The visible amount can be used by UI delegates to 
+   * determine the size of the thumb.
+   *
+   * @return The visible amount (AKA extent).
+   */
+  public int getVisibleAmount()
+  {
+    return model.getExtent();
+  }
+
+  /**
+   * This method sets the visible amount (AKA extent).
+   *
+   * @param extent The visible amount (AKA extent).
+   */
+  public void setVisibleAmount(int extent)
+  {
+    if (extent != getVisibleAmount())
+    {
+      model.setExtent(extent);
+      fireAdjustmentValueChanged(AdjustmentEvent.ADJUSTMENT_VALUE_CHANGED,
+                                 AdjustmentEvent.TRACK, extent);
+    }
+  }
+
+  /**
+   * This method returns the minimum value of the scrollbar.
+   *
+   * @return The minimum value of the scrollbar.
+   */
+  public int getMinimum()
+  {
+    return model.getMinimum();
+  }
+
+  /**
+   * This method sets the minimum value of the scrollbar.
+   *
+   * @param minimum The minimum value of the scrollbar.
+   */
+  public void setMinimum(int minimum)
+  {
+    if (minimum != getMinimum())
+    {
+      model.setMinimum(minimum);
+      fireAdjustmentValueChanged(AdjustmentEvent.ADJUSTMENT_VALUE_CHANGED,
+                                 AdjustmentEvent.TRACK, minimum);
+    }
+  }
+
+  /**
+   * This method returns the maximum value of the scrollbar.
+   *
+   * @return The maximum value of the scrollbar.
+   */
+  public int getMaximum()
+  {
+    return model.getMaximum();
+  }
+
+  /**
+   * This method sets the maximum value of the scrollbar.
+   *
+   * @param maximum The maximum value of the scrollbar.
+   */
+  public void setMaximum(int maximum)
+  {
+    if (maximum != getMaximum())
+    {
+      model.setMaximum(maximum);
+      fireAdjustmentValueChanged(AdjustmentEvent.ADJUSTMENT_VALUE_CHANGED,
+                                 AdjustmentEvent.TRACK, maximum);
+    }
+  }
+
+  /**
+   * This method returns the model's isAjusting value.
+   *
+   * @return The model's isAdjusting value.
+   */
+  public boolean getValueIsAdjusting()
+  {
+    return model.getValueIsAdjusting();
+  }
+
+  /**
+   * This method sets the model's isAdjusting value.
+   *
+   * @param b The new isAdjusting value.
+   */
+  public void setValueIsAdjusting(boolean b)
+  {
+    model.setValueIsAdjusting(b);
+  }
+
+  /**
+   * This method sets the value, extent, minimum and 
+   * maximum.
+   *
+   * @param newValue The new value.
+   * @param newExtent The new extent.
+   * @param newMin The new minimum.
+   * @param newMax The new maximum.
+   */
+  public void setValues(int newValue, int newExtent, int newMin, int newMax)
+  {
+    if (!isEnabled())
+      newValue = model.getValue();
+    // It seems to be that on any change the value is fired.
+    if (newValue != getValue() || newExtent != getVisibleAmount() ||
+        newMin != getMinimum() || newMax != getMaximum())
+    {
+      model.setRangeProperties(newValue, newExtent, newMin, newMax,
+                               model.getValueIsAdjusting());
+      fireAdjustmentValueChanged(AdjustmentEvent.ADJUSTMENT_VALUE_CHANGED,
+                                 AdjustmentEvent.TRACK, newValue);
+    }
+  }
+
+  /**
+   * This method adds an AdjustmentListener to the scroll bar.
+   *
+   * @param listener The listener to add.
+   */
+  public void addAdjustmentListener(AdjustmentListener listener)
+  {
+    listenerList.add(AdjustmentListener.class, listener);
+  }
+
+  /**
+   * This method removes an AdjustmentListener from the scroll bar. 
+   *
+   * @param listener The listener to remove.
+   */
+  public void removeAdjustmentListener(AdjustmentListener listener)
+  {
+    listenerList.remove(AdjustmentListener.class, listener);
+  }
+
+  /**
+   * This method returns an arry of all AdjustmentListeners listening to 
+   * this scroll bar.
+   *
+   * @return An array of AdjustmentListeners listening to this scroll bar.
+   */
+  public AdjustmentListener[] getAdjustmentListeners()
+  {
+    return (AdjustmentListener[]) listenerList.getListeners(AdjustmentListener.class);
+  }
+
+  /**
+   * This method is called to fired AdjustmentEvents to the listeners
+   * of this scroll bar. All AdjustmentEvents that are fired
+   * will have an ID of ADJUSTMENT_VALUE_CHANGED and a type of
+   * TRACK. 
+   *
+   * @param id The ID of the adjustment event.
+   * @param type The Type of change.
+   * @param value The new value for the property that was changed..
+   */
+  protected void fireAdjustmentValueChanged(int id, int type, int value)
+  {
+    Object[] adjustmentListeners = listenerList.getListenerList();
+    AdjustmentEvent adjustmentEvent = new AdjustmentEvent(this, 
+                                            AdjustmentEvent.ADJUSTMENT_VALUE_CHANGED,
+					    AdjustmentEvent.TRACK,
+					    value);
+    for (int i = adjustmentListeners.length - 2; i >= 0; i -= 2)
+      {
+	if (adjustmentListeners[i] == AdjustmentListener.class)
+	  ((AdjustmentListener) adjustmentListeners[i + 1]).adjustmentValueChanged(adjustmentEvent);
+      }
+  }
+
+  /**
+   * This method returns the minimum size for this scroll bar.
+   *
+   * @return The minimum size.
+   */
+  public Dimension getMinimumSize()
+  {
+    return ui.getMinimumSize(this);
+  }
+
+  /**
+   * This method returns the maximum size for this scroll bar.
+   *
+   * @return The maximum size.
+   */
+  public Dimension getMaximumSize()
+  {
+    return ui.getMaximumSize(this);
+  }
+
+  /**
+   * This method overrides the setEnabled in JComponent.
+   * When the scroll bar is disabled, the knob cannot
+   * be moved.
+   *
+   * @param x Whether the scrollbar is enabled.
+   */
+  public void setEnabled(boolean x)
+  {
+    // nothing special needs to be done here since we 
+    // just check the enabled setting before changing the value.
+    super.setEnabled(x);
+  }
+
+  /**
+   * Returns a string describing the attributes for the <code>JScrollBar</code>
+   * component, for use in debugging.  The return value is guaranteed to be 
+   * non-<code>null</code>, but the format of the string may vary between
+   * implementations.
+   *
+   * @return A string describing the attributes of the <code>JScrollBar</code>.
+   */
+  protected String paramString()
+  {
+    StringBuffer sb = new StringBuffer(super.paramString());
+    sb.append(",blockIncrement=").append(blockIncrement);
+    sb.append(",orientation=");
+    if (this.orientation == JScrollBar.HORIZONTAL)
+      sb.append("HORIZONTAL");
+    else 
+      sb.append("VERTICAL");
+    sb.append(",unitIncrement=").append(unitIncrement);
+    return sb.toString();
+  }
+
+  /**
+   * Returns the object that provides accessibility features for this
+   * <code>JScrollBar</code> component.
+   *
+   * @return The accessible context (an instance of 
+   *     {@link AccessibleJScrollBar}).
+   */
+  public AccessibleContext getAccessibleContext()
+  {
+    if (accessibleContext == null)
+      accessibleContext = new AccessibleJScrollBar();
+    return accessibleContext;
+  }
+}

Added: llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JScrollPane.java
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JScrollPane.java?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JScrollPane.java (added)
+++ llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JScrollPane.java Thu Nov  8 16:56:19 2007
@@ -0,0 +1,710 @@
+/* JScrollPane.java -- 
+   Copyright (C) 2002, 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;
+
+import java.awt.Component;
+import java.awt.ComponentOrientation;
+import java.awt.Insets;
+import java.awt.LayoutManager;
+import java.awt.Rectangle;
+import java.beans.PropertyChangeEvent;
+import java.beans.PropertyChangeListener;
+
+import javax.accessibility.Accessible;
+import javax.accessibility.AccessibleContext;
+import javax.swing.border.Border;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;
+import javax.swing.plaf.ScrollPaneUI;
+import javax.swing.plaf.UIResource;
+
+/**
+ * A component that embeds another component and enables it to be scrolled
+ * both in horizontal and vertical direction.
+ *
+ * <table>
+ * <tr><th>Property                    </th><th>Stored in       </th><th>Bound?</th></tr>
+ * <tr><td>columnHeader                </td><td>scrollPane      </td><td>yes   </td></tr>
+ * <tr><td>columnHeaderView            </td><td>columnHeader    </td><td>no    </td></tr>
+ * <tr><td>componentOrientation        </td><td>scrollPane      </td><td>yes   </td></tr>
+ * <tr><td>horizontalScrollBar         </td><td>scrollPane      </td><td>yes   </td></tr>
+ * <tr><td>horizontalScrollBarPolicy   </td><td>scrollPane      </td><td>yes   </td></tr>
+ * <tr><td>layout                      </td><td>scrollPane      </td><td>yes   </td></tr>
+ * <tr><td>rowHeader                   </td><td>scrollPane      </td><td>yes   </td></tr>
+ * <tr><td>rowHeaderView               </td><td>rowHeader       </td><td>no    </td></tr>
+ * <tr><td>validateRoot                </td><td>scrollPane      </td><td>no    </td></tr>
+ * <tr><td>verticalScrollBar           </td><td>scrollPane      </td><td>yes   </td></tr>
+ * <tr><td>verticalScrollBarPolicy     </td><td>scrollPane      </td><td>yes   </td></tr>
+ * <tr><td>viewport                    </td><td>scrollPane      </td><td>yes   </td></tr>
+ * <tr><td>viewportBorder              </td><td>scrollPane      </td><td>yes   </td></tr>
+ * <tr><td>viewportBorderBounds        </td><td>scrollPane      </td><td>no    </td></tr>
+ * <tr><td>viewportView                </td><td>viewport        </td><td>no    </td></tr>
+ * <tr><td>wheelScrollingEnabled       </td><td>scrollPane      </td><td>yes   </td></tr>
+ * </table>
+ */
+public class JScrollPane extends JComponent
+  implements Accessible, ScrollPaneConstants
+{
+  /**
+   * Provides accessibility support for the <code>JScrollPane</code>.
+   *
+   * @author Roman Kennke (kennke at aicas.com)
+   */
+  protected class AccessibleJScrollPane extends AccessibleJComponent
+    implements ChangeListener, PropertyChangeListener
+  {
+
+    /**
+     * The viewport of the underlying scrollpane.
+     */
+    protected JViewport viewPort;
+
+    /**
+     * Creates a new <code>AccessibleJScrollPane</code> object. This
+     * initializes the <code>viewport</code> field with the current viewport
+     * from the scrollpane associated with this
+     * <code>AccessibleJScrollPane</code>.
+     */
+    public AccessibleJScrollPane()
+    {
+      viewPort = getViewport();
+      viewPort.addChangeListener(this);
+      viewPort.addPropertyChangeListener(this);
+    }
+
+    /**
+     * Receives notification when the state of the viewport changes.
+     *
+     * @param event the change event
+     */
+    public void stateChanged(ChangeEvent event)
+    {
+      // TODO: Figure out what should be done here, if anything.
+    }
+
+    /**
+     * Receives notification if any of the viewport's bound properties changes.
+     *
+     * @param e the propery change event
+     */
+    public void propertyChange(PropertyChangeEvent e)
+    {
+      // TODO: Figure out what should be done here, if anything.
+    }
+
+    /**
+     * Resets the <code>viewPort</code> field when the scrollpane's viewport
+     * changes. This method is called by
+     * {@link JScrollPane#setViewport(JViewport)} in order to update the
+     * <code>viewPort</code> field and set up the listeners on this viewport
+     * correctly.
+     */
+    public void resetViewPort()
+    {
+      viewPort.removeChangeListener(this);
+      viewPort.removePropertyChangeListener(this);
+      viewPort = getViewport();
+      viewPort.addChangeListener(this);
+      viewPort.addPropertyChangeListener(this);
+    }
+  }
+
+  private static final long serialVersionUID = 5203525440012340014L;
+  
+  protected JViewport columnHeader;
+  protected JViewport rowHeader;
+
+  protected Component lowerLeft;
+  protected Component lowerRight;
+  protected Component upperLeft;
+  protected Component upperRight;
+
+  protected JScrollBar horizontalScrollBar;
+  protected int horizontalScrollBarPolicy;
+  protected JScrollBar verticalScrollBar;
+  protected int verticalScrollBarPolicy;
+
+  protected JViewport viewport;
+  
+  Border viewportBorder;
+  boolean wheelScrollingEnabled;
+
+  public JViewport getColumnHeader()
+  {
+    return columnHeader;
+  }
+
+  public Component getCorner(String key) 
+  {
+    if (getComponentOrientation() 
+        == ComponentOrientation.LEFT_TO_RIGHT)
+      {
+        if (key == LOWER_LEADING_CORNER)
+          key = LOWER_LEFT_CORNER;
+        else if (key == LOWER_TRAILING_CORNER)
+          key = LOWER_RIGHT_CORNER;
+        else if (key == UPPER_LEADING_CORNER)
+          key = UPPER_LEFT_CORNER;
+        else if (key == UPPER_TRAILING_CORNER)
+          key = UPPER_RIGHT_CORNER;
+      }
+    else if (getComponentOrientation() 
+             == ComponentOrientation.RIGHT_TO_LEFT)
+      {
+        if (key == LOWER_LEADING_CORNER)
+          key = LOWER_RIGHT_CORNER;
+        else if (key == LOWER_TRAILING_CORNER)
+          key = LOWER_LEFT_CORNER;
+        else if (key == UPPER_LEADING_CORNER)
+          key = UPPER_RIGHT_CORNER;
+        else if (key == UPPER_TRAILING_CORNER)
+          key = UPPER_LEFT_CORNER;
+      }
+
+    if (key == LOWER_RIGHT_CORNER)
+      return lowerRight;
+    else if (key == UPPER_RIGHT_CORNER)
+      return upperRight;
+    else if (key == LOWER_LEFT_CORNER)
+      return lowerLeft;
+    else if (key == UPPER_LEFT_CORNER)
+      return upperLeft;
+    return null;
+  }
+
+  public JScrollBar getHorizontalScrollBar()
+  {
+    return horizontalScrollBar;
+  }
+
+  public int getHorizontalScrollBarPolicy()
+  {
+    return horizontalScrollBarPolicy;
+  }
+
+  public JViewport getRowHeader()
+  {
+    return rowHeader;
+  }
+
+  public JScrollBar getVerticalScrollBar()
+  {
+    return verticalScrollBar;
+  }
+
+  public int getVerticalScrollBarPolicy()
+  {
+    return verticalScrollBarPolicy;
+  }
+
+  public JViewport getViewport()
+  {
+    return viewport;
+  }
+
+  public Border getViewportBorder()
+  {
+    return viewportBorder;
+  }
+
+  public Rectangle getViewportBorderBounds()
+  {
+    if (viewportBorder == null)
+      {
+        if (getViewport() == null)
+          return new Rectangle(0, 0, 0, 0);
+        else
+          return getViewport().getBounds();
+      }
+    else
+      {
+        Insets i = viewportBorder.getBorderInsets(getViewport());
+        if (getViewport() == null)
+          return new Rectangle(0, 0, i.left + i.right, i.top + i.bottom);
+        else
+          {
+            Rectangle b = getViewport().getBounds();
+            return new Rectangle(b.x - i.left, 
+                                 b.y - i.top,
+                                 b.width + i.left + i.right, 
+                                 b.height + i.top + i.bottom);
+          }
+      }
+  }
+  
+  public boolean isWheelScrollingEnabled()
+  {
+    return wheelScrollingEnabled;
+  }
+
+
+
+  private void sync()
+  {
+    LayoutManager m = super.getLayout();
+    if (m != null && m instanceof ScrollPaneLayout)
+      {
+        ScrollPaneLayout sl = (ScrollPaneLayout) m;
+        sl.syncWithScrollPane(this);
+      }
+  }
+
+  private void removeNonNull(Component c)
+  {
+    if (c != null)
+      remove(c);
+  }
+
+  private void addNonNull(Component c, Object constraints)
+  {
+    if (c != null)
+      add(c, constraints);
+  }
+
+  public void setComponentOrientation(ComponentOrientation co)
+  {
+    ComponentOrientation old = super.getComponentOrientation();
+    super.setComponentOrientation(co);
+    firePropertyChange("componentOrientation", old, co);
+    sync();
+  }
+
+  public void setColumnHeader(JViewport h)
+  {
+    if (columnHeader == h)
+      return;
+    
+    JViewport old = columnHeader;
+    removeNonNull(old);
+    columnHeader = h;
+    addNonNull(h, JScrollPane.COLUMN_HEADER);
+    firePropertyChange("columnHeader", old, h);
+    sync();
+  }
+
+  public void setColumnHeaderView(Component c)
+  {
+    if (columnHeader == null)
+      setColumnHeader(createViewport());
+    columnHeader.setView(c);
+    sync();
+  }
+
+  public void setCorner(String key, Component c)
+  {
+    if (getComponentOrientation() 
+        == ComponentOrientation.LEFT_TO_RIGHT)
+      {
+        if (key == LOWER_LEADING_CORNER)
+          key = LOWER_LEFT_CORNER;
+        else if (key == LOWER_TRAILING_CORNER)
+          key = LOWER_RIGHT_CORNER;
+        else if (key == UPPER_LEADING_CORNER)
+          key = UPPER_LEFT_CORNER;
+        else if (key == UPPER_TRAILING_CORNER)
+          key = UPPER_RIGHT_CORNER;
+      }
+    else if (getComponentOrientation() 
+             == ComponentOrientation.RIGHT_TO_LEFT)
+      {
+        if (key == LOWER_LEADING_CORNER)
+          key = LOWER_RIGHT_CORNER;
+        else if (key == LOWER_TRAILING_CORNER)
+          key = LOWER_LEFT_CORNER;
+        else if (key == UPPER_LEADING_CORNER)
+          key = UPPER_RIGHT_CORNER;
+        else if (key == UPPER_TRAILING_CORNER)
+          key = UPPER_LEFT_CORNER;
+      }
+
+    if (key == LOWER_RIGHT_CORNER)
+      {
+        removeNonNull(lowerRight);
+        lowerRight = c;
+        addNonNull(c, JScrollPane.LOWER_RIGHT_CORNER);
+      }
+    else if (key == UPPER_RIGHT_CORNER)
+      {
+        removeNonNull(upperRight);
+        upperRight = c;
+        addNonNull(c, JScrollPane.UPPER_RIGHT_CORNER);
+      }
+    else if (key == LOWER_LEFT_CORNER)
+      {
+        removeNonNull(lowerLeft);
+        lowerLeft = c;
+        addNonNull(c, JScrollPane.LOWER_LEFT_CORNER);
+      }
+    else if (key == UPPER_LEFT_CORNER)
+      {
+        removeNonNull(upperLeft);
+        upperLeft = c;
+        addNonNull(c, JScrollPane.UPPER_LEFT_CORNER);
+      }
+    else
+      throw new IllegalArgumentException("unknown corner " + key);
+    sync();
+  }
+
+  public void setHorizontalScrollBar(JScrollBar h)
+  {
+    if (horizontalScrollBar == h)
+      return;
+
+    JScrollBar old = horizontalScrollBar;
+    removeNonNull(old);
+    horizontalScrollBar = h;
+    addNonNull(h, JScrollPane.HORIZONTAL_SCROLLBAR);
+    firePropertyChange("horizontalScrollBar", old, h);
+    sync();
+
+  }
+
+  public void setHorizontalScrollBarPolicy(int h)
+  {
+    if (horizontalScrollBarPolicy == h)
+      return;
+    
+    if (h != HORIZONTAL_SCROLLBAR_AS_NEEDED
+        && h != HORIZONTAL_SCROLLBAR_NEVER
+        && h != HORIZONTAL_SCROLLBAR_ALWAYS)
+      throw new IllegalArgumentException("unknown horizontal scrollbar policy");    
+
+    int old = horizontalScrollBarPolicy;
+    horizontalScrollBarPolicy = h;
+    firePropertyChange("horizontalScrollBarPolicy", old, h);
+    sync();
+    revalidate();
+  }
+
+  public void setLayout(LayoutManager l)
+  {
+    LayoutManager old = super.getLayout();
+    ScrollPaneLayout tmp = (ScrollPaneLayout) l;
+    super.setLayout(l);
+    tmp.syncWithScrollPane(this);
+    firePropertyChange("layout", old, l);
+    sync();
+  }
+
+  public void setRowHeader(JViewport v)
+  {
+    if (rowHeader == v)
+      return;
+    
+    JViewport old = rowHeader;
+    removeNonNull(old);
+    rowHeader = v;
+    addNonNull(v, JScrollPane.ROW_HEADER);
+    firePropertyChange("rowHeader", old, v);
+    sync();
+  }
+
+  public void setRowHeaderView(Component c)
+  {
+    if (rowHeader == null)
+      setRowHeader(createViewport());
+    rowHeader.setView(c);
+    sync();
+  }
+
+  public void setVerticalScrollBar(JScrollBar v)
+  {
+    if (verticalScrollBar == v)
+      return;
+    
+    JScrollBar old = verticalScrollBar;
+    removeNonNull(old);
+    verticalScrollBar = v;
+    addNonNull(v, JScrollPane.VERTICAL_SCROLLBAR);
+    firePropertyChange("verticalScrollBar", old, v);
+    sync();
+  }
+
+  public void setVerticalScrollBarPolicy(int v)
+  {
+    if (verticalScrollBarPolicy == v)
+      return;
+    
+    if (v != VERTICAL_SCROLLBAR_AS_NEEDED
+        && v != VERTICAL_SCROLLBAR_NEVER
+        && v != VERTICAL_SCROLLBAR_ALWAYS)
+      throw new IllegalArgumentException("unknown vertical scrollbar policy");    
+    
+    int old = verticalScrollBarPolicy;
+    verticalScrollBarPolicy = v;
+    firePropertyChange("verticalScrollBarPolicy", old, v);
+    sync();
+    revalidate();
+  }
+
+  public void setWheelScrollingEnabled(boolean b)
+  {
+    if (wheelScrollingEnabled == b)
+      return;
+    
+    boolean old = wheelScrollingEnabled;
+    wheelScrollingEnabled = b;
+    firePropertyChange("wheelScrollingEnabled", old, b);
+    sync();
+  }
+
+  public void setViewport(JViewport v)
+  {
+    if (viewport == v)
+      return;
+    
+    JViewport old = viewport;
+    removeNonNull(old);
+    viewport = v;
+    addNonNull(v, JScrollPane.VIEWPORT);
+    revalidate();
+    repaint();
+    firePropertyChange("viewport", old, v);
+    sync();
+    if (accessibleContext != null)
+      {
+        AccessibleJScrollPane asp = (AccessibleJScrollPane) accessibleContext;
+        asp.resetViewPort();
+      }
+  }
+
+  public void setViewportBorder(Border b)
+  {
+    if (viewportBorder == b)
+      return;
+    
+    Border old = viewportBorder;
+    viewportBorder = b;
+    firePropertyChange("viewportBorder", old, b);
+    sync();
+  }
+    
+  public void setViewportView(Component view)
+  {
+    if (getViewport() == null)
+      {
+        setViewport(createViewport());
+      }
+	
+    if (view != null)
+      {
+        getViewport().setView(view);
+      }
+    sync();
+  }
+
+  public boolean isValidateRoot()
+  {
+    return true;
+  }
+
+  /**
+   * Creates a new <code>JScrollPane</code> without a view. The scrollbar
+   * policy is set to {@link #VERTICAL_SCROLLBAR_AS_NEEDED} and
+   * {@link #HORIZONTAL_SCROLLBAR_AS_NEEDED}.
+   */
+  public JScrollPane() 
+  {
+    this(null);
+  }
+
+  /**
+   * Creates a new <code>JScrollPane</code> that embeds the specified
+   * <code>view</code> component, displaying vertical and horizontal scrollbars
+   * as needed.
+   *
+   * @param view the component that is embedded inside the JScrollPane
+   */
+  public JScrollPane(Component view) 
+  {
+    this(view, 
+         VERTICAL_SCROLLBAR_AS_NEEDED, 
+         HORIZONTAL_SCROLLBAR_AS_NEEDED);
+  }
+
+  /**
+   * Creates a new <code>JScrollPane</code> without a view; The scrollbar
+   * policies are set to <code>vsbPolicy</code> and <code>hsbPolicy</code>.
+   *
+   * @param vsbPolicy the vertical scrollbar policy to set
+   * @param hsbPolicy the vertical scrollbar policy to set
+   *
+   * @see ScrollPaneConstants#HORIZONTAL_SCROLLBAR_ALWAYS
+   * @see ScrollPaneConstants#HORIZONTAL_SCROLLBAR_AS_NEEDED
+   * @see ScrollPaneConstants#HORIZONTAL_SCROLLBAR_NEVER
+   * @see ScrollPaneConstants#VERTICAL_SCROLLBAR_ALWAYS
+   * @see ScrollPaneConstants#VERTICAL_SCROLLBAR_AS_NEEDED
+   * @see ScrollPaneConstants#VERTICAL_SCROLLBAR_NEVER
+   */
+  public JScrollPane(int vsbPolicy, int hsbPolicy) 
+  {
+    this(null, vsbPolicy, hsbPolicy);
+  }
+
+  /**
+   * Creates a new <code>JScrollPane</code> that embeds the specified
+   * <code>view</code> component; The scrollbar
+   * policies are set to <code>vsbPolicy</code> and <code>hsbPolicy</code>.
+   *
+   * @param vsbPolicy the vertical scrollbar policy to set
+   * @param hsbPolicy the vertical scrollbar policy to set
+   *
+   * @see ScrollPaneConstants#HORIZONTAL_SCROLLBAR_ALWAYS
+   * @see ScrollPaneConstants#HORIZONTAL_SCROLLBAR_AS_NEEDED
+   * @see ScrollPaneConstants#HORIZONTAL_SCROLLBAR_NEVER
+   * @see ScrollPaneConstants#VERTICAL_SCROLLBAR_ALWAYS
+   * @see ScrollPaneConstants#VERTICAL_SCROLLBAR_AS_NEEDED
+   * @see ScrollPaneConstants#VERTICAL_SCROLLBAR_NEVER
+   */
+  public JScrollPane(Component view, int vsbPolicy, int hsbPolicy) 
+  {
+    setVerticalScrollBarPolicy(vsbPolicy);
+    setVerticalScrollBar(createVerticalScrollBar());
+    setHorizontalScrollBarPolicy(hsbPolicy);
+    setHorizontalScrollBar(createHorizontalScrollBar());
+    viewport = createViewport();
+    if (view != null)
+      getViewport().setView(view);
+    add(viewport,0);
+    setLayout(new ScrollPaneLayout());
+    setOpaque(false);
+    updateUI();
+  }
+
+  
+  public JScrollBar createHorizontalScrollBar()
+  {
+    return new ScrollBar(SwingConstants.HORIZONTAL);
+  }
+
+  public JScrollBar createVerticalScrollBar()
+  {
+    return new ScrollBar(SwingConstants.VERTICAL);
+  }
+    
+  protected JViewport createViewport()
+  {
+    return new JViewport();
+  }
+
+  public String getUIClassID()
+  {
+    return "ScrollPaneUI";
+  }
+  
+  public void updateUI()
+  {
+    setUI((ScrollPaneUI) UIManager.getUI(this));
+  }  
+
+  /**
+   * This method returns the scrollpane's UI delegate.
+   *
+   * @return The scrollpane's UI delegate.
+   */
+  public ScrollPaneUI getUI()
+  {
+    return (ScrollPaneUI) ui;
+  }
+
+  /**
+   * This method sets the scrollpane's UI delegate.
+   *
+   * @param ui The scrollpane's UI delegate.
+   */
+  public void setUI(ScrollPaneUI ui)
+  {
+    super.setUI(ui);
+  }
+
+  protected class ScrollBar 
+    extends JScrollBar
+    implements UIResource
+  {
+    private static final long serialVersionUID = -42032395320987283L;
+
+    public ScrollBar(int orientation)
+    {
+      super(orientation);
+    }
+
+    public int getBlockIncrement(int direction)
+    {
+      Component view = JScrollPane.this.getViewport().getView();
+      if (view == null || (! (view instanceof Scrollable)))
+        return super.getBlockIncrement(direction);
+      else
+        {
+          Scrollable s = (Scrollable) view;
+          return s.getScrollableBlockIncrement(JScrollPane.this.getViewport().getViewRect(), 
+                                               this.getOrientation(),
+                                               direction);
+        }
+    }
+
+    public int getUnitIncrement(int direction)
+    {
+      Component view = JScrollPane.this.getViewport().getView();
+      if (view == null || (! (view instanceof Scrollable)))
+        return super.getUnitIncrement(direction);
+      else
+        {
+          Scrollable s = (Scrollable) view;
+          return s.getScrollableUnitIncrement(JScrollPane.this.getViewport().getViewRect(), 
+                                              this.getOrientation(),
+                                              direction);
+        }
+    }
+  }
+
+  /**
+   * Returns the accessible context associated with this
+   * <code>JScrollPane</code>.
+   *
+   * @return the accessible context associated with this
+   *         <code>JScrollPane</code>
+   */
+  public AccessibleContext getAccessibleContext()
+  {
+    if (accessibleContext == null)
+      accessibleContext = new AccessibleJScrollPane();
+    return accessibleContext;
+  }
+}

Added: llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JSeparator.java
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JSeparator.java?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JSeparator.java (added)
+++ llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JSeparator.java Thu Nov  8 16:56:19 2007
@@ -0,0 +1,218 @@
+/* JSeparator.java --
+   Copyright (C) 2002, 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., 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;
+
+import java.beans.PropertyChangeEvent;
+
+import javax.accessibility.Accessible;
+import javax.accessibility.AccessibleContext;
+import javax.accessibility.AccessibleRole;
+import javax.swing.plaf.SeparatorUI;
+
+/**
+ * The JSeparator. It is mostly used to divide/space out
+ * components.
+ */
+public class JSeparator extends JComponent implements SwingConstants,
+                                                      Accessible
+{
+  /**
+   * Provides the accessibility features for the <code>JSeparator</code>
+   * component.
+   */
+  protected class AccessibleJSeparator extends AccessibleJComponent
+  {
+    private static final long serialVersionUID = 916332890553201095L;
+  
+    /**
+     * Creates a new <code>AccessibleJSeparator</code> instance.
+     */
+    protected AccessibleJSeparator()
+    {
+      // Nothing to do here.
+    }
+
+    /**
+     * Returns the accessible role for the <code>JSeparator</code> component.
+     *
+     * @return {@link AccessibleRole#SEPARATOR}.
+     */
+    public AccessibleRole getAccessibleRole()
+    {
+      return AccessibleRole.SEPARATOR;
+    }
+  }
+
+  private static final long serialVersionUID = 125301223445282357L;
+  
+  /** The orientation of the JSeparator. */
+  private transient int orientation = HORIZONTAL;
+
+  /**
+   * Creates a new horizontal <code>JSeparator</code> object.
+   */
+  public JSeparator()
+  {
+    this(HORIZONTAL);
+  }
+
+  /**
+   * Creates a new <code>JSeparator</code> object with the given orientation.
+   *
+   * @param orientation  the orientation (either {@link #HORIZONTAL} or 
+   *     {@link #VERTICAL}).
+   *     
+   * @throws IllegalArgumentException if <code>orientation</code> is not
+   *     one of the specified values.
+   */
+  public JSeparator(int orientation)
+  {
+    if (orientation != HORIZONTAL && orientation != VERTICAL)
+      throw new IllegalArgumentException(orientation
+                                         + " is not a valid orientation.");
+    this.orientation = orientation;
+    updateUI();
+  }
+
+  /**
+   * Returns the UI delegate being used with the <code>JSeparator</code>.
+   *
+   * @return The JSeparator's UI delegate.
+   */
+  public SeparatorUI getUI()
+  {
+    return (SeparatorUI) ui;
+  }
+
+  /**
+   * Sets the separator's UI delegate.
+   *
+   * @param ui  the UI delegate.
+   */
+  public void setUI(SeparatorUI ui)
+  {
+    super.setUI(ui);
+  }
+
+  /**
+   * Sets this separator's UI delegate to the default (obtained from the
+   * {@link UIManager}) for the current look and feel.
+   */
+  public void updateUI()
+  {
+    setUI((SeparatorUI) UIManager.getUI(this));
+  }
+
+  /**
+   * Returns the suffix (<code>"SeparatorUI"</code> in this case) used to 
+   * determine the class name for a UI delegate that can provide the look and 
+   * feel for a <code>JSeparator</code>.
+   *
+   * @return <code>"SeparatorUI"</code>.
+   */
+  public String getUIClassID()
+  {
+    return "SeparatorUI";
+  }
+
+  /**
+   * Returns the orientation of the <code>JSeparator</code>.
+   *
+   * @return The orientation (one of {@link #HORIZONTAL} and {@link #VERTICAL}).
+   * 
+   * @see #setOrientation(int)
+   */
+  public int getOrientation()
+  {
+    return orientation;
+  }
+
+  /**
+   * Sets the orientation for the <code>JSeparator</code> and sends a 
+   * {@link PropertyChangeEvent} (with the property name 
+   * <code>orientation</code>) to all registered listeners.
+   *
+   * @param orientation  the orientation (either {@link #HORIZONTAL} or 
+   *     {@link #VERTICAL}).
+   *     
+   * @throws IllegalArgumentException if <code>orientation</code> is not
+   *     one of the specified values.
+   *     
+   * @see #getOrientation()
+   */
+  public void setOrientation(int orientation)
+  {
+    if (orientation != HORIZONTAL && orientation != VERTICAL)
+      throw new IllegalArgumentException(orientation
+                                         + " is not a valid orientation.");
+    int old = this.orientation;
+    this.orientation = orientation;
+    firePropertyChange("orientation", old, orientation);
+  }
+
+  /**
+   * Returns an implementation-dependent string describing the attributes of
+   * this <code>JSeparator</code>.
+   *
+   * @return A string describing the attributes of this <code>JSeparator</code>
+   *         (never <code>null</code>).
+   */
+  protected String paramString()
+  {
+    String superParamStr = super.paramString();
+    if (orientation == HORIZONTAL)
+      return superParamStr + ",orientation=HORIZONTAL";
+    else
+      return superParamStr + ",orientation=VERTICAL";
+  }
+
+  /**
+   * Returns the object that provides accessibility features for this
+   * <code>JSeparator</code> component.
+   *
+   * @return The accessible context (an instance of 
+   *     {@link AccessibleJSeparator}).
+   */
+  public AccessibleContext getAccessibleContext()
+  {
+    if (accessibleContext == null)
+      accessibleContext = new AccessibleJSeparator();
+    
+    return accessibleContext;
+  }
+}

Added: llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JSlider.java
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JSlider.java?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JSlider.java (added)
+++ llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JSlider.java Thu Nov  8 16:56:19 2007
@@ -0,0 +1,1115 @@
+/* JSlider.java --
+   Copyright (C) 2002, 2004, 2005, 2006,  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;
+
+import java.awt.Dimension;
+import java.awt.MenuContainer;
+import java.awt.image.ImageObserver;
+import java.beans.PropertyChangeEvent;
+import java.io.Serializable;
+import java.util.Dictionary;
+import java.util.Enumeration;
+import java.util.Hashtable;
+
+import javax.accessibility.Accessible;
+import javax.accessibility.AccessibleContext;
+import javax.accessibility.AccessibleRole;
+import javax.accessibility.AccessibleState;
+import javax.accessibility.AccessibleStateSet;
+import javax.accessibility.AccessibleValue;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;
+import javax.swing.plaf.SliderUI;
+
+/**
+ * A visual component that allows selection of a value within a
+ * range by adjusting a thumb in a track. The values for the minimum,
+ * maximum, extent and value are stored in a {@link
+ * DefaultBoundedRangeModel}.
+ * <p>
+ * A <code>JSlider</code> component has the following properties:
+ * </p>
+ * 
+ * <table>
+ * <tr><th> Property         </th><th> Stored in </th><th> Bound? </th></tr>
+ * <tr><td> extent           </td><td> model     </td><td> no     </td></tr>
+ * <tr><td> inverted         </td><td> slider    </td><td> yes    </td></tr>
+ * <tr><td> labelTable       </td><td> slider    </td><td> yes    </td></tr>
+ * <tr><td> majorTickSpacing </td><td> slider    </td><td> yes    </td></tr> 
+ * <tr><td> maximum          </td><td> model     </td><td> yes     </td></tr>
+ * <tr><td> minimum          </td><td> model     </td><td> yes     </td></tr>
+ * <tr><td> minorTickSpacing </td><td> slider    </td><td> yes    </td></tr>
+ * <tr><td> model            </td><td> slider    </td><td> yes    </td></tr> 
+ * <tr><td> orientation      </td><td> slider    </td><td> yes    </td></tr>
+ * <tr><td> paintLabels      </td><td> slider    </td><td> yes    </td></tr>
+ * <tr><td> paintTicks       </td><td> slider    </td><td> yes    </td></tr>
+ * <tr><td> snapToTicks      </td><td> slider    </td><td> yes     </td></tr>
+ * <tr><td> value            </td><td> model     </td><td> no     </td></tr>
+ * <tr><td> valueIsAdjusting </td><td> model     </td><td> no     </td></tr>
+ * </table>
+ * 
+ * <p>
+ * The various behavioural aspects of these properties follows:
+ * </p>
+ * 
+ * <ul>
+ * <li>
+ * When a non-bound property stored in the slider changes, the slider fires
+ * a {@link ChangeEvent} to its change listeners.
+ * </li>
+ * <li>
+ * When a bound property stored in the slider changes, the slider fires a
+ * {@link PropertyChangeEvent} to its property change listeners.
+ * </li>
+ * <li>
+ * If any of the model's properties change, it fires a {@link ChangeEvent} to 
+ * its listeners, which include the slider.
+ * </li>
+ * <li>
+ * If the slider receives a {@link ChangeEvent} from its model, it will 
+ * propagate the event to its own change listeners, with the event's "source"
+ * property set to refer to the slider, rather than the model.
+ * </li>
+ * </ul>
+ */
+public class JSlider extends JComponent implements SwingConstants, Accessible,
+                                                   ImageObserver,
+                                                   MenuContainer, Serializable
+{
+  private static final long serialVersionUID = -1441275936141218479L;
+
+  /**
+   * Provides the accessibility features for the <code>JSlider</code>
+   * component.
+   */
+  protected class AccessibleJSlider extends JComponent.AccessibleJComponent
+    implements AccessibleValue
+  {
+    private static final long serialVersionUID = -6301740148041106789L;
+  
+    /**
+     * Creates a new <code>AccessibleJSlider</code> instance.
+     */
+    protected AccessibleJSlider()
+    {
+      // Nothing to do here.
+    }
+
+    /**
+     * Returns a set containing the current state of the {@link JSlider} 
+     * component.
+     *
+     * @return The accessible state set.
+     */
+    public AccessibleStateSet getAccessibleStateSet()
+    {
+      AccessibleStateSet result = super.getAccessibleStateSet();
+      if (orientation == JSlider.HORIZONTAL)
+        result.add(AccessibleState.HORIZONTAL);
+      else if (orientation == JSlider.VERTICAL)
+        result.add(AccessibleState.VERTICAL);
+      return result;
+    }
+
+    /**
+     * Returns the accessible role for the <code>JSlider</code> component.
+     *
+     * @return {@link AccessibleRole#SLIDER}.
+     */
+    public AccessibleRole getAccessibleRole()
+    {
+      return AccessibleRole.SLIDER;
+    }
+
+    /**
+     * Returns an object that provides access to the current, minimum and 
+     * maximum values for the {@link JSlider}.  Since this class implements 
+     * {@link AccessibleValue}, it returns itself.
+     *
+     * @return The accessible value.
+     */
+    public AccessibleValue getAccessibleValue()
+    {
+      return this;
+    }
+
+    /**
+     * Returns the current value of the {@link JSlider} component, as an
+     * {@link Integer}.
+     *
+     * @return The current value of the {@link JSlider} component.
+     */
+    public Number getCurrentAccessibleValue()
+    {
+      return new Integer(getValue());
+    }
+
+    /**
+     * Sets the current value of the {@link JSlider} component and sends a
+     * {@link PropertyChangeEvent} (with the property name 
+     * {@link AccessibleContext#ACCESSIBLE_VALUE_PROPERTY}) to all registered
+     * listeners.  If the supplied value is <code>null</code>, this method 
+     * does nothing and returns <code>false</code>.
+     *
+     * @param value  the new slider value (<code>null</code> permitted).
+     *
+     * @return <code>true</code> if the slider value is updated, and 
+     *     <code>false</code> otherwise.
+     */
+    public boolean setCurrentAccessibleValue(Number value)
+    {
+      if (value == null)
+        return false;
+      Number oldValue = getCurrentAccessibleValue();
+      setValue(value.intValue());
+      firePropertyChange(AccessibleContext.ACCESSIBLE_VALUE_PROPERTY, oldValue, 
+                         new Integer(getValue()));
+      return true;
+    }
+
+    /**
+     * Returns the minimum value of the {@link JSlider} component, as an
+     * {@link Integer}.
+     *
+     * @return The minimum value of the {@link JSlider} component.
+     */
+    public Number getMinimumAccessibleValue()
+    {
+      return new Integer(getMinimum());
+    }
+
+    /**
+     * Returns the maximum value of the {@link JSlider} component, as an
+     * {@link Integer}.
+     *
+     * @return The maximum value of the {@link JSlider} component.
+     */
+    public Number getMaximumAccessibleValue()
+    {
+      return new Integer(getMaximum());
+    }
+  }
+
+  /** Whether or not this slider paints its ticks. */
+  private transient boolean paintTicks;
+
+  /** Whether or not this slider paints its track. */
+  private transient boolean paintTrack = true;
+
+  /** Whether or not this slider paints its labels. */
+  private transient boolean paintLabels;
+
+  /**
+   * A dictionary of (Integer, Component) pairs where each Component is a
+   * JLabel and the Integer determines where the label will be painted.
+   */
+  private transient Dictionary labelTable;
+
+  /** The model used to store the slider's range and current value. */
+  protected BoundedRangeModel sliderModel;
+
+  /** The space/distance between major ticks. */
+  protected int majorTickSpacing;
+
+  /** The space/distance between minor ticks. */
+  protected int minorTickSpacing;
+
+  /** Whether the slider snaps its values to ticks. */
+  protected boolean snapToTicks;
+
+  /** The orientation (horizontal or vertical) of the slider. */
+  protected int orientation = HORIZONTAL;
+
+  /** Whether the slider is inverted. */
+  private transient boolean isInverted;
+
+  /** 
+   * The listener that monitors the slider's model and forwards events to the
+   * slider's listeners (see <code>createChangeListener()</code>). 
+   */
+  protected ChangeListener changeListener;
+
+  /** The change event that is passed to all listeners of this slider. */
+  protected transient ChangeEvent changeEvent;
+
+  /**
+   * Creates a new horizontal <code>JSlider</code> instance with a minimum of 
+   * 0, a maximum of 100, and a value of 50.
+   */
+  public JSlider()
+  {
+    this(HORIZONTAL, 0, 100, 50);
+  }
+
+  /**
+   * Creates a new <code>JSlider</code> instance with the given orientation 
+   * and a minimum of 0, a maximum of 100, and a value of 50.
+   *
+   * @param orientation The orientation of the slider ({@link #HORIZONTAL} or
+   *                    {@link #VERTICAL}).
+   * 
+   * @throws IllegalArgumentException if <code>orientation</code> is not one of
+   *         the specified values.
+   */
+  public JSlider(int orientation)
+  {
+    this(orientation, 0, 100, 50);
+  }
+
+  /**
+   * Creates a new horizontal <code>JSlider</code> instance with the given 
+   * maximum and minimum and a value that is halfway between the minimum and the
+   * maximum.
+   *
+   * @param minimum The minimum value.
+   * @param maximum The maximum value.
+   * 
+   * @throws IllegalArgumentException if <code>minimum</code> is greater than
+   *     <code>maximum</code>.
+   */
+  public JSlider(int minimum, int maximum)
+  {
+    this(HORIZONTAL, minimum, maximum, (maximum + minimum) / 2);
+  }
+
+  /**
+   * Creates a new horizontal <code>JSlider</code> instance with the given 
+   * minimum, maximum, and value.
+   *
+   * @param minimum The minimum value.
+   * @param maximum The maximum value.
+   * @param value The initial value.
+   * 
+   * @throws IllegalArgumentException if <code>value</code> is not in the 
+   *     specified range.
+   * @throws IllegalArgumentException if <code>minimum</code> is greater than
+   *     <code>maximum</code>.
+   */
+  public JSlider(int minimum, int maximum, int value)
+  {
+    this(HORIZONTAL, minimum, maximum, value);
+  }
+
+  /**
+   * Creates a new <code>JSlider</code> instance with the given orientation, 
+   * minimum, maximum, and value.
+   *
+   * @param orientation The orientation of the slider ({@link #HORIZONTAL} or
+   *                    {@link #VERTICAL}).
+   * @param minimum The minimum value of the JSlider.
+   * @param maximum The maximum value of the JSlider.
+   * @param value The initial value of the JSlider.
+   * 
+   * @throws IllegalArgumentException if <code>orientation</code> is not one of
+   *     the specified values.
+   * @throws IllegalArgumentException if <code>value</code> is not in the 
+   *     specified range.
+   * @throws IllegalArgumentException if <code>minimum</code> is greater than
+   *     <code>maximum</code>.
+   */
+  public JSlider(int orientation, int minimum, int maximum, int value)
+  {
+    sliderModel = new DefaultBoundedRangeModel(value, 0, minimum, maximum);
+    if (orientation != HORIZONTAL && orientation != VERTICAL)
+      throw new IllegalArgumentException(orientation 
+                                         + " is not a legal orientation");
+    this.orientation = orientation;
+    changeListener = createChangeListener();
+    sliderModel.addChangeListener(changeListener);
+    updateUI();
+  }
+
+  /**
+   * Creates a new horizontal <code>JSlider</code> instance with the given 
+   * model.
+   *
+   * @param model The model (<code>null</code> not permitted).
+   * 
+   * @throws NullPointerException if <code>model</code> is <code>null</code>.
+   */
+  public JSlider(BoundedRangeModel model)
+  {
+    sliderModel = model;
+    changeListener = createChangeListener();
+    sliderModel.addChangeListener(changeListener);
+    updateUI();
+  }
+
+  /**
+   * Returns the slider's value (from the slider's model).
+   *
+   * @return The value of the slider.
+   * 
+   * @see #setValue(int)
+   */
+  public int getValue()
+  {
+    return sliderModel.getValue();
+  }
+
+  /**
+   * Sets the slider's value and sends a {@link ChangeEvent} to all 
+   * registered listeners.  Note that the model will fire a change event to all
+   * of its registered listeners first (with the model as the event source) and
+   * then the slider will fire another change event to all of its registered
+   * listeners (this time with the slider as the event source).
+   *
+   * @param value  the new value.
+   * 
+   * @see #getValue()
+   */
+  public void setValue(int value)
+  {
+    sliderModel.setValue(value);
+  }
+
+  /**
+   * Returns the slider's UI delegate.
+   *
+   * @return The slider's UI delegate.
+   */
+  public SliderUI getUI()
+  {
+    return (SliderUI) ui;
+  }
+
+  /**
+   * Sets the slider's UI delegate.
+   *
+   * @param ui  the UI delegate.
+   */
+  public void setUI(SliderUI ui)
+  {
+    super.setUI(ui);
+  }
+
+  /**
+   * Sets this slider's UI delegate to the default (obtained from the
+   * {@link UIManager}) for the current look and feel.
+   */
+  public void updateUI()
+  {
+    setUI((SliderUI) UIManager.getUI(this));
+  }
+
+  /**
+   * Returns the suffix (<code>"SliderUI"</code> in this case) used to 
+   * determine the class name for a UI delegate that can provide the look and 
+   * feel for a <code>JSlider</code>.
+   *
+   * @return <code>"SliderUI"</code>.
+   */
+  public String getUIClassID()
+  {
+    return "SliderUI";
+  }
+
+  /**
+   * Creates a {@link ChangeListener} that is added to the slider's model and
+   * forwards change events generated by the model to the listeners that are
+   * registered with the <code>JSlider</code> (by calling the 
+   * {@link #fireStateChanged} method).
+   *
+   * @return A new listener.
+   */
+  protected ChangeListener createChangeListener()
+  {
+    return new ChangeListener()
+      {
+        public void stateChanged(ChangeEvent ce)
+        {
+          // No need to trigger a repaint since the UI listens to the model
+          // as well. All we need to do is pass on the stateChanged event 
+          // to our listeners.
+          fireStateChanged();
+        }
+      };
+  }
+
+  /**
+   * Registers a listener with the slider so that it will receive 
+   * {@link ChangeEvent} notifications.  Note that change events generated
+   * by the slider's model will be forwarded automatically to the slider's
+   * listeners.
+   *
+   * @param listener  the listener to register.
+   * 
+   * @see #removeChangeListener(ChangeListener)
+   */
+  public void addChangeListener(ChangeListener listener)
+  {
+    listenerList.add(ChangeListener.class, listener);
+  }
+
+  /**
+   * Removes a listener from this slider so that it will no longer receive
+   * {@link ChangeEvent} notifications from the slider.
+   *
+   * @param listener The listener to remove.
+   * 
+   * @see #addChangeListener(ChangeListener)
+   */
+  public void removeChangeListener(ChangeListener listener)
+  {
+    listenerList.remove(ChangeListener.class, listener);
+  }
+
+  /**
+   * Sends a {@link ChangeEvent} to all registered listeners, with this slider 
+   * as the source.
+   */
+  protected void fireStateChanged()
+  {
+    Object[] changeListeners = listenerList.getListenerList();
+    if (changeEvent == null)
+      changeEvent = new ChangeEvent(this);
+    for (int i = changeListeners.length - 2; i >= 0; i -= 2)
+      {
+        if (changeListeners[i] == ChangeListener.class)
+          ((ChangeListener) changeListeners[i + 1]).stateChanged(changeEvent);
+      }
+  }
+
+  /**
+   * Returns an array containing all the {@link ChangeListener} instances 
+   * registered with this slider.  If no listeners are registered, this method
+   * returns an empty array.
+   *
+   * @return An array array containing all the {@link ChangeListener} instances 
+   *     registered with this slider (possibly empty, but never 
+   *     <code>null</code>).
+   */
+  public ChangeListener[] getChangeListeners()
+  {
+    return (ChangeListener[]) listenerList.getListeners(ChangeListener.class);
+  }
+
+  /**
+   * Returns the slider's model, which stores the minimum, maximum and current 
+   * values.
+   *
+   * @return The slider's model.
+   * 
+   * @see #setModel(BoundedRangeModel)
+   */
+  public BoundedRangeModel getModel()
+  {
+    return sliderModel;
+  }
+
+  /**
+   * Sets the slider's model and sends a {@link PropertyChangeEvent} (with the
+   * property name "model") to all registered listeners.   The change listener
+   * that the slider registered with the original model is removed and added
+   * to the new model (this ensures that {@link ChangeEvent} notifications 
+   * generated by the model are automatically forwarded to listeners that are
+   * registered with the slider).
+   *
+   * @param model The model to use with the slider.
+   * 
+   * @see #getModel()
+   */
+  public void setModel(BoundedRangeModel model)
+  {
+    // I didn't do the null pointer check on purpose.
+    // If you try it with Sun's, it'll go ahead and set it to null
+    // and bork the next time it tries to access the model.
+    if (model != sliderModel)
+      {
+        BoundedRangeModel oldModel = sliderModel;
+        sliderModel = model;
+        oldModel.removeChangeListener(changeListener);
+        sliderModel.addChangeListener(changeListener);
+        firePropertyChange("model", oldModel, sliderModel);
+      }
+  }
+
+  /**
+   * Returns the minimum value of the slider (from the slider's model).
+   *
+   * @return The minimum value of the slider.
+   * 
+   * @see #setMinimum(int)
+   */
+  public int getMinimum()
+  {
+    return sliderModel.getMinimum();
+  }
+
+  /**
+   * Sets the minimum value of the slider and fires a 
+   * {@link PropertyChangeEvent} (with the property name "minimum") to all
+   * registered listeners.  Note that:
+   * <p>
+   * <ul>
+   * <li>the minimum value is stored in the slider's model (see 
+   *     {@link #getModel()});</li>
+   * <li>in addition to the property change event, the slider also fires a 
+   *     {@link ChangeEvent}.</li>
+   * </ul>
+   * 
+   * @param minimum The minimum value of the slider.
+   * 
+   * @see #getMinimum()
+   */
+  public void setMinimum(int minimum)
+  {
+    int old = sliderModel.getMinimum();
+    sliderModel.setMinimum(minimum);
+    if (minimum != old)
+      firePropertyChange("minimum", old, minimum);
+  }
+
+  /**
+   * Returns the slider's maximum value (obtained from the slider's model).
+   *
+   * @return The maximum value of the slider.
+   * 
+   * @see #setMaximum(int)
+   */
+  public int getMaximum()
+  {
+    return sliderModel.getMaximum();
+  }
+
+  /**
+   * Sets the maximum value of the slider and fires a 
+   * {@link PropertyChangeEvent} (with the property name "maximum") to all
+   * registered listeners.  Note that:
+   * <p>
+   * <ul>
+   * <li>the maximum value is stored in the slider's model (see 
+   *     {@link #getModel()});</li>
+   * <li>in addition to the property change event, the slider also fires a 
+   *     {@link ChangeEvent}.</li>
+   * </ul>
+   *
+   * @param maximum The maximum value of the slider.
+   * 
+   * @see #getMaximum()
+   */
+  public void setMaximum(int maximum)
+  {
+    int old = sliderModel.getMaximum();
+    sliderModel.setMaximum(maximum);
+    if (maximum != old)
+      firePropertyChange("maximum", old, maximum);
+  }
+
+  /**
+   * Returns the <code>valueIsAdjusting</code> flag from the slider's model.
+   *
+   * @return The <code>valueIsAdjusting</code> flag from the slider's model.
+   * 
+   * @see #setValueIsAdjusting(boolean)
+   */
+  public boolean getValueIsAdjusting()
+  {
+    return sliderModel.getValueIsAdjusting();
+  }
+
+  /**
+   * Sets the <code>valueIsAdjusting</code> flag in the slider's model, and 
+   * sends a {@link ChangeEvent} to all registered listeners.
+   *
+   * @param adjusting  the new flag value.
+   * 
+   * @see #getValueIsAdjusting()
+   */
+  public void setValueIsAdjusting(boolean adjusting)
+  {
+    sliderModel.setValueIsAdjusting(adjusting);
+  }
+
+  /**
+   * Returns the slider's extent value, obtained from the slider's model.
+   *
+   * @return The extent value.
+   * 
+   * @see #setExtent(int)
+   */
+  public int getExtent()
+  {
+    return sliderModel.getExtent();
+  }
+
+  /**
+   * Sets the slider's extent value and sends a {@link ChangeEvent} to all 
+   * registered listeners.  Note that the model will fire a change event to all
+   * of its registered listeners first (with the model as the event source) and
+   * then the slider will fire another change event to all of its registered
+   * listeners (this time with the slider as the event source).
+   *
+   * @param extent The extent value for this slider.
+   * 
+   * @see #getExtent()
+   */
+  public void setExtent(int extent)
+  {
+    sliderModel.setExtent(extent);
+  }
+
+  /**
+   * Returns the orientation of the slider, either {@link JSlider#HORIZONTAL}
+   * or {@link JSlider#VERTICAL}.
+   *
+   * @return The orientation of the slider.
+   * 
+   * @see #setOrientation(int)
+   */
+  public int getOrientation()
+  {
+    return orientation;
+  }
+
+  /**
+   * Sets the orientation for the slider and sends a 
+   * {@link PropertyChangeEvent} (with the property name "orientation") to all
+   * registered listeners.
+   *
+   * @param orientation  the orientation (one of {@link JSlider#HORIZONTAL} or
+   *     {@link JSlider#VERTICAL}).
+   *     
+   * @throws IllegalArgumentException if <code>orientation</code> is not one of
+   *     the permitted values.
+   *     
+   * @see #getOrientation()
+   */
+  public void setOrientation(int orientation)
+  {
+    if (orientation != VERTICAL && orientation != HORIZONTAL)
+      throw new IllegalArgumentException(
+          "orientation must be one of: VERTICAL, HORIZONTAL");
+    if (orientation != this.orientation)
+      {
+        int oldOrientation = this.orientation;
+        this.orientation = orientation;
+        firePropertyChange("orientation", oldOrientation, this.orientation);
+      }
+  }
+
+  /**
+   * Returns the label table for the slider.
+   *
+   * @return The label table for the slider (possibly <code>null</code>).
+   * 
+   * @see #setLabelTable(Dictionary)
+   */
+  public Dictionary getLabelTable()
+  {
+    return labelTable;
+  }
+
+  /**
+   * Sets the table of labels for the slider and sends a 
+   * {@link PropertyChangeEvent} (with the property name "labelTable") to all 
+   * registered listeners.
+   *
+   * @param table  the table of labels (<code>null</code> permitted).
+   * 
+   * @see #getLabelTable()
+   */
+  public void setLabelTable(Dictionary table)
+  {
+    if (table != labelTable)
+      {
+        Dictionary oldTable = labelTable;
+        labelTable = table;
+        firePropertyChange("labelTable", oldTable, labelTable);
+      }
+  }
+
+  /**
+   * Resets the UI delegates for the labels in the <code>labelTable</code> to 
+   * the default for the current look and feel.
+   */
+  protected void updateLabelUIs()
+  {
+    if (labelTable == null)
+      return;
+    for (Enumeration list = labelTable.elements(); list.hasMoreElements();)
+      {
+        JLabel label = (JLabel) list.nextElement();
+        label.updateUI();
+      }
+  }
+
+  /**
+   * Creates a hashtable of <code>(Integer, JLabel)</code> pairs that can be 
+   * used as a label table for this slider. The labels will start from the 
+   * slider's minimum and increase by the increment. Each label will have a text
+   * string indicating its integer value.
+   *
+   * @param increment The increment between labels (must be > 0).
+   *
+   * @return A hashtable containing the labels.
+   *
+   * @throws IllegalArgumentException if <code>increment</code> is not greater
+   *         than zero.
+   */
+  public Hashtable createStandardLabels(int increment)
+  {
+    return createStandardLabels(increment, sliderModel.getMinimum());
+  }
+
+  /**
+   * Creates a hashtable of <code>(Integer, JLabel)</code> pairs that can be 
+   * used as a label table for this slider. The labels will start from the 
+   * given start value and increase by the increment. Each  label will have a 
+   * text string indicating its integer value.
+   *
+   * @param increment The increment between labels (must be > 0).
+   * @param start The value to start from.
+   *
+   * @return A hashtable with the labels and their keys.
+   *
+   * @throws IllegalArgumentException if <code>increment</code> is not greater
+   *         than zero, or <code>start</code> is not within the range of the
+   *         model.
+   */
+  public Hashtable createStandardLabels(int increment, int start)
+  {
+    if (increment <= 0) 
+      throw new IllegalArgumentException("Requires 'increment' > 0.");
+    if (start < getMinimum() || start > getMaximum())
+      throw new IllegalArgumentException("The 'start' value is out of range.");
+    Hashtable table = new Hashtable();
+    JLabel label;
+    Dimension dim;
+
+    int max = sliderModel.getMaximum();
+
+    for (int i = start; i <= max; i += increment)
+      {
+        label = new JLabel(String.valueOf(i));
+        label.setVerticalAlignment(CENTER);
+        label.setHorizontalAlignment(CENTER);
+        
+        // Make sure these labels have the width and height
+        // they want.
+        dim = label.getPreferredSize();
+        label.setBounds(label.getX(), label.getY(),
+                        (int) dim.getWidth(),
+                        (int) dim.getHeight()); 
+        table.put(new Integer(i), label);
+      }
+    return table;
+  }
+
+  /**
+   * Returns the flag that controls whether or not the value scale for the
+   * slider is inverted (the default value is <code>false</code>).
+   *
+   * @return The flag that controls whether or not the value scale for the
+   *     slider is inverted.
+   *     
+   * @see #setInverted(boolean)
+   */
+  public boolean getInverted()
+  {
+    return isInverted;
+  }
+
+  /**
+   * Sets the flag that controls whether or not the value scale for the
+   * slider is inverted and, if the new flag value is different to the old flag
+   * value, sends a {@link PropertyChangeEvent} to all registered listeners.
+   * Typically, a horizontal slider will display a scale that increases from 
+   * left to right, but this is reversed if the 'inverted' flag is set to 
+   * <code>true</code>.  Similarly, a vertical slider will display a scale that
+   * increases from bottom to top, and this is reversed if the 'inverted' flag
+   * is set to <code>true</code>.
+   *
+   * @param inverted  the new flag value.
+   * 
+   * @see #getInverted()
+   */
+  public void setInverted(boolean inverted)
+  {
+    if (isInverted != inverted)
+      {
+        boolean oldInverted = isInverted;
+        isInverted = inverted;
+        firePropertyChange("inverted", oldInverted, isInverted);
+      }
+  }
+
+  /**
+   * Returns the distance between major tick marks along the slider's value 
+   * scale.
+   *
+   * @return The amount of units between each major tick mark.
+   * 
+   * @see #setMajorTickSpacing(int)
+   */
+  public int getMajorTickSpacing()
+  {
+    return majorTickSpacing;
+  }
+
+  /**
+   * Sets the distance between major tick marks along the slider's value scale, 
+   * and sends a {@link PropertyChangeEvent} (with the property name 
+   * "majorTickSpacing") to all registered listeners.
+   *
+   * @param spacing  the distance between major tick marks.
+   * 
+   * @see #getMajorTickSpacing()
+   */
+  public void setMajorTickSpacing(int spacing)
+  {
+    if (majorTickSpacing != spacing)
+      {
+        int oldSpacing = majorTickSpacing;
+        majorTickSpacing = spacing;
+        firePropertyChange("majorTickSpacing", oldSpacing, majorTickSpacing);
+      }
+  }
+
+  /**
+   * Returns the distance between minor tick marks along the slider's value 
+   * scale.
+   *
+   * @return The distance between minor tick marks along the slider's value 
+   *     scale.
+   *     
+   * @see #setMinorTickSpacing(int)
+   */
+  public int getMinorTickSpacing()
+  {
+    return minorTickSpacing;
+  }
+
+  /**
+   * Sets the distance between minor tick marks along the slider's value scale, 
+   * and sends a {@link PropertyChangeEvent} (with the property name 
+   * "minorTickSpacing") to all registered listeners.
+   *
+   * @param spacing  the distance between minor tick marks.
+   * 
+   * @see #getMinorTickSpacing()
+   */
+  public void setMinorTickSpacing(int spacing)
+  {
+    if (minorTickSpacing != spacing)
+      {
+        int oldSpacing = minorTickSpacing;
+        minorTickSpacing = spacing;
+        firePropertyChange("minorTickSpacing", oldSpacing, minorTickSpacing);
+      }
+  }
+
+  /**
+   * Returns the flag that controls whether the slider thumb will snap to ticks.
+   * Sliders that snap to ticks will automatically move the thumb to the 
+   * nearest tick mark.
+   *
+   * @return <code>true</code> if the slider thumb automatically.
+   * 
+   * @see #setSnapToTicks(boolean)
+   */
+  public boolean getSnapToTicks()
+  {
+    return snapToTicks;
+  }
+
+  /**
+   * Sets the flag that controls whether the slider thumb will snap to ticks 
+   * and sends a {@link PropertyChangeEvent} (with the property name 
+   * 'snapToTicks') to all registered listeners. Sliders that snap to ticks 
+   * will automatically move the thumb to the nearest tick mark.
+   *
+   * @param snap  the new flag value.
+   * 
+   * @see #getSnapToTicks()
+   */
+  public void setSnapToTicks(boolean snap)
+  {
+    if (snap != snapToTicks)
+      {
+        snapToTicks = snap;
+        firePropertyChange("snapToTicks", !snap, snap);
+      }
+  }
+
+  /**
+   * Returns the flag that controls whether or not tick marks are painted along
+   * the slider's value scale.
+   *
+   * @return <code>true</code> if tick marks should be painted, and 
+   *     <code>false</code> if tick marks should not be painted.
+   *     
+   * @see #setPaintTicks(boolean)
+   */
+  public boolean getPaintTicks()
+  {
+    return paintTicks;
+  }
+
+  /**
+   * Sets the flag that controls whether or not tick marks are painted along
+   * the slider's value scale, and sends a {@link PropertyChangeEvent} (with 
+   * the property name "paintTicks") to all registered listeners. In
+   * addition to setting this property to <code>true</code>, one or both of the
+   * minor tick spacing and major tick spacing attributes must be set to a 
+   * value greater than 0 in order for ticks to be painted.
+   *
+   * @param paint Whether ticks will be painted.
+   * 
+   * @see #getPaintTicks()
+   */
+  public void setPaintTicks(boolean paint)
+  {
+    if (paint != paintTicks)
+      {
+        boolean oldPaintTicks = paintTicks;
+        paintTicks = paint;
+        firePropertyChange("paintTicks", oldPaintTicks, paintTicks);
+      }
+  }
+
+  /**
+   * Returns the flag that controls whether or not the track is painted.
+   *
+   * @return Whether the track will be painted.
+   * 
+   * @see #setPaintTrack(boolean)
+   */
+  public boolean getPaintTrack()
+  {
+    return paintTrack;
+  }
+
+  /**
+   * Sets the flag that controls whether or not the track is painted, and
+   * sends a {@link PropertyChangeEvent} (for the "paintTrack" property) to all
+   * registered listeners.
+   *
+   * @param paint Whether the track will be painted.
+   * 
+   * @see #getPaintTrack()
+   */
+  public void setPaintTrack(boolean paint)
+  {
+    if (paintTrack != paint)
+    {
+      paintTrack = paint;
+      firePropertyChange("paintTrack", !paint, paint);
+    }
+  }
+
+  /**
+   * Returns the flag that controls whether or not labels are painted for the
+   * tick marks along the slider.
+   *
+   * @return Whether labels will be painted.
+   * 
+   * @see #setPaintLabels(boolean)
+   */
+  public boolean getPaintLabels()
+  {
+    return paintLabels;
+  }
+
+  /**
+   * Sets the flag that controls whether or not labels are painted for the
+   * tick marks along the slider and sends a {@link PropertyChangeEvent} (with 
+   * the property name "paintLabels") to all registered listeners.
+   *
+   * @param paint Whether labels will be painted.
+   * 
+   * @see #getPaintLabels()
+   */
+  public void setPaintLabels(boolean paint)
+  {
+    if (paint != paintLabels)
+      {
+        paintLabels = paint;
+        if (paint && majorTickSpacing > 0 && labelTable == null)
+          labelTable = createStandardLabels(majorTickSpacing);
+        firePropertyChange("paintLabels", !paint, paint);
+      }
+  }
+
+  /**
+   * Returns an implementation-dependent string describing the attributes of
+   * this <code>JSlider</code>.
+   *
+   * @return A string describing the attributes of this <code>JSlider</code>
+   *         (never <code>null</code>).
+   */
+  protected String paramString()
+  {
+    String superParamStr = super.paramString();
+    StringBuffer sb = new StringBuffer();
+    sb.append(",isInverted=").append(getInverted());
+    sb.append(",majorTickSpacing=").append(getMajorTickSpacing());
+    sb.append(",minorTickSpacing=").append(getMinorTickSpacing());
+    sb.append(",orientation=");
+    if (orientation == HORIZONTAL)
+      sb.append("HORIZONTAL");
+    else
+      sb.append("VERTICAL");
+    sb.append(",paintLabels=").append(getPaintLabels());
+    sb.append(",paintTicks=").append(getPaintTicks());
+    sb.append(",paintTrack=").append(getPaintTrack());
+    sb.append(",snapToTicks=").append(getSnapToTicks());
+    
+    // the following is output by the reference implementation.  We don't
+    // strictly need to replicate this. Perhaps it has some meaning, but
+    // I couldn't determine it yet...
+    sb.append(",snapToValue=true");
+
+    return superParamStr + sb.toString();
+  }
+
+  /**
+   * Returns the object that provides accessibility features for this
+   * <code>JSlider</code> component.
+   *
+   * @return The accessible context (an instance of {@link AccessibleJSlider}).
+   */
+  public AccessibleContext getAccessibleContext()
+  {
+    if (accessibleContext == null)
+      accessibleContext = new AccessibleJSlider();
+    
+    return accessibleContext;
+  }
+}

Added: llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JSpinner.java
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JSpinner.java?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JSpinner.java (added)
+++ llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JSpinner.java Thu Nov  8 16:56:19 2007
@@ -0,0 +1,754 @@
+/* JSpinner.java --
+   Copyright (C) 2004, 2005, 2006  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;
+
+import java.awt.Component;
+import java.awt.Container;
+import java.awt.Dimension;
+import java.awt.Insets;
+import java.awt.LayoutManager;
+import java.beans.PropertyChangeEvent;
+import java.beans.PropertyChangeListener;
+import java.text.DateFormat;
+import java.text.DecimalFormat;
+import java.text.NumberFormat;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;
+import javax.swing.plaf.SpinnerUI;
+import javax.swing.text.DateFormatter;
+import javax.swing.text.DefaultFormatterFactory;
+import javax.swing.text.NumberFormatter;
+
+/**
+ * A <code>JSpinner</code> is a component that displays a single value from
+ * a sequence of values, and provides a convenient means for selecting the
+ * previous and next values in the sequence.  Typically the spinner displays
+ * a numeric value, but it is possible to display dates or arbitrary items
+ * from a list.
+ *
+ * @author Ka-Hing Cheung
+ * 
+ * @since 1.4
+ */
+public class JSpinner extends JComponent
+{
+  /**
+   * The base class for the editor used by the {@link JSpinner} component.  
+   * The editor is in fact a panel containing a {@link JFormattedTextField}
+   * component.
+   */
+  public static class DefaultEditor 
+    extends JPanel 
+    implements ChangeListener, PropertyChangeListener, LayoutManager
+  {
+    /** The spinner that the editor is allocated to. */
+    private JSpinner spinner;
+
+    /** The JFormattedTextField that backs the editor. */
+    JFormattedTextField ftf;
+
+    /**
+     * For compatability with Sun's JDK 1.4.2 rev. 5
+     */
+    private static final long serialVersionUID = -5317788736173368172L;
+
+    /**
+     * Creates a new <code>DefaultEditor</code> object.  The editor is 
+     * registered with the spinner as a {@link ChangeListener} here.
+     *
+     * @param spinner the <code>JSpinner</code> associated with this editor
+     */
+    public DefaultEditor(JSpinner spinner)
+    {
+      super();
+      setLayout(this);
+      this.spinner = spinner;
+      ftf = new JFormattedTextField();
+      add(ftf);
+      ftf.setValue(spinner.getValue());
+      ftf.addPropertyChangeListener(this);
+      if (getComponentOrientation().isLeftToRight())
+	ftf.setHorizontalAlignment(JTextField.RIGHT);
+      else
+	ftf.setHorizontalAlignment(JTextField.LEFT);
+      spinner.addChangeListener(this);
+    }
+
+    /**
+     * Returns the <code>JSpinner</code> component that the editor is assigned
+     * to.
+     * 
+     * @return The spinner that the editor is assigned to.
+     */
+    public JSpinner getSpinner()
+    {
+      return spinner;
+    }
+    
+    /**
+     * DOCUMENT ME!
+     */
+    public void commitEdit() throws ParseException
+    {
+      // TODO: Implement this properly.
+    }
+
+    /**
+     * Removes the editor from the {@link ChangeListener} list maintained by
+     * the specified <code>spinner</code>.
+     *
+     * @param spinner  the spinner (<code>null</code> not permitted).
+     */
+    public void dismiss(JSpinner spinner)
+    {
+      spinner.removeChangeListener(this);
+    }
+
+    /**
+     * Returns the text field used to display and edit the current value in 
+     * the spinner.
+     *
+     * @return The text field.
+     */
+    public JFormattedTextField getTextField()
+    {
+      return ftf;
+    }
+    
+    /**
+     * Sets the bounds for the child components in this container.  In this
+     * case, the text field is the only component to be laid out.
+     *
+     * @param parent the parent container.
+     */
+    public void layoutContainer(Container parent)
+    {
+      Insets insets = getInsets();
+      Dimension size = getSize();
+      ftf.setBounds(insets.left, insets.top,
+                    size.width - insets.left - insets.right,
+                    size.height - insets.top - insets.bottom);
+    }
+    
+    /**
+     * Calculates the minimum size for this component.  In this case, the
+     * text field is the only subcomponent, so the return value is the minimum
+     * size of the text field plus the insets of this component.
+     *
+     * @param parent  the parent container.
+     *
+     * @return The minimum size.
+     */
+    public Dimension minimumLayoutSize(Container parent)
+    {
+      Insets insets = getInsets();
+      Dimension minSize = ftf.getMinimumSize();
+      return new Dimension(minSize.width + insets.left + insets.right,
+                            minSize.height + insets.top + insets.bottom);
+    }
+    
+    /**
+     * Calculates the preferred size for this component.  In this case, the
+     * text field is the only subcomponent, so the return value is the 
+     * preferred size of the text field plus the insets of this component.
+     *
+     * @param parent  the parent container.
+     *
+     * @return The preferred size.
+     */
+    public Dimension preferredLayoutSize(Container parent)
+    {
+      Insets insets = getInsets();
+      Dimension prefSize = ftf.getPreferredSize();
+      return new Dimension(prefSize.width + insets.left + insets.right,
+                            prefSize.height + insets.top + insets.bottom);
+    }
+    
+    /**
+     * Receives notification of property changes.  If the text field's 'value' 
+     * property changes, the spinner's model is updated accordingly.
+     *
+     * @param event the event.
+     */
+    public void propertyChange(PropertyChangeEvent event)
+    {
+      if (event.getSource() == ftf) 
+        {
+          if (event.getPropertyName().equals("value"))
+            spinner.getModel().setValue(event.getNewValue());
+        }
+    }
+    
+    /**
+     * Receives notification of changes in the state of the {@link JSpinner}
+     * that the editor belongs to - the content of the text field is updated
+     * accordingly.  
+     *
+     * @param event  the change event.
+     */
+    public void stateChanged(ChangeEvent event)
+    {
+      ftf.setValue(spinner.getValue());
+    }
+    
+    /**
+     * This method does nothing.  It is required by the {@link LayoutManager}
+     * interface, but since this component has a single child, there is no
+     * need to use this method.
+     * 
+     * @param child  the child component to remove.
+     */
+    public void removeLayoutComponent(Component child)
+    {
+      // Nothing to do here.
+    }
+
+    /**
+     * This method does nothing.  It is required by the {@link LayoutManager}
+     * interface, but since this component has a single child, there is no
+     * need to use this method.
+     * 
+     * @param name  the name.
+     * @param child  the child component to add.
+     */
+    public void addLayoutComponent(String name, Component child)
+    {
+      // Nothing to do here.
+    }
+  }
+
+  /**
+   * A panel containing a {@link JFormattedTextField} that is configured for
+   * displaying and editing numbers.  The panel is used as a subcomponent of
+   * a {@link JSpinner}.
+   * 
+   * @see JSpinner#createEditor(SpinnerModel)
+   */
+  public static class NumberEditor extends DefaultEditor
+  {
+    /**
+     * For compatability with Sun's JDK
+     */
+    private static final long serialVersionUID = 3791956183098282942L;
+
+    /**
+     * Creates a new <code>NumberEditor</code> object for the specified 
+     * <code>spinner</code>.  The editor is registered with the spinner as a 
+     * {@link ChangeListener}.
+     *
+     * @param spinner the component the editor will be used with.
+     */
+    public NumberEditor(JSpinner spinner)
+    {
+      super(spinner);
+      NumberEditorFormatter nef = new NumberEditorFormatter();
+      nef.setMinimum(getModel().getMinimum());
+      nef.setMaximum(getModel().getMaximum());
+      ftf.setFormatterFactory(new DefaultFormatterFactory(nef));
+    }
+
+    /**
+     * Creates a new <code>NumberEditor</code> object.
+     *
+     * @param spinner  the spinner.
+     * @param decimalFormatPattern  the number format pattern.
+     */
+    public NumberEditor(JSpinner spinner, String decimalFormatPattern)
+    {
+      super(spinner);
+      NumberEditorFormatter nef 
+          = new NumberEditorFormatter(decimalFormatPattern);
+      nef.setMinimum(getModel().getMinimum());
+      nef.setMaximum(getModel().getMaximum());
+      ftf.setFormatterFactory(new DefaultFormatterFactory(nef));
+    }
+
+    /**
+     * Returns the format used by the text field.
+     *
+     * @return The format used by the text field.
+     */
+    public DecimalFormat getFormat()
+    {
+      NumberFormatter formatter = (NumberFormatter) ftf.getFormatter();
+      return (DecimalFormat) formatter.getFormat();
+    }
+
+    /**
+     * Returns the model used by the editor's {@link JSpinner} component,
+     * cast to a {@link SpinnerNumberModel}.
+     * 
+     * @return The model.
+     */
+    public SpinnerNumberModel getModel()
+    {
+      return (SpinnerNumberModel) getSpinner().getModel();
+    }
+  }
+  
+  static class NumberEditorFormatter 
+    extends NumberFormatter
+  {
+    public NumberEditorFormatter() 
+    {
+      super(NumberFormat.getInstance());
+    }
+    public NumberEditorFormatter(String decimalFormatPattern)
+    {
+      super(new DecimalFormat(decimalFormatPattern));
+    }
+  }
+
+  /**
+   * A <code>JSpinner</code> editor used for the {@link SpinnerListModel}.
+   * This editor uses a <code>JFormattedTextField</code> to edit the values
+   * of the spinner.
+   *
+   * @author Roman Kennke (kennke at aicas.com)
+   */
+  public static class ListEditor extends DefaultEditor
+  {
+    /**
+     * Creates a new instance of <code>ListEditor</code>.
+     *
+     * @param spinner the spinner for which this editor is used
+     */
+    public ListEditor(JSpinner spinner)
+    {
+      super(spinner);
+    }
+
+    /**
+     * Returns the spinner's model cast as a {@link SpinnerListModel}.
+     * 
+     * @return The spinner's model.
+     */
+    public SpinnerListModel getModel()
+    {
+      return (SpinnerListModel) getSpinner().getModel();
+    }
+  }
+
+  /**
+   * An editor class for a <code>JSpinner</code> that is used
+   * for displaying and editing dates (e.g. that uses
+   * <code>SpinnerDateModel</code> as model).
+   *
+   * The editor uses a {@link JTextField} with the value
+   * displayed by a {@link DateFormatter} instance.
+   */
+  public static class DateEditor extends DefaultEditor
+  {
+
+    /** The serialVersionUID. */
+    private static final long serialVersionUID = -4279356973770397815L;
+
+    /**
+     * Creates a new instance of DateEditor for the specified
+     * <code>JSpinner</code>.
+     *
+     * @param spinner the <code>JSpinner</code> for which to
+     *     create a <code>DateEditor</code> instance
+     */
+    public DateEditor(JSpinner spinner)
+    {
+      super(spinner);
+      DateEditorFormatter nef = new DateEditorFormatter();
+      nef.setMinimum(getModel().getStart());
+      nef.setMaximum(getModel().getEnd());
+      ftf.setFormatterFactory(new DefaultFormatterFactory(nef));
+    }
+
+    /**
+     * Creates a new instance of DateEditor for the specified
+     * <code>JSpinner</code> using the specified date format
+     * pattern.
+     *
+     * @param spinner the <code>JSpinner</code> for which to
+     *     create a <code>DateEditor</code> instance
+     * @param dateFormatPattern the date format to use
+     *
+     * @see SimpleDateFormat#SimpleDateFormat(String)
+     */
+    public DateEditor(JSpinner spinner, String dateFormatPattern)
+    {
+      super(spinner);
+      DateEditorFormatter nef = new DateEditorFormatter(dateFormatPattern);
+      nef.setMinimum(getModel().getStart());
+      nef.setMaximum(getModel().getEnd());
+      ftf.setFormatterFactory(new DefaultFormatterFactory(nef));
+    }
+
+    /**
+     * Returns the <code>SimpleDateFormat</code> instance that is used to
+     * format the date value.
+     *
+     * @return the <code>SimpleDateFormat</code> instance that is used to
+     *     format the date value
+     */
+    public SimpleDateFormat getFormat()
+    {
+      DateFormatter formatter = (DateFormatter) ftf.getFormatter();
+      return (SimpleDateFormat) formatter.getFormat();
+    }
+
+    /**
+     * Returns the {@link SpinnerDateModel} that is edited by this editor.
+     *
+     * @return the <code>SpinnerDateModel</code> that is edited by this editor
+     */
+    public SpinnerDateModel getModel()
+    {
+      return (SpinnerDateModel) getSpinner().getModel();
+    }
+  }
+
+  static class DateEditorFormatter 
+    extends DateFormatter
+  {
+    public DateEditorFormatter() 
+    {
+      super(DateFormat.getInstance());
+    }
+    public DateEditorFormatter(String dateFormatPattern)
+    {
+      super(new SimpleDateFormat(dateFormatPattern));
+    }
+  }
+
+  /** 
+   * A listener that forwards {@link ChangeEvent} notifications from the model
+   * to the {@link JSpinner}'s listeners. 
+   */
+  class ModelListener implements ChangeListener
+  {
+    /**
+     * Creates a new listener.
+     */
+    public ModelListener()
+    {
+      // nothing to do here
+    }
+    
+    /**
+     * Receives notification from the model that its state has changed.
+     * 
+     * @param event  the event (ignored).
+     */
+    public void stateChanged(ChangeEvent event)
+    {
+      fireStateChanged();
+    }
+  }
+
+  /** 
+   * The model that defines the current value and permitted values for the 
+   * spinner. 
+   */
+  private SpinnerModel model;
+
+  /** The current editor. */
+  private JComponent editor;
+
+  private static final long serialVersionUID = 3412663575706551720L;
+
+  /**
+   * Creates a new <code>JSpinner</code> with default instance of 
+   * {@link SpinnerNumberModel} (that is, a model with value 0, step size 1, 
+   * and no upper or lower limit).
+   *
+   * @see javax.swing.SpinnerNumberModel
+   */
+  public JSpinner()
+  {
+    this(new SpinnerNumberModel());
+  }
+
+  /**
+   * Creates a new <code>JSpinner with the specified model.  The 
+   * {@link #createEditor(SpinnerModel)} method is used to create an editor
+   * that is suitable for the model.
+   *
+   * @param model the model (<code>null</code> not permitted).
+   * 
+   * @throws NullPointerException if <code>model</code> is <code>null</code>.
+   */
+  public JSpinner(SpinnerModel model)
+  {
+    this.model = model;
+    this.editor = createEditor(model);
+    model.addChangeListener(new ModelListener());
+    updateUI();
+  }
+
+  /**
+   * If the editor is <code>JSpinner.DefaultEditor</code>, then forwards the
+   * call to it, otherwise do nothing.
+   *
+   * @throws ParseException DOCUMENT ME!
+   */
+  public void commitEdit() throws ParseException
+  {
+    if (editor instanceof DefaultEditor)
+      ((DefaultEditor) editor).commitEdit();
+  }
+
+  /**
+   * Gets the current editor
+   *
+   * @return the current editor
+   *
+   * @see #setEditor
+   */
+  public JComponent getEditor()
+  {
+    return editor;
+  }
+
+  /**
+   * Changes the current editor to the new editor. The old editor is
+   * removed from the spinner's {@link ChangeEvent} list.
+   *
+   * @param editor the new editor (<code>null</code> not permitted.
+   *
+   * @throws IllegalArgumentException if <code>editor</code> is 
+   *                                  <code>null</code>.
+   *
+   * @see #getEditor
+   */
+  public void setEditor(JComponent editor)
+  {
+    if (editor == null)
+      throw new IllegalArgumentException("editor may not be null");
+
+    JComponent oldEditor = this.editor;
+    if (oldEditor instanceof DefaultEditor)
+      ((DefaultEditor) oldEditor).dismiss(this);
+    else if (oldEditor instanceof ChangeListener)
+      removeChangeListener((ChangeListener) oldEditor);
+    
+    this.editor = editor;
+    firePropertyChange("editor", oldEditor, editor);
+  }
+
+  /**
+   * Returns the model used by the {@link JSpinner} component.
+   *
+   * @return The model.
+   * 
+   * @see #setModel(SpinnerModel)
+   */
+  public SpinnerModel getModel()
+  {
+    return model;
+  }
+
+  /**
+   * Sets a new underlying model.
+   *
+   * @param newModel the new model to set
+   *
+   * @exception IllegalArgumentException if newModel is <code>null</code>
+   */
+  public void setModel(SpinnerModel newModel)
+  {
+    if (newModel == null)
+      throw new IllegalArgumentException();
+    
+    if (model == newModel)
+      return;
+
+    SpinnerModel oldModel = model;
+    model = newModel;
+    firePropertyChange("model", oldModel, newModel);
+    setEditor(createEditor(model));
+  }
+
+  /**
+   * Gets the next value without changing the current value.
+   *
+   * @return the next value
+   *
+   * @see javax.swing.SpinnerModel#getNextValue
+   */
+  public Object getNextValue()
+  {
+    return model.getNextValue();
+  }
+
+  /**
+   * Gets the previous value without changing the current value.
+   *
+   * @return the previous value
+   *
+   * @see javax.swing.SpinnerModel#getPreviousValue
+   */
+  public Object getPreviousValue()
+  {
+    return model.getPreviousValue();
+  }
+
+  /**
+   * Gets the <code>SpinnerUI</code> that handles this spinner
+   *
+   * @return the <code>SpinnerUI</code>
+   */
+  public SpinnerUI getUI()
+  {
+    return (SpinnerUI) ui;
+  }
+
+  /**
+   * Gets the current value of the spinner, according to the underly model,
+   * not the UI.
+   *
+   * @return the current value
+   *
+   * @see javax.swing.SpinnerModel#getValue
+   */
+  public Object getValue()
+  {
+    return model.getValue();
+  }
+
+  /**
+   * Sets the value in the model.
+   *
+   * @param value the new value.
+   */
+  public void setValue(Object value)
+  {
+    model.setValue(value);
+  }
+
+  /**
+   * Returns the ID that identifies which look and feel class will be
+   * the UI delegate for this spinner.
+   *
+   * @return <code>"SpinnerUI"</code>.
+   */
+  public String getUIClassID()
+  {
+    return "SpinnerUI";
+  }
+
+  /**
+   * This method resets the spinner's UI delegate to the default UI for the
+   * current look and feel.
+   */
+  public void updateUI()
+  {
+    setUI((SpinnerUI) UIManager.getUI(this));
+  }
+
+  /**
+   * Sets the UI delegate for the component.
+   *
+   * @param ui The spinner's UI delegate.
+   */
+  public void setUI(SpinnerUI ui)
+  {
+    super.setUI(ui);
+  }
+
+  /**
+   * Adds a <code>ChangeListener</code>
+   *
+   * @param listener the listener to add
+   */
+  public void addChangeListener(ChangeListener listener)
+  {
+    listenerList.add(ChangeListener.class, listener);
+  }
+
+  /**
+   * Remove a particular listener
+   *
+   * @param listener the listener to remove
+   */
+  public void removeChangeListener(ChangeListener listener)
+  {
+    listenerList.remove(ChangeListener.class, listener);
+  }
+
+  /**
+   * Gets all the <code>ChangeListener</code>s
+   *
+   * @return all the <code>ChangeListener</code>s
+   */
+  public ChangeListener[] getChangeListeners()
+  {
+    return (ChangeListener[]) listenerList.getListeners(ChangeListener.class);
+  }
+
+  /**
+   * Fires a <code>ChangeEvent</code> to all the <code>ChangeListener</code>s
+   * added to this <code>JSpinner</code>
+   */
+  protected void fireStateChanged()
+  {
+    ChangeEvent evt = new ChangeEvent(this);
+    ChangeListener[] listeners = getChangeListeners();
+
+    for (int i = 0; i < listeners.length; ++i)
+      listeners[i].stateChanged(evt);
+  }
+
+  /**
+   * Creates an editor that is appropriate for the specified <code>model</code>.
+   *
+   * @param model the model.
+   *
+   * @return The editor.
+   */
+  protected JComponent createEditor(SpinnerModel model)
+  {
+    if (model instanceof SpinnerDateModel)
+      return new DateEditor(this);
+    else if (model instanceof SpinnerNumberModel)
+      return new NumberEditor(this);
+    else if (model instanceof SpinnerListModel)
+      return new ListEditor(this);
+    else
+      return new DefaultEditor(this);
+  }
+}

Added: llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JSplitPane.java
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JSplitPane.java?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JSplitPane.java (added)
+++ llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JSplitPane.java Thu Nov  8 16:56:19 2007
@@ -0,0 +1,946 @@
+/* JSplitPane.java -- 
+   Copyright (C) 2004, 2006,  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;
+
+import java.awt.Component;
+import java.awt.Graphics;
+import java.beans.PropertyChangeEvent;
+
+import javax.accessibility.Accessible;
+import javax.accessibility.AccessibleContext;
+import javax.accessibility.AccessibleRole;
+import javax.accessibility.AccessibleState;
+import javax.accessibility.AccessibleStateSet;
+import javax.accessibility.AccessibleValue;
+import javax.swing.plaf.SplitPaneUI;
+
+/**
+ * This class implements JSplitPane. It is used to divide two components. By
+ * dragging the SplitPane's divider, the user can resize the two components.
+ * Note that the divider cannot resize a component to smaller than it's
+ * minimum size.
+ */
+public class JSplitPane extends JComponent implements Accessible
+{
+
+  /**
+   * Provides the accessibility features for the <code>JSplitPane</code>
+   * component.
+   */
+  protected class AccessibleJSplitPane extends JComponent.AccessibleJComponent
+    implements AccessibleValue
+  {
+  private static final long serialVersionUID = -1788116871416305366L;
+  
+    /**
+     * Creates a new <code>AccessibleJSplitPane</code> instance.
+     */
+    protected AccessibleJSplitPane()
+    {
+      // Nothing to do here.
+    }
+
+    /**
+     * Returns a set containing the current state of the {@link JSplitPane} 
+     * component.
+     *
+     * @return The accessible state set.
+     */
+    public AccessibleStateSet getAccessibleStateSet()
+    {
+      AccessibleStateSet result = super.getAccessibleStateSet();
+      if (getOrientation() == HORIZONTAL_SPLIT)
+        {
+          result.add(AccessibleState.HORIZONTAL);
+        }
+      else if (getOrientation() == VERTICAL_SPLIT)
+        {
+          result.add(AccessibleState.VERTICAL);
+        }
+      return result;
+    }
+
+    /**
+     * Returns the accessible role for the <code>JSplitPane</code> component.
+     *
+     * @return {@link AccessibleRole#SPLIT_PANE}.
+     */
+    public AccessibleRole getAccessibleRole()
+    {
+      return AccessibleRole.SPLIT_PANE;
+    }
+
+    /**
+     * Returns an object that provides access to the current, minimum and 
+     * maximum values for the {@link JSplitPane}.  Since this class implements 
+     * {@link AccessibleValue}, it returns itself.
+     *
+     * @return The accessible value.
+     */
+    public AccessibleValue getAccessibleValue()
+    {
+      return this;
+    }
+
+    /**
+     * Returns the current divider location for the {@link JSplitPane} 
+     * component, as an {@link Integer}.
+     *
+     * @return The current divider location.
+     */
+    public Number getCurrentAccessibleValue()
+    {
+      return new Integer(getDividerLocation());
+    }
+
+    /**
+     * Sets the divider location for the {@link JSplitPane} component and sends 
+     * a {@link PropertyChangeEvent} (with the property name 
+     * {@link AccessibleContext#ACCESSIBLE_VALUE_PROPERTY}) to all registered
+     * listeners.  If the supplied value is <code>null</code>, this method 
+     * does nothing and returns <code>false</code>.
+     *
+     * @param value  the new divider location (<code>null</code> permitted).
+     *
+     * @return <code>true</code> if the divider location value is updated, and 
+     *     <code>false</code> otherwise.
+     */
+    public boolean setCurrentAccessibleValue(Number value)
+    {
+      if (value == null)
+        return false;
+      Number oldValue = getCurrentAccessibleValue();
+      setDividerLocation(value.intValue());
+      firePropertyChange(AccessibleContext.ACCESSIBLE_VALUE_PROPERTY, oldValue, 
+                         new Integer(value.intValue()));
+      return true;
+    }
+
+    /**
+     * Returns the minimum divider location for the {@link JSplitPane} 
+     * component, as an {@link Integer}.
+     *
+     * @return The minimum divider location.
+     */
+    public Number getMinimumAccessibleValue()
+    {
+      return new Integer(getMinimumDividerLocation());
+    }
+
+    /**
+     * Returns the maximum divider location for the {@link JSplitPane} 
+     * component, as an {@link Integer}.
+     *
+     * @return The maximum divider location.
+     */
+    public Number getMaximumAccessibleValue()
+    {
+      return new Integer(getMaximumDividerLocation());
+    }
+  }
+
+  private static final long serialVersionUID = -5634142046175988380L;
+  
+  /** The constraints string used to add components to the bottom. */
+  public static final String BOTTOM = "bottom";
+
+  /** The property fired when the continuousLayout property changes. */
+  public static final String CONTINUOUS_LAYOUT_PROPERTY = "continuousLayout";
+
+  /** The property fired when the divider property changes. */
+  public static final String DIVIDER = "divider";
+
+  /** The property fired when the divider location property changes. */
+  public static final String DIVIDER_LOCATION_PROPERTY = "dividerLocation";
+
+  /** The property fired when the divider size property changes. */
+  public static final String DIVIDER_SIZE_PROPERTY = "dividerSize";
+
+  /**
+   * The value of the orientation when the components are split horizontally.
+   */
+  public static final int HORIZONTAL_SPLIT = 1;
+
+  /** The property fired when the last divider location property changes. */
+  public static final String LAST_DIVIDER_LOCATION_PROPERTY = 
+    "lastDividerLocation";
+
+  /** The constraints string used to add components to the left. */
+  public static final String LEFT = "left";
+
+  /** The property fired when the one touch expandable property changes. */
+  public static final String ONE_TOUCH_EXPANDABLE_PROPERTY = 
+    "oneTouchExpandable";
+
+  /** The property fired when the orientation property changes. */
+  public static final String ORIENTATION_PROPERTY = "orientation";
+
+  /** The property fired when the resize weight property changes. */
+  public static final String RESIZE_WEIGHT_PROPERTY = "resizeWeight";
+
+  /** The constraints string used to add components to the right. */
+  public static final String RIGHT = "right";
+
+  /** The constraints string used to add components to the top. */
+  public static final String TOP = "top";
+
+  /** The value of the orientation when the components are split vertically. */
+  public static final int VERTICAL_SPLIT = 0;
+
+  /** Whether the JSplitPane uses continuous layout. */
+  protected boolean continuousLayout;
+
+  /** Whether the JSplitPane uses one touch expandable buttons. */
+  protected boolean oneTouchExpandable = false;
+
+  // This is the master dividerSize variable and sets the 
+  // BasicSplitPaneDivider one accordingly
+
+  /** The size of the divider. */
+  protected int dividerSize = 10;
+
+  /** The last location of the divider given by the UI. */
+  protected int lastDividerLocation;
+
+  /** The orientation of the JSplitPane. */
+  protected int orientation;
+
+  /** The component on the top or left. */
+  protected Component leftComponent;
+
+  /** The component on the right or bottom. */
+  protected Component rightComponent;
+
+  /** Determines how extra space should be allocated. */
+  private transient double resizeWeight;
+
+  /**
+   * Indicates if the dividerSize property has been set by a client program or
+   * by the UI.
+   *
+   * @see #setUIProperty(String, Object)
+   * @see LookAndFeel#installProperty(JComponent, String, Object)
+   */
+  private boolean clientDividerSizeSet = false;
+
+  /**
+   * Indicates if the oneTouchExpandable property has been set by a client
+   * program or by the UI.
+   *
+   * @see #setUIProperty(String, Object)
+   * @see LookAndFeel#installProperty(JComponent, String, Object)
+   */
+  private boolean clientOneTouchExpandableSet = false;
+
+  /**
+   * Creates a new JSplitPane object with the given orientation, layout mode,
+   * and left and right components.
+   *
+   * @param newOrientation The orientation to use.
+   * @param newContinuousLayout The layout mode to use.
+   * @param newLeftComponent The left component.
+   * @param newRightComponent The right component.
+   *
+   * @throws IllegalArgumentException DOCUMENT ME!
+   */
+  public JSplitPane(int newOrientation, boolean newContinuousLayout,
+                    Component newLeftComponent, Component newRightComponent)
+  {
+    if (newOrientation != HORIZONTAL_SPLIT && newOrientation != VERTICAL_SPLIT)
+      throw new IllegalArgumentException("orientation is invalid.");
+    orientation = newOrientation;
+    continuousLayout = newContinuousLayout;
+    setLeftComponent(newLeftComponent);
+    setRightComponent(newRightComponent);
+
+    updateUI();
+  }
+
+  /**
+   * Creates a new JSplitPane object using nonContinuousLayout mode, the given
+   * orientation and left and right components.
+   *
+   * @param newOrientation The orientation to use.
+   * @param newLeftComponent The left component.
+   * @param newRightComponent The right component.
+   */
+  public JSplitPane(int newOrientation, Component newLeftComponent,
+                    Component newRightComponent)
+  {
+    this(newOrientation, false, newLeftComponent, newRightComponent);
+  }
+
+  /**
+   * Creates a new JSplitPane object with the given layout mode and
+   * orientation.
+   *
+   * @param newOrientation The orientation to use.
+   * @param newContinuousLayout The layout mode to use.
+   */
+  public JSplitPane(int newOrientation, boolean newContinuousLayout)
+  {
+    this(newOrientation, newContinuousLayout, null, null);
+  }
+
+  /**
+   * Creates a new JSplitPane object using a nonContinuousLayout mode and the
+   * given orientation.
+   *
+   * @param newOrientation The orientation to use.
+   */
+  public JSplitPane(int newOrientation)
+  {
+    this(newOrientation, false, null, null);
+  }
+
+  /**
+   * Creates a new JSplitPane object using HORIZONTAL_SPLIT and a
+   * nonContinuousLayout mode.
+   */
+  public JSplitPane()
+  {
+    this(HORIZONTAL_SPLIT, false, new JButton("left button"),
+         new JButton("right button"));
+  }
+
+  /**
+   * This method adds a component to the JSplitPane. The constraints object is
+   * a string that identifies where this component should go. If the
+   * constraints is not a known one, it will throw an
+   * IllegalArgumentException. The valid constraints are LEFT, TOP, RIGHT,
+   * BOTTOM and DIVIDER.
+   *
+   * @param comp The component to add.
+   * @param constraints The constraints string to use.
+   * @param index Where to place to component in the list of components.
+   *
+   * @throws IllegalArgumentException When the constraints is not a known 
+   * identifier.
+   */
+  protected void addImpl(Component comp, Object constraints, int index)
+  {
+    int left = 0;
+    int right = 1;
+    int div = 2;
+    int place;
+    if (constraints == null)
+      {
+        if (leftComponent == null)
+          constraints = LEFT;
+        else if (rightComponent == null)
+          constraints = RIGHT;
+      }
+
+    if (constraints instanceof String)
+      {
+        String placement = (String) constraints;
+
+        if (placement.equals(BOTTOM) || placement.equals(RIGHT))
+          {
+            if (rightComponent != null)
+              remove(rightComponent);
+            rightComponent = comp;
+          }
+        else if (placement.equals(LEFT) || placement.equals(TOP))
+          {
+            if (leftComponent != null)
+              remove(leftComponent);
+            leftComponent = comp;
+          }
+        else if (placement.equals(DIVIDER))
+          constraints = null;
+        else
+          throw new 
+            IllegalArgumentException("Constraints is not a known identifier.");
+
+        // If no dividerLocation has been set, then we need to trigger an
+        // initial layout.
+        if (getDividerLocation() != -1)
+          resetToPreferredSizes();
+
+        super.addImpl(comp, constraints, index);
+      }
+  }
+
+  /**
+   * Returns the object that provides accessibility features for this
+   * <code>JSplitPane</code> component.
+   *
+   * @return The accessible context (an instance of 
+   *     {@link AccessibleJSplitPane}).
+   */
+  public AccessibleContext getAccessibleContext()
+  {
+    if (accessibleContext == null)
+      accessibleContext = new AccessibleJSplitPane();
+    
+    return accessibleContext;
+  }
+
+  /**
+   * This method returns the bottom component.
+   *
+   * @return The bottom component.
+   */
+  public Component getBottomComponent()
+  {
+    return rightComponent;
+  }
+
+  /**
+   * This method returns the location of the divider. This method is passed to
+   * the UI.
+   *
+   * @return The location of the divider.
+   */
+  public int getDividerLocation()
+  {
+    if (ui != null)
+      return ((SplitPaneUI) ui).getDividerLocation(this);
+    else
+      return -1;
+  }
+
+  /**
+   * This method returns the size of the divider.
+   *
+   * @return The size of the divider.
+   */
+  public int getDividerSize()
+  {
+    return dividerSize;
+  }
+
+  /**
+   * This method returns the last divider location.
+   *
+   * @return The last divider location.
+   */
+  public int getLastDividerLocation()
+  {
+    return lastDividerLocation;
+  }
+
+  /**
+   * This method returns the left component.
+   *
+   * @return The left component.
+   */
+  public Component getLeftComponent()
+  {
+    return leftComponent;
+  }
+
+  /**
+   * This method returns the maximum divider location. This method is passed
+   * to  the UI.
+   *
+   * @return DOCUMENT ME!
+   */
+  public int getMaximumDividerLocation()
+  {
+    if (ui != null)
+      return ((SplitPaneUI) ui).getMaximumDividerLocation(this);
+    else
+      return -1;
+  }
+
+  /**
+   * This method returns the minimum divider location. This method is passed
+   * to the UI.
+   *
+   * @return The minimum divider location.
+   */
+  public int getMinimumDividerLocation()
+  {
+    if (ui != null)
+      return ((SplitPaneUI) ui).getMinimumDividerLocation(this);
+    else
+      return -1;
+  }
+
+  /**
+   * This method returns the orientation that the JSplitPane is using.
+   *
+   * @return The current orientation.
+   */
+  public int getOrientation()
+  {
+    return orientation;
+  }
+
+  /**
+   * This method returns the current resize weight.
+   *
+   * @return The current resize weight.
+   */
+  public double getResizeWeight()
+  {
+    return resizeWeight;
+  }
+
+  /**
+   * This method returns the right component.
+   *
+   * @return The right component.
+   */
+  public Component getRightComponent()
+  {
+    return rightComponent;
+  }
+
+  /**
+   * This method returns the top component.
+   *
+   * @return The top component.
+   */
+  public Component getTopComponent()
+  {
+    return leftComponent;
+  }
+
+  /**
+   * This method returns the UI.
+   *
+   * @return The UI.
+   */
+  public SplitPaneUI getUI()
+  {
+    return (SplitPaneUI) ui;
+  }
+
+  /**
+   * This method returns true if the JSplitPane is using a continuousLayout.
+   *
+   * @return True if using a continuousLayout.
+   */
+  public boolean isContinuousLayout()
+  {
+    return continuousLayout;
+  }
+
+  /**
+   * This method returns true if the divider has one touch expandable buttons.
+   *
+   * @return True if one touch expandable is used.
+   */
+  public boolean isOneTouchExpandable()
+  {
+    return oneTouchExpandable;
+  }
+
+  /**
+   * This method returns true.
+   *
+   * @return true.
+   */
+  public boolean isValidateRoot()
+  {
+    return true;
+  }
+
+  /**
+   * This method overrides JComponent's paintChildren so the UI can be
+   * messaged when the children have finished painting.
+   *
+   * @param g The Graphics object to paint with.
+   */
+  protected void paintChildren(Graphics g)
+  {
+    super.paintChildren(g);
+    if (ui != null)
+      ((SplitPaneUI) ui).finishedPaintingChildren(this, g);
+  }
+
+  /**
+   * Returns an implementation-dependent string describing the attributes of
+   * this <code>JSplitPane</code>.
+   *
+   * @return A string describing the attributes of this <code>JSplitPane</code>
+   *         (never <code>null</code>).
+   */
+  protected String paramString()
+  {
+    // FIXME: the next line can be restored once PR27208 is fixed
+    String superParamStr = ""; //super.paramString();
+    StringBuffer sb = new StringBuffer();
+    sb.append(",continuousLayout=").append(isContinuousLayout());
+    sb.append(",dividerSize=").append(getDividerSize());
+    sb.append(",lastDividerLocation=").append(getLastDividerLocation());
+    sb.append(",oneTouchExpandable=").append(isOneTouchExpandable());
+    sb.append(",orientation=");
+    if (orientation == HORIZONTAL_SPLIT)
+      sb.append("HORIZONTAL_SPLIT");
+    else
+      sb.append("VERTICAL_SPLIT");
+    return superParamStr + sb.toString();
+  }
+
+  /**
+   * This method removes the given component from the JSplitPane.
+   *
+   * @param component The Component to remove.
+   */
+  public void remove(Component component)
+  {
+    if (component == leftComponent)
+      leftComponent = null;
+    else if (component == rightComponent)
+      rightComponent = null;
+    super.remove(component);
+  }
+
+  /**
+   * This method removes the component at the given index.
+   *
+   * @param index The index of the component to remove.
+   */
+  public void remove(int index)
+  {
+    Component component = getComponent(index);
+    if (component == leftComponent)
+      leftComponent = null;
+    else if (component == rightComponent)
+      rightComponent = null;
+    super.remove(index);
+  }
+
+  /**
+   * This method removes all components from the JSplitPane.
+   */
+  public void removeAll()
+  {
+    leftComponent = null;
+    rightComponent = null;
+    super.removeAll();
+  }
+
+  /**
+   * This method resets all children of the JSplitPane to their preferred
+   * sizes.
+   */
+  public void resetToPreferredSizes()
+  {
+    if (ui != null)
+      ((SplitPaneUI) ui).resetToPreferredSizes(this);
+  }
+
+  /**
+   * This method sets the bottom component.
+   *
+   * @param comp The Component to be placed at the bottom.
+   */
+  public void setBottomComponent(Component comp)
+  {
+    if (comp != null)
+      add(comp, BOTTOM);
+    else
+      add(new JButton("right button"), BOTTOM);
+  }
+
+  /**
+   * This method sets the layout mode for the JSplitPane.
+   *
+   * @param newContinuousLayout Whether the JSplitPane is in continuousLayout
+   *        mode.
+   */
+  public void setContinuousLayout(boolean newContinuousLayout)
+  {
+    if (newContinuousLayout != continuousLayout)
+      {
+        boolean oldValue = continuousLayout;
+        continuousLayout = newContinuousLayout;
+        firePropertyChange(CONTINUOUS_LAYOUT_PROPERTY, oldValue,
+                           continuousLayout);
+      }
+  }
+
+  /**
+   * This method sets the location of the divider. A value of 0 sets the
+   * divider to the farthest left. A value of 1 sets the divider to the
+   * farthest right.
+   *
+   * @param proportionalLocation A double that describes the location of the
+   *        divider.
+   *
+   * @throws IllegalArgumentException if <code>proportionalLocation</code> is
+   *     not in the range from 0.0 to 1.0 inclusive.
+   */
+  public void setDividerLocation(double proportionalLocation)
+  {
+    if (proportionalLocation > 1 || proportionalLocation < 0)
+      throw new IllegalArgumentException
+        ("proportion has to be between 0 and 1.");
+
+    int max = ((orientation == HORIZONTAL_SPLIT) ? getWidth() : getHeight())
+              - getDividerSize();
+    setDividerLocation((int) (proportionalLocation * max));
+  }
+
+  /**
+   * This method sets the location of the divider.
+   * 
+   * @param location The location of the divider. The negative value forces to
+   *          compute the new location from the preferred sizes of the split
+   *          pane components.
+   */
+  public void setDividerLocation(int location)
+  {
+    if (ui != null && location != getDividerLocation())
+      {
+        int oldLocation = getDividerLocation();        
+        if (location < 0)
+          ((SplitPaneUI) ui).resetToPreferredSizes(this);
+        else
+            ((SplitPaneUI) ui).setDividerLocation(this, location);
+        
+        firePropertyChange(DIVIDER_LOCATION_PROPERTY, oldLocation, 
+                           getDividerLocation());
+      }
+  }
+
+  /**
+   * This method sets the size of the divider.
+   *
+   * @param newSize The size of the divider.
+   */
+  public void setDividerSize(int newSize)
+  {
+    clientDividerSizeSet = true;
+    if (newSize != dividerSize)
+      {
+        int oldSize = dividerSize;
+        dividerSize = newSize;
+        firePropertyChange(DIVIDER_SIZE_PROPERTY, oldSize, dividerSize);
+      }
+  }
+
+  // This doesn't appear to do anything when set from user side.
+  // so it probably is only used from the UI side to change the
+  // lastDividerLocation var.
+
+  /**
+   * This method sets the last location of the divider.
+   *
+   * @param newLastLocation The last location of the divider.
+   */
+  public void setLastDividerLocation(int newLastLocation)
+  {
+    if (newLastLocation != lastDividerLocation)
+      {
+        int oldValue = lastDividerLocation;
+        lastDividerLocation = newLastLocation;
+        firePropertyChange(LAST_DIVIDER_LOCATION_PROPERTY, oldValue,
+                           lastDividerLocation);
+      }
+  }
+
+  /**
+   * This method sets the left component.
+   *
+   * @param comp The left component.
+   */
+  public void setLeftComponent(Component comp)
+  {    
+    if (comp != null)
+      add(comp, LEFT);
+    else
+      remove (leftComponent);
+  }
+
+  /**
+   * This method sets whether the divider has one touch expandable buttons.
+   * The one touch expandable buttons can expand the size of either component
+   * to the maximum allowed size.
+   *
+   * @param newValue Whether the divider will have one touch expandable
+   *        buttons.
+   */
+  public void setOneTouchExpandable(boolean newValue)
+  {
+    clientOneTouchExpandableSet = true;
+    if (newValue != oneTouchExpandable)
+      {
+        boolean oldValue = oneTouchExpandable;
+        oneTouchExpandable = newValue;
+        firePropertyChange(ONE_TOUCH_EXPANDABLE_PROPERTY, oldValue,
+                           oneTouchExpandable);
+      }
+  }
+
+  /**
+   * Sets the orientation for the <code>JSplitPane</code> and sends a 
+   * {@link PropertyChangeEvent} (with the property name 
+   * {@link #ORIENTATION_PROPERTY}) to all registered listeners.
+   *
+   * @param orientation  the orientation (either {@link #HORIZONTAL_SPLIT}
+   * or {@link #VERTICAL_SPLIT}).
+   *
+   * @throws IllegalArgumentException if <code>orientation</code> is not one of
+   *     the listed values.
+   */
+  public void setOrientation(int orientation)
+  {
+    if (orientation != HORIZONTAL_SPLIT && orientation != VERTICAL_SPLIT)
+      throw new IllegalArgumentException
+        ("orientation must be one of VERTICAL_SPLIT, HORIZONTAL_SPLIT");
+    if (orientation != this.orientation)
+      {
+        int oldOrientation = this.orientation;
+        this.orientation = orientation;
+        firePropertyChange(ORIENTATION_PROPERTY, oldOrientation,
+                           this.orientation);
+      }
+  }
+
+  /**
+   * This method determines how extra space will be distributed among the left
+   * and right components. A value of 0 will allocate all extra space to the
+   * right component. A value of 1 indicates that all extra space will go to
+   * the left component. A value in between 1 and 0 will split the space
+   * accordingly.
+   *
+   * @param value The resize weight.
+   */
+  public void setResizeWeight(double value)
+  {
+    if (value < 0.0 || value > 1.0)
+      throw new IllegalArgumentException("Value outside permitted range.");
+    if (this.resizeWeight != value)
+      { 
+        double old = resizeWeight;
+        resizeWeight = value;
+        firePropertyChange(RESIZE_WEIGHT_PROPERTY, old, value);
+      }
+  }
+
+  /**
+   * This method sets the right component.
+   *
+   * @param comp The right component.
+   */
+  public void setRightComponent(Component comp)
+  {
+    if (comp != null)
+      add(comp, RIGHT);
+    else
+      remove (rightComponent);
+  }
+
+  /**
+   * This method sets the top component.
+   *
+   * @param comp The top component.
+   */
+  public void setTopComponent(Component comp)
+  {
+    if (comp != null)
+      add(comp, TOP);
+    else
+      add(new JButton("left button"), TOP);
+  }
+
+  /**
+   * This method sets the UI used by the JSplitPane.
+   *
+   * @param ui The UI to use.
+   */
+  public void setUI(SplitPaneUI ui)
+  {
+    super.setUI(ui);
+  }
+
+  /**
+   * This method resets the UI to the one specified by the current Look and
+   * Feel.
+   */
+  public void updateUI()
+  {
+    setUI((SplitPaneUI) UIManager.getUI(this));
+  }
+
+  /**
+   * This method returns a string identifier to determine which UI class it
+   * needs.
+   *
+   * @return A string that identifies it's UI class.
+   */
+  public String getUIClassID()
+  {
+    return "SplitPaneUI";
+  }
+
+  /**
+   * Helper method for
+   * {@link LookAndFeel#installProperty(JComponent, String, Object)}.
+   * 
+   * @param propertyName the name of the property
+   * @param value the value of the property
+   *
+   * @throws IllegalArgumentException if the specified property cannot be set
+   *         by this method
+   * @throws ClassCastException if the property value does not match the
+   *         property type
+   * @throws NullPointerException if <code>c</code> or
+   *         <code>propertyValue</code> is <code>null</code>
+   */
+  void setUIProperty(String propertyName, Object value)
+  {
+    if (propertyName.equals("dividerSize"))
+      {
+        if (! clientDividerSizeSet)
+          {
+            setDividerSize(((Integer) value).intValue());
+            clientDividerSizeSet = false;
+          }
+      }
+    else if (propertyName.equals("oneTouchExpandable"))
+      {
+        if (! clientOneTouchExpandableSet)
+          {
+            setOneTouchExpandable(((Boolean) value).booleanValue());
+            clientOneTouchExpandableSet = false;
+          }
+      }
+    else
+      {
+        super.setUIProperty(propertyName, value);
+      }
+  }
+}

Added: llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JTabbedPane.java
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JTabbedPane.java?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JTabbedPane.java (added)
+++ llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JTabbedPane.java Thu Nov  8 16:56:19 2007
@@ -0,0 +1,1719 @@
+/* JTabbedPane.java --
+   Copyright (C) 2002, 2004, 2005, 2006,  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;
+
+import java.awt.Color;
+import java.awt.Component;
+import java.awt.Point;
+import java.awt.Rectangle;
+import java.awt.event.MouseEvent;
+import java.io.Serializable;
+import java.util.Locale;
+import java.util.Vector;
+
+import javax.accessibility.Accessible;
+import javax.accessibility.AccessibleContext;
+import javax.accessibility.AccessibleRole;
+import javax.accessibility.AccessibleSelection;
+import javax.accessibility.AccessibleState;
+import javax.accessibility.AccessibleStateSet;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;
+import javax.swing.plaf.TabbedPaneUI;
+import javax.swing.plaf.UIResource;
+
+/**
+ * This is a container for components where only one component is displayed at
+ * a given time and the displayed component can be switched by clicking on
+ * tabs.
+ * 
+ * <p>
+ * Tabs can be oriented in several ways. They can be above, below, left and
+ * right of the component. Tabs can either wrap around (by creating multiple
+ * rows of tabs) or they can be scrolled (where only a subset of the  tabs
+ * can be seen at once). More tabs can be added by calling the
+ * add/addTab/insertTab methods.
+ * </p>
+ */
+public class JTabbedPane extends JComponent implements Serializable,
+                                                       Accessible,
+                                                       SwingConstants
+{
+  /**
+   * Accessibility support for <code>JTabbedPane</code>.
+   */
+  protected class AccessibleJTabbedPane extends JComponent.AccessibleJComponent
+    implements AccessibleSelection, ChangeListener
+  {
+    /**
+     * The serialization UID.
+     */
+    private static final long serialVersionUID = 7610530885966830483L;
+
+    /**
+     * Creates a new AccessibleJTabbedPane object.
+     */
+    public AccessibleJTabbedPane()
+    {
+      super();
+    }
+
+    /**
+     * Receives notification when the selection state of the
+     * <code>JTabbedPane</code> changes and fires appropriate property change
+     * events to interested listeners.
+     *
+     * @param e the change event describing the change
+     */
+    public void stateChanged(ChangeEvent e)
+    {
+      // I couldn't figure out what else should be done here.
+      Object source = e.getSource();
+      firePropertyChange(AccessibleContext.ACCESSIBLE_SELECTION_PROPERTY,
+                         null, source);
+    }
+
+    /**
+     * Returns the accessible role of the <code>JTabbedPane</code>, which is
+     * {@link AccessibleRole#PAGE_TAB_LIST}.
+     *
+     * @return the accessible role of the <code>JTabbedPane</code>
+     */
+    public AccessibleRole getAccessibleRole()
+    {
+      return AccessibleRole.PAGE_TAB_LIST;
+    }
+
+    /**
+     * Returns the number of accessible child components of the
+     * <code>JTabbedPane</code>.
+     *
+     * @return the number of accessible child components of the
+     *         <code>JTabbedPane</code>
+     */
+    public int getAccessibleChildrenCount()
+    {
+      return getTabCount();
+    }
+
+    /**
+     * Returns the accessible child component at the specified index.
+     *
+     * @param i the index of the child component to fetch
+     *
+     * @return the accessible child component at the specified index
+     */
+    public Accessible getAccessibleChild(int i)
+    {
+      // Testing shows that the reference implementation returns instances
+      // of page here.
+      Accessible child = null;
+      if (i >= 0 && i < tabs.size())
+        child = (Page) tabs.get(i);
+      return child;
+    }
+
+    /**
+     * Returns the current selection state of the <code>JTabbedPane</code>
+     * as AccessibleSelection object.
+     *
+     * @return the current selection state of the <code>JTabbedPane</code>
+     */
+    public AccessibleSelection getAccessibleSelection()
+    {
+      return this;
+    }
+
+    /**
+     * Returns the accessible child component at the specified coordinates.
+     * If there is no child component at this location, then return the
+     * currently selected tab.
+     *
+     * @param p the coordinates at which to look up the child component
+     *
+     * @return the accessible child component at the specified coordinates or
+     *         the currently selected tab if there is no child component at
+     *         this location
+     */
+    public Accessible getAccessibleAt(Point p)
+    {
+      int tabIndex = indexAtLocation(p.x, p.y);
+      if (tabIndex >= 0)
+        return getAccessibleChild(tabIndex);
+      else
+        return getAccessibleSelection(0);
+    }
+
+    /**
+     * Returns the number of selected child components of the
+     * <code>JTabbedPane</code>. The reference implementation appears
+     * to return <code>1</code> always and we do the same. 
+     *
+     * @return <code>1</code>
+     */
+    public int getAccessibleSelectionCount()
+    {
+      return 1;
+    }
+
+    /**
+     * Returns the selected tab, or <code>null</code> if there is no 
+     * selection.
+     *
+     * @param i  the selection index (ignored here).
+     *
+     * @return The selected tab, or <code>null</code>.
+     */
+    public Accessible getAccessibleSelection(int i)
+    {
+      Accessible result = null;
+      int selected = getSelectedIndex();
+      if (selected >= 0)
+        result = (Page) tabs.get(selected);
+      return result;
+    }
+
+    /**
+     * Returns <code>true</code> if the specified child is selected,
+     * and <code>false</code> otherwise.
+     *
+     * @param i the child index.
+     *
+     * @return A boolean.
+     */
+    public boolean isAccessibleChildSelected(int i)
+    {
+      return i == getSelectedIndex();
+    }
+
+    /**
+     * Selects the specified tab.
+     *
+     * @param i  the index of the item to select.
+     */
+    public void addAccessibleSelection(int i)
+    {
+      setSelectedIndex(i);
+    }
+
+    /**
+     * Does nothing - it makes no sense to remove a selection for a
+     * tabbed pane, since one tab must always be selected.
+     *
+     * @param i  the item index.
+     * 
+     * @see #addAccessibleSelection(int)
+     */
+    public void removeAccessibleSelection(int i)
+    {
+      // do nothing
+    }
+
+    /**
+     * Does nothing - it makes no sense to clear the selection for
+     * a tabbed pane, since one tab must always be selected.
+     * 
+     * @see #addAccessibleSelection(int)
+     */
+    public void clearAccessibleSelection()
+    {
+      // do nothing
+    }
+
+    /**
+     * Does nothing - it makes no sense to select all for a tabbed
+     * pane, since only one tab can be selected at a time.
+     * 
+     * @see #addAccessibleSelection(int)
+     */
+    public void selectAllAccessibleSelection()
+    {
+      // do nothing
+    }
+  }
+
+  /**
+   * A helper class that listens for changes to the model.
+   */
+  protected class ModelListener implements ChangeListener, Serializable
+  {
+    private static final long serialVersionUID = 497359819958114132L;
+
+    /**
+     * Creates a new ModelListener object.
+     */
+    protected ModelListener()
+    {
+      // Nothing to do here.
+    }
+
+    /**
+     * This method is called whenever the model  is changed.
+     *
+     * @param e The ChangeEvent that is passed from the model.
+     */
+    public void stateChanged(ChangeEvent e)
+    {
+      // Propagate to our listeners.
+      fireStateChanged();
+    }
+  }
+
+  /**
+   * A private class that holds all the information  for each tab.
+   */
+  private class Page
+    extends AccessibleContext
+    implements Accessible
+  {
+    /** The tooltip string. */
+    private String tip;
+
+    /** The component associated with the tab. */
+    private Component component;
+
+    /** The active icon associated with the tab. */
+    private transient Icon icon;
+
+    /** The disabled icon associated with the tab. */
+    private transient Icon disabledIcon;
+
+    /** The tab's enabled status. */
+    private transient boolean enabled = true;
+
+    /** The string painted on the tab. */
+    private transient String title;
+
+    /** The background color of the tab. */
+    private transient Color bg;
+
+    /** The foreground color of the tab. */
+    private transient Color fg;
+
+    /** The mnemonic associated with the tab. */
+    private transient int mnemonicKey;
+
+    /** The index of the underlined character in the string. */
+    private transient int underlinedChar = -1;
+
+    /**
+     * Creates a new data storage for the tab.
+     *
+     * @param title The string displayed on the tab.
+     * @param icon The active icon displayed on the tab.
+     * @param component The component associated with the tab.
+     * @param tip The tooltip associated with the tab.
+     */
+    protected Page(String title, Icon icon, Component component, String tip)
+    {
+      this.title = title;
+      this.icon = icon;
+      this.component = component;
+      this.tip = tip;
+    }
+
+    /**
+     * This method returns the component associated with the tab.
+     *
+     * @return The component associated with the tab.
+     */
+    public Component getComponent()
+    {
+      return component;
+    }
+
+    /**
+     * This method sets the component associated with the tab.
+     *
+     * @param c The component associated with the tab.
+     */
+    public void setComponent(Component c)
+    {
+      int i = indexOfComponent(component);
+      insertTab(title, icon, c, tip, i);
+      component = c;
+      removeTabAt(i);
+    }
+
+    /**
+     * This method returns the tooltip string.
+     *
+     * @return The tooltip string.
+     */
+    public String getTip()
+    {
+      return tip;
+    }
+
+    /**
+     * This method sets the tooltip string.
+     *
+     * @param tip The tooltip string.
+     */
+    public void setTip(String tip)
+    {
+      this.tip = tip;
+    }
+
+    /**
+     * This method returns the background color.
+     *
+     * @return The background color.
+     */
+    public Color getBackground()
+    {
+      Color background;
+      if (bg == null)
+        background = JTabbedPane.this.getBackground();
+      else
+        background = bg;
+      return background;
+    }
+
+    /**
+     * This method sets the background color.
+     *
+     * @param background The background color.
+     */
+    public void setBackground(Color background)
+    {
+      bg = background;
+    }
+
+    /**
+     * This method returns the foreground color.
+     *
+     * @return The foreground color.
+     */
+    public Color getForeground()
+    {
+      Color foreground;
+      if (fg == null)
+        foreground = JTabbedPane.this.getForeground();
+      else
+        foreground = fg;
+      return foreground;
+    }
+
+    /**
+     * This method sets the foreground color.
+     *
+     * @param foreground The foreground color.
+     */
+    public void setForeground(Color foreground)
+    {
+      fg = foreground;
+    }
+
+    /**
+     * This method returns the title associated with the tab.
+     *
+     * @return The title of the tab.
+     */
+    public String getTitle()
+    {
+      return title;
+    }
+
+    private static final long serialVersionUID = 1614381073220130939L;
+
+    /**
+     * This method sets the title of the tab.
+     *
+     * @param text The title of the tab.
+     */
+    public void setTitle(String text)
+    {
+      title = text;
+      if (title != null && title.length() <= underlinedChar)
+	setDisplayedMnemonicIndex(title.length() - 1);
+    }
+
+    /**
+     * This method returns the active icon.
+     *
+     * @return The active icon.
+     */
+    public Icon getIcon()
+    {
+      return icon;
+    }
+
+    /**
+     * This method sets the active icon.
+     *
+     * @param icon The active icon.
+     */
+    public void setIcon(Icon icon)
+    {
+      this.icon = icon;
+    }
+
+    /**
+     * This method returns the disabled icon.
+     *
+     * @return The disabled icon.
+     */
+    public Icon getDisabledIcon()
+    {
+      if (disabledIcon == null && icon instanceof ImageIcon)
+	setDisabledIcon(icon);
+      return disabledIcon;
+    }
+
+    /**
+     * This method sets the disabled icon.
+     *
+     * @param disabledIcon The disabled icon.
+     */
+    public void setDisabledIcon(Icon disabledIcon)
+    {
+      this.disabledIcon = disabledIcon;
+    }
+
+    /**
+     * This method returns whether the tab is enabled.
+     *
+     * @return Whether the tab is enabled.
+     */
+    public boolean isEnabled()
+    {
+      return enabled;
+    }
+
+    /**
+     * This method sets whether the tab is enabled.
+     *
+     * @param enabled Whether this tab is enabled.
+     */
+    public void setEnabled(boolean enabled)
+    {
+      this.enabled = enabled;
+    }
+
+    /**
+     * This method returns the mnemonic.
+     *
+     * @return The mnemonic.
+     */
+    public int getMnemonic()
+    {
+      return mnemonicKey;
+    }
+
+    /**
+     * This method sets the mnemonic. If the title is set, it will update the
+     * mnemonicIndex.
+     *
+     * @param key The mnemonic.
+     */
+    public void setMnemonic(int key)
+    {
+      setMnemonic((char) key);
+    }
+
+    /**
+     * This method sets the mnemonic. If the title is set, it will update the
+     * mnemonicIndex.
+     *
+     * @param aChar The mnemonic.
+     */
+    public void setMnemonic(char aChar)
+    {
+      mnemonicKey = aChar;
+      if (title != null)
+	setDisplayedMnemonicIndex(title.indexOf(mnemonicKey));
+    }
+
+    /**
+     * This method returns the mnemonicIndex.
+     *
+     * @return The mnemonicIndex.
+     */
+    public int getDisplayedMnemonicIndex()
+    {
+      return underlinedChar;
+    }
+
+    /**
+     * This method sets the mnemonicIndex.
+     *
+     * @param index The mnemonicIndex.
+     *
+     * @throws IllegalArgumentException If index less than -1 || index greater
+     *         or equal to title.length.
+     */
+    public void setDisplayedMnemonicIndex(int index)
+      throws IllegalArgumentException
+    {
+      if (index < -1 || title != null && index >= title.length())
+	throw new IllegalArgumentException();
+
+      if (title == null || mnemonicKey == 0 || (index > -1 && title.charAt(index) != mnemonicKey))
+	index = -1;
+
+      underlinedChar = index;
+    }
+
+    /**
+     * Returns the accessible context, which is this object itself.
+     *
+     * @return the accessible context, which is this object itself
+     */
+    public AccessibleContext getAccessibleContext()
+    {
+      return this;
+    }
+
+    /**
+     * Returns the accessible name for this tab.
+     * 
+     * @return The accessible name.
+     */
+    public String getAccessibleName()
+    {
+      if (accessibleName != null)
+        return accessibleName;
+      else
+        return title;
+    }
+    
+    /**
+     * Returns the accessible role of this tab, which is always
+     * {@link AccessibleRole#PAGE_TAB}.
+     *
+     * @return the accessible role of this tab
+     */
+    public AccessibleRole getAccessibleRole()
+    {
+      return AccessibleRole.PAGE_TAB;
+    }
+
+    /**
+     * Returns the accessible state set of this object.
+     *
+     * @return the accessible state set of this object
+     */
+    public AccessibleStateSet getAccessibleStateSet()
+    {
+      AccessibleContext parentCtx = JTabbedPane.this.getAccessibleContext(); 
+      AccessibleStateSet state = parentCtx.getAccessibleStateSet();
+      state.add(AccessibleState.SELECTABLE);
+      if (component == getSelectedComponent())
+        state.add(AccessibleState.SELECTED);
+      return state;
+    }
+
+    /**
+     * Returns the index of this tab inside its parent.
+     *
+     * @return the index of this tab inside its parent
+     */
+    public int getAccessibleIndexInParent()
+    {
+      // TODO: Not sure if the title is unambiguous, but I can't figure
+      // another way of doing this.
+      return indexOfTab(title);
+    }
+
+    /**
+     * Returns the number of accessible children, which is always one (the
+     * component of this tab).
+     *
+     * @return the number of accessible children
+     */
+    public int getAccessibleChildrenCount()
+    {
+      return 1;
+    }
+
+    /**
+     * Returns the accessible child of this tab, which is the component
+     * displayed by the tab.
+     *
+     * @return the accessible child of this tab
+     */
+    public Accessible getAccessibleChild(int i)
+    {
+      // A quick test shows that this method always returns the component
+      // displayed by the tab, regardless of the index.
+      return (Accessible) component;
+    }
+
+    /**
+     * Returns the locale of this accessible object.
+     *
+     * @return the locale of this accessible object
+     */
+    public Locale getLocale()
+    {
+      // TODO: Is this ok?
+      return Locale.getDefault();
+    }
+  }
+
+  private static final long serialVersionUID = 1614381073220130939L;
+
+  /** The changeEvent used to fire changes to listeners. */
+  protected ChangeEvent changeEvent;
+
+  /** The listener that listens to the model. */
+  protected ChangeListener changeListener;
+
+  /** The model that describes this JTabbedPane. */
+  protected SingleSelectionModel model;
+
+  /** Indicates that the TabbedPane is in scrolling mode. */
+  public static final int SCROLL_TAB_LAYOUT = 1;
+
+  /** Indicates that the TabbedPane is in wrap mode. */
+  public static final int WRAP_TAB_LAYOUT = 0;
+
+  /** The current tabPlacement of the TabbedPane. */
+  protected int tabPlacement = SwingConstants.TOP;
+
+  /** The current tabLayoutPolicy of the TabbedPane. */
+  private transient int layoutPolicy;
+
+  /** The list of tabs associated with the TabbedPane. */
+  transient Vector tabs = new Vector();
+
+  /**
+   * Creates a new JTabbedPane object with tabs on top and using wrap tab
+   * layout.
+   */
+  public JTabbedPane()
+  {
+    this(SwingConstants.TOP, WRAP_TAB_LAYOUT);
+  }
+
+  /**
+   * Creates a new JTabbedPane object using wrap tab layout  and the given
+   * <code>tabPlacement</code>, where <code>tabPlacement</code> can be one
+   * of the following values: {@link #TOP}, {@link #BOTTOM}, {@link #LEFT} or
+   * {@link #RIGHT}.
+   *
+   * @param tabPlacement where the tabs will be placed
+   */
+  public JTabbedPane(int tabPlacement)
+  {
+    this(tabPlacement, WRAP_TAB_LAYOUT);
+  }
+
+  /**
+   * Creates a new JTabbedPane object with the given <code>tabPlacement</code>
+   * and <code>tabLayoutPolicy</code>. The <code>tabPlacement</code> can be one
+   * of the following values: {@link #TOP}, {@link #BOTTOM}, {@link #LEFT} or
+   * {@link #RIGHT}. The <code>tabLayoutPolicy</code> can be either
+   * {@link #SCROLL_TAB_LAYOUT} or {@link #WRAP_TAB_LAYOUT}.
+   *
+   * @param tabPlacement where the tabs will be placed
+   * @param tabLayoutPolicy the way tabs will be placed
+   *
+   * @throws IllegalArgumentException If tabLayoutPolicy or tabPlacement are
+   *         not valid.
+   */
+  public JTabbedPane(int tabPlacement, int tabLayoutPolicy)
+  {
+    if (tabPlacement != TOP && tabPlacement != BOTTOM && tabPlacement != RIGHT
+        && tabPlacement != LEFT)
+      throw new IllegalArgumentException("tabPlacement is not valid.");
+    if (tabLayoutPolicy != SCROLL_TAB_LAYOUT
+        && tabLayoutPolicy != WRAP_TAB_LAYOUT)
+      throw new IllegalArgumentException("tabLayoutPolicy is not valid.");
+    this.tabPlacement = tabPlacement;
+    layoutPolicy = tabLayoutPolicy;
+    
+    changeEvent = new ChangeEvent(this);
+    changeListener = createChangeListener();
+
+    model = new DefaultSingleSelectionModel();
+    model.addChangeListener(changeListener);
+
+    updateUI();
+  }
+
+  /**
+   * This method returns the UI used to display the JTabbedPane.
+   *
+   * @return The UI used to display the JTabbedPane.
+   */
+  public TabbedPaneUI getUI()
+  {
+    return (TabbedPaneUI) ui;
+  }
+
+  /**
+   * This method sets the UI used to display the JTabbedPane.
+   *
+   * @param ui The UI used to display the JTabbedPane.
+   */
+  public void setUI(TabbedPaneUI ui)
+  {
+    super.setUI(ui);
+  }
+
+  /**
+   * This method restores the UI to the defaults given by the UIManager.
+   */
+  public void updateUI()
+  {
+    setUI((TabbedPaneUI) UIManager.getUI(this));
+  }
+
+  /**
+   * This method returns a string identifier that  is used to determine which
+   * UI will be used with  the JTabbedPane.
+   *
+   * @return A string identifier for the UI.
+   */
+  public String getUIClassID()
+  {
+    return "TabbedPaneUI";
+  }
+
+  /**
+   * This method creates a ChangeListener that is used to  listen to the model
+   * for events.
+   *
+   * @return A ChangeListener to listen to the model.
+   */
+  protected ChangeListener createChangeListener()
+  {
+    return new ModelListener();
+  }
+
+  /**
+   * This method adds a ChangeListener to the JTabbedPane.
+   *
+   * @param l The ChangeListener to add.
+   */
+  public void addChangeListener(ChangeListener l)
+  {
+    listenerList.add(ChangeListener.class, l);
+  }
+
+  /**
+   * This method removes a ChangeListener to the JTabbedPane.
+   *
+   * @param l The ChangeListener to remove.
+   */
+  public void removeChangeListener(ChangeListener l)
+  {
+    listenerList.remove(ChangeListener.class, l);
+  }
+
+  /**
+   * This method fires a ChangeEvent to all the JTabbedPane's ChangeListeners.
+   */
+  protected void fireStateChanged()
+  {
+    Object[] changeListeners = listenerList.getListenerList();
+    if (changeEvent == null)
+      changeEvent = new ChangeEvent(this);
+    for (int i = changeListeners.length - 2; i >= 0; i -= 2)
+      {
+	if (changeListeners[i] == ChangeListener.class)
+	  ((ChangeListener) changeListeners[i + 1]).stateChanged(changeEvent);
+      }
+  }
+
+  /**
+   * This method returns all ChangeListeners registered with the JTabbedPane.
+   *
+   * @return The ChangeListeners registered with the JTabbedPane.
+   */
+  public ChangeListener[] getChangeListeners()
+  {
+    return (ChangeListener[]) super.getListeners(ChangeListener.class);
+  }
+
+  /**
+   * This method returns the model used with the JTabbedPane.
+   *
+   * @return The JTabbedPane's model.
+   */
+  public SingleSelectionModel getModel()
+  {
+    return model;
+  }
+
+  /**
+   * This method changes the model property of the JTabbedPane.
+   *
+   * @param model The new model to use with the JTabbedPane.
+   */
+  public void setModel(SingleSelectionModel model)
+  {
+    if (model != this.model)
+      {
+	SingleSelectionModel oldModel = this.model;
+	this.model.removeChangeListener(changeListener);
+	this.model = model;
+	this.model.addChangeListener(changeListener);
+	firePropertyChange("model", oldModel, this.model);
+      }
+  }
+
+  /**
+   * This method returns the tabPlacement.
+   *
+   * @return The tabPlacement used with the JTabbedPane.
+   */
+  public int getTabPlacement()
+  {
+    return tabPlacement;
+  }
+
+  /**
+   * This method changes the tabPlacement property of the JTabbedPane.
+   *
+   * @param tabPlacement The tabPlacement to use.
+   *
+   * @throws IllegalArgumentException If tabPlacement is not one of TOP,
+   *         BOTTOM, LEFT, or RIGHT.
+   */
+  public void setTabPlacement(int tabPlacement)
+  {
+    if (tabPlacement != TOP && tabPlacement != BOTTOM && tabPlacement != RIGHT
+        && tabPlacement != LEFT)
+      throw new IllegalArgumentException("tabPlacement is not valid.");
+    if (tabPlacement != this.tabPlacement)
+      {
+	int oldPlacement = this.tabPlacement;
+	this.tabPlacement = tabPlacement;
+	firePropertyChange("tabPlacement", oldPlacement, this.tabPlacement);
+      }
+  }
+
+  /**
+   * This method returns the tabLayoutPolicy.
+   *
+   * @return The tabLayoutPolicy.
+   */
+  public int getTabLayoutPolicy()
+  {
+    return layoutPolicy;
+  }
+
+  /**
+   * This method changes the tabLayoutPolicy property of the JTabbedPane.
+   *
+   * @param tabLayoutPolicy The tabLayoutPolicy to use.
+   *
+   * @throws IllegalArgumentException If tabLayoutPolicy is not one of
+   *         SCROLL_TAB_LAYOUT or WRAP_TAB_LAYOUT.
+   */
+  public void setTabLayoutPolicy(int tabLayoutPolicy)
+  {
+    if (tabLayoutPolicy != SCROLL_TAB_LAYOUT
+        && tabLayoutPolicy != WRAP_TAB_LAYOUT)
+      throw new IllegalArgumentException("tabLayoutPolicy is not valid.");
+    if (tabLayoutPolicy != layoutPolicy)
+      {
+	int oldPolicy = layoutPolicy;
+	layoutPolicy = tabLayoutPolicy;
+	firePropertyChange("tabLayoutPolicy", oldPolicy, layoutPolicy);
+      }
+  }
+
+  /**
+   * This method returns the index of the tab that is currently selected.
+   *
+   * @return The index of the selected tab.
+   */
+  public int getSelectedIndex()
+  {
+    return model.getSelectedIndex();
+  }
+
+  /**
+   * This method checks the index.
+   *
+   * @param index The index to check.
+   * @param start DOCUMENT ME!
+   * @param end DOCUMENT ME!
+   *
+   * @throws IndexOutOfBoundsException DOCUMENT ME!
+   */
+  private void checkIndex(int index, int start, int end)
+  {
+    if (index < start || index >= end)
+      throw new IndexOutOfBoundsException("Index < " + start + " || Index >= "
+                                          + end);
+  }
+
+  /**
+   * This method sets the selected index. This method will hide the old
+   * component and show the new component.
+   *
+   * @param index The index to set it at.
+   */
+  public void setSelectedIndex(int index)
+  {
+    checkIndex(index, -1, tabs.size());
+    if (index != getSelectedIndex())
+      {
+        // Hiding and showing the involved components
+        // is done by the JTabbedPane's UI.
+	model.setSelectedIndex(index);
+      }
+  }
+
+  /**
+   * This method returns the component at the selected index.
+   *
+   * @return The component at the selected index.
+   */
+  public Component getSelectedComponent()
+  {
+    int selectedIndex = getSelectedIndex();
+    Component selected = null;
+    if (selectedIndex >= 0)
+      selected = getComponentAt(selectedIndex);
+    return selected;
+  }
+
+  /**
+   * This method sets the component at the selected index.
+   *
+   * @param c The component associated with the selected index.
+   */
+  public void setSelectedComponent(Component c)
+  {
+    if (c.getParent() == this)
+      setSelectedIndex(indexOfComponent(c));
+    else
+      setComponentAt(getSelectedIndex(), c);
+  }
+
+  /**
+   * This method inserts tabs into JTabbedPane. This includes adding the
+   * component to the JTabbedPane and hiding it.
+   *
+   * @param title the title of the tab; may be <code>null</code>
+   * @param icon the tab's icon; may be <code>null</code>
+   * @param component the component associated with the tab
+   * @param tip the tooltip for the tab
+   * @param index the index to insert the tab at
+   */
+  public void insertTab(String title, Icon icon, Component component,
+                        String tip, int index)
+  {
+    if (title == null)
+      title = "";
+    Page p = new Page(title, icon, component, tip);
+    tabs.insertElementAt(p, index);
+
+    // Hide the component so we don't see it. Do it before we parent it
+    // so we don't trigger a repaint.
+    if (component != null)
+      {
+	component.hide();
+	super.add(component);
+      }
+
+    if (getSelectedIndex() == -1)
+      setSelectedIndex(0);
+
+    revalidate();
+    repaint();
+  }
+
+  /**
+   * This method adds a tab to the JTabbedPane.
+   *
+   * @param title the title of the tab; may be <code>null</code>
+   * @param icon the icon for the tab; may be <code>null</code>
+   * @param component the associated component
+   * @param tip the associated tooltip
+   */
+  public void addTab(String title, Icon icon, Component component, String tip)
+  {
+    insertTab(title, icon, component, tip, tabs.size());
+  }
+
+  /**
+   * This method adds a tab to the JTabbedPane.
+   *
+   * @param title the title of the tab; may be <code>null</code>
+   * @param icon the icon for the tab; may be <code>null</code>
+   * @param component the associated component
+   */
+  public void addTab(String title, Icon icon, Component component)
+  {
+    insertTab(title, icon, component, null, tabs.size());
+  }
+
+  /**
+   * This method adds a tab to the JTabbedPane.
+   *
+   * @param title the title of the tab; may be <code>null</code>
+   * @param component the associated component
+   */
+  public void addTab(String title, Component component)
+  {
+    insertTab(title, null, component, null, tabs.size());
+  }
+
+  /**
+   * This method adds a tab to the JTabbedPane. The title of the tab is the
+   * Component's name. If the Component is an instance of UIResource, it
+   * doesn't add the tab and instead add the component directly to the
+   * JTabbedPane.
+   *
+   * @param component The associated component.
+   *
+   * @return The Component that was added.
+   */
+  public Component add(Component component)
+  {
+    if (component instanceof UIResource)
+      super.add(component);
+    else
+      insertTab(component.getName(), null, component, null, tabs.size());
+    
+    return component;
+  }
+
+  /**
+   * This method adds a tab to the JTabbedPane. If the Component is an
+   * instance of UIResource, it doesn't add the tab and instead add the
+   * component directly to the JTabbedPane.
+   *
+   * @param title the title of the tab; may be <code>null</code>
+   * @param component the associated component
+   *
+   * @return The Component that was added.
+   */
+  public Component add(String title, Component component)
+  {
+    if (component instanceof UIResource)
+      super.add(component);
+    else
+      insertTab(title, null, component, null, tabs.size());
+    return component;
+  }
+
+  /**
+   * This method adds a tab to the JTabbedPane. If the Component is an
+   * instance of UIResource, it doesn't add the tab and instead add the
+   * component directly to the JTabbedPane.
+   *
+   * @param component The associated component.
+   * @param index The index to insert the tab at.
+   *
+   * @return The Component that was added.
+   */
+  public Component add(Component component, int index)
+  {
+    if (component instanceof UIResource)
+      super.add(component);
+    else
+      insertTab(component.getName(), null, component, null, index);
+    return component;
+  }
+
+  /**
+   * This method adds a tab to the JTabbedPane. If the Component is an
+   * instance of UIResource, it doesn't add the tab and instead add the
+   * component directly to the JTabbedPane. If the constraints object is an
+   * icon, it will be used as the tab's icon. If the constraints object is a
+   * string, we will use it as the title.
+   *
+   * @param component The associated component.
+   * @param constraints The constraints object.
+   */
+  public void add(Component component, Object constraints)
+  {
+    add(component, constraints, tabs.size());
+  }
+
+  /**
+   * This method adds a tab to the JTabbedPane. If the Component is an
+   * instance of UIResource, it doesn't add the tab and instead add the
+   * component directly to the JTabbedPane. If the constraints object is an
+   * icon, it will be used as the tab's icon. If the constraints object is a
+   * string, we will use it as the title.
+   *
+   * @param component The associated component.
+   * @param constraints The constraints object.
+   * @param index The index to insert the tab at.
+   */
+  public void add(Component component, Object constraints, int index)
+  {
+    if (component instanceof UIResource)
+      super.add(component);
+    else
+      {
+	if (constraints instanceof String)
+	  insertTab((String) constraints, null, component, null, index);
+	else
+	  insertTab(component.getName(),
+	            (constraints instanceof Icon) ? (Icon) constraints : null,
+	            component, null, index);
+      }
+  }
+
+  /**
+   * Removes the tab at index. After the component associated with 
+   * index is removed, its visibility is reset to true to ensure it 
+   * will be visible if added to other containers.
+   *
+   * @param index The index of the tab to remove.
+   */
+  public void removeTabAt(int index)
+  {
+    checkIndex(index, 0, tabs.size());
+
+    // We need to adjust the selection if we remove a tab that comes
+    // before the selected tab or if the selected tab is removed.
+    // This decrements the selected index by 1 if any of this is the case.
+    // Note that this covers all cases:
+    // - When the selected tab comes after the removed tab, this simply
+    //   adjusts the selection so that after the removal the selected tab
+    //   is still the same.
+    // - When we remove the currently selected tab, then the tab before the
+    //   selected tab gets selected.
+    // - When the last tab is removed, then we have an index==0, which gets
+    //   decremented to -1, which means no selection, which is 100% perfect.
+    int selectedIndex = getSelectedIndex();
+    if (selectedIndex >= index)
+      setSelectedIndex(selectedIndex - 1);
+
+    Component comp = getComponentAt(index);
+
+    // Remove the tab object.
+    tabs.remove(index);
+
+    // Remove the component. I think we cannot assume that the tab order
+    // is equal to the component order, so we iterate over the children
+    // here to find the and remove the correct component.
+    if (comp != null)
+      {
+        Component[] children = getComponents();
+        for (int i = children.length - 1; i >= 0; --i)
+          {
+            if (children[i] == comp)
+              {
+                super.remove(i);
+                comp.setVisible(true);
+                break;
+              }
+          }
+      }
+    revalidate();
+    repaint();
+  }
+
+  /**
+   * Removes the specified Component from the JTabbedPane.
+   *
+   * @param component The Component to remove.
+   */
+  public void remove(Component component)
+  {
+    // Since components implementing UIResource
+    // are not added as regular tabs by the add()
+    // methods we have to take special care when
+    // removing these object. Especially 
+    // Container.remove(Component) cannot be used
+    // because it will call JTabbedPane.remove(int)
+    // later which is overridden and can only
+    // handle tab components.
+    // This implementation can even cope with a
+    // situation that someone called insertTab()
+    // with a component that implements UIResource.
+    int index = indexOfComponent(component);
+    
+    // If the component is not a tab component
+    // find out its Container-given index
+    // and call that class' implementation
+    // directly.
+    if (index == -1)
+      {
+        Component[] cs = getComponents();
+        for (int i = 0; i< cs.length; i++)
+          if (cs[i] == component)
+            super.remove(i);
+      }
+    else
+      removeTabAt(index);
+  }
+
+  /**
+   * Removes the tab and component which corresponds to the specified index.
+   *
+   * @param index The index of the tab to remove.
+   */
+  public void remove(int index)
+  {
+    removeTabAt(index);
+  }
+
+  /**
+   * This method removes all tabs and associated components from the
+   * JTabbedPane.
+   */
+  public void removeAll()
+  {
+    setSelectedIndex(-1);
+    for (int i = getTabCount() - 1; i >= 0; i--)
+      removeTabAt(i);
+  }
+
+  /**
+   * This method returns how many tabs are in the JTabbedPane.
+   *
+   * @return The number of tabs in the JTabbedPane.
+   */
+  public int getTabCount()
+  {
+    return tabs.size();
+  }
+
+  /**
+   * This method returns the number of runs used  to paint the JTabbedPane.
+   *
+   * @return The number of runs.
+   */
+  public int getTabRunCount()
+  {
+    return ((TabbedPaneUI) ui).getTabRunCount(this);
+  }
+
+  /**
+   * This method returns the tab title given the index.
+   *
+   * @param index The index of the tab.
+   *
+   * @return The title for the tab.
+   */
+  public String getTitleAt(int index)
+  {
+    checkIndex(index, 0, tabs.size());
+    return ((Page) tabs.elementAt(index)).getTitle();
+  }
+
+  /**
+   * This method returns the active icon given the index.
+   *
+   * @param index The index of the tab.
+   *
+   * @return The active icon for the tab.
+   */
+  public Icon getIconAt(int index)
+  {
+    checkIndex(index, 0, tabs.size());
+    return ((Page) tabs.elementAt(index)).getIcon();
+  }
+
+  /**
+   * This method returns the disabled icon given the index.
+   *
+   * @param index The index of the tab.
+   *
+   * @return The disabled icon for the tab.
+   */
+  public Icon getDisabledIconAt(int index)
+  {
+    checkIndex(index, 0, tabs.size());
+    return ((Page) tabs.elementAt(index)).getDisabledIcon();
+  }
+
+  /**
+   * This method returns the tooltip string for the tab.
+   *
+   * @param index The index of the tab.
+   *
+   * @return The tooltip string for the tab.
+   */
+  public String getToolTipTextAt(int index)
+  {
+    checkIndex(index, 0, tabs.size());
+    return ((Page) tabs.elementAt(index)).getTip();
+  }
+
+  /**
+   * This method returns the foreground color for the tab.
+   *
+   * @param index The index of the tab.
+   *
+   * @return The foreground color for the tab.
+   */
+  public Color getForegroundAt(int index)
+  {
+    checkIndex(index, 0, tabs.size());
+    return ((Page) tabs.elementAt(index)).getForeground();
+  }
+
+  /**
+   * This method returns the background color for the tab.
+   *
+   * @param index The index of the tab.
+   *
+   * @return The background color for the tab.
+   */
+  public Color getBackgroundAt(int index)
+  {
+    checkIndex(index, 0, tabs.size());
+    return ((Page) tabs.elementAt(index)).getBackground();
+  }
+
+  /**
+   * This method returns the component associated with the tab.
+   *
+   * @param index The index of the tab.
+   *
+   * @return The component associated with the tab.
+   */
+  public Component getComponentAt(int index)
+  {
+    checkIndex(index, 0, tabs.size());
+    return ((Page) tabs.elementAt(index)).getComponent();
+  }
+
+  /**
+   * This method returns whether this tab is enabled. Disabled tabs cannot be
+   * selected.
+   *
+   * @param index The index of the tab.
+   *
+   * @return Whether the tab is enabled.
+   */
+  public boolean isEnabledAt(int index)
+  {
+    checkIndex(index, 0, tabs.size());
+    return ((Page) tabs.elementAt(index)).isEnabled();
+  }
+
+  /**
+   * This method returns the mnemonic for the tab.
+   *
+   * @param tabIndex The index of the tab.
+   *
+   * @return The mnemonic for the tab.
+   */
+  public int getMnemonicAt(int tabIndex)
+  {
+    checkIndex(tabIndex, 0, tabs.size());
+    return ((Page) tabs.elementAt(tabIndex)).getMnemonic();
+  }
+
+  /**
+   * This method returns the mnemonic index for the tab.
+   *
+   * @param tabIndex The index of the tab.
+   *
+   * @return The mnemonic index for the tab.
+   */
+  public int getDisplayedMnemonicIndexAt(int tabIndex)
+  {
+    checkIndex(tabIndex, 0, tabs.size());
+    return ((Page) tabs.elementAt(tabIndex)).getDisplayedMnemonicIndex();
+  }
+
+  /**
+   * This method returns the bounds of the tab given the index.
+   *
+   * @param index The index of the tab.
+   *
+   * @return A rectangle describing the bounds of the tab.
+   */
+  public Rectangle getBoundsAt(int index)
+  {
+    checkIndex(index, 0, tabs.size());
+    return ((TabbedPaneUI) ui).getTabBounds(this, index);
+  }
+
+  /**
+   * This method sets the title of the tab.
+   *
+   * @param index The index of the tab.
+   * @param title The new title.
+   */
+  public void setTitleAt(int index, String title)
+  {
+    checkIndex(index, 0, tabs.size());
+    ((Page) tabs.elementAt(index)).setTitle(title);
+  }
+
+  /**
+   * This method sets the icon of the tab.
+   *
+   * @param index The index of the tab.
+   * @param icon The new icon.
+   */
+  public void setIconAt(int index, Icon icon)
+  {
+    checkIndex(index, 0, tabs.size());
+    ((Page) tabs.elementAt(index)).setIcon(icon);
+  }
+
+  /**
+   * This method sets the disabled icon of the tab.
+   *
+   * @param index The index of the tab.
+   * @param disabledIcon The new disabled icon.
+   */
+  public void setDisabledIconAt(int index, Icon disabledIcon)
+  {
+    checkIndex(index, 0, tabs.size());
+    ((Page) tabs.elementAt(index)).setDisabledIcon(disabledIcon);
+  }
+
+  /**
+   * This method sets the tooltip text of the tab.
+   *
+   * @param index The index of the tab.
+   * @param toolTipText The tooltip text.
+   */
+  public void setToolTipTextAt(int index, String toolTipText)
+  {
+    checkIndex(index, 0, tabs.size());
+    ((Page) tabs.elementAt(index)).setTip(toolTipText);
+  }
+
+  /**
+   * This method sets the background color of the tab.
+   *
+   * @param index The index of the tab.
+   * @param background The background color of the tab.
+   */
+  public void setBackgroundAt(int index, Color background)
+  {
+    checkIndex(index, 0, tabs.size());
+    ((Page) tabs.elementAt(index)).setBackground(background);
+  }
+
+  /**
+   * This method sets the foreground color of the tab.
+   *
+   * @param index The index of the tab.
+   * @param foreground The foreground color of the tab.
+   */
+  public void setForegroundAt(int index, Color foreground)
+  {
+    checkIndex(index, 0, tabs.size());
+    ((Page) tabs.elementAt(index)).setForeground(foreground);
+  }
+
+  /**
+   * This method sets whether the tab is enabled.
+   *
+   * @param index The index of the tab.
+   * @param enabled Whether the tab is enabled.
+   */
+  public void setEnabledAt(int index, boolean enabled)
+  {
+    checkIndex(index, 0, tabs.size());
+    ((Page) tabs.elementAt(index)).setEnabled(enabled);
+  }
+
+  /**
+   * This method sets the component associated with the tab.
+   *
+   * @param index The index of the tab.
+   * @param component The component associated with the tab.
+   */
+  public void setComponentAt(int index, Component component)
+  {
+    checkIndex(index, 0, tabs.size());
+    ((Page) tabs.elementAt(index)).setComponent(component);
+  }
+
+  /**
+   * This method sets the displayed mnemonic index of the tab.
+   *
+   * @param tabIndex The index of the tab.
+   * @param mnemonicIndex The mnemonic index.
+   */
+  public void setDisplayedMnemonicIndexAt(int tabIndex, int mnemonicIndex)
+  {
+    checkIndex(tabIndex, 0, tabs.size());
+    ((Page) tabs.elementAt(tabIndex)).setDisplayedMnemonicIndex(mnemonicIndex);
+  }
+
+  /**
+   * This method sets the mnemonic for the tab.
+   *
+   * @param tabIndex The index of the tab.
+   * @param mnemonic The mnemonic.
+   */
+  public void setMnemonicAt(int tabIndex, int mnemonic)
+  {
+    checkIndex(tabIndex, 0, tabs.size());
+    ((Page) tabs.elementAt(tabIndex)).setMnemonic(mnemonic);
+  }
+
+  /**
+   * This method finds the index of a tab given the title.
+   *
+   * @param title The title that belongs to a tab.
+   *
+   * @return The index of the tab that has the title or -1 if not found.
+   */
+  public int indexOfTab(String title)
+  {
+    int index = -1;
+    for (int i = 0; i < tabs.size(); i++)
+      {
+	if (((Page) tabs.elementAt(i)).getTitle().equals(title))
+	  {
+	    index = i;
+	    break;
+	  }
+      }
+    return index;
+  }
+
+  /**
+   * This method finds the index of a tab given the icon.
+   *
+   * @param icon The icon that belongs to a tab.
+   *
+   * @return The index of the tab that has the icon or -1 if not found.
+   */
+  public int indexOfTab(Icon icon)
+  {
+    int index = -1;
+    for (int i = 0; i < tabs.size(); i++)
+      {
+	if (((Page) tabs.elementAt(i)).getIcon() == icon)
+	  {
+	    index = i;
+	    break;
+	  }
+      }
+    return index;
+  }
+
+  /**
+   * This method finds the index of a tab given the component.
+   *
+   * @param component A component associated with a tab.
+   *
+   * @return The index of the tab that has this component or -1 if not found.
+   */
+  public int indexOfComponent(Component component)
+  {
+    int index = -1;
+    for (int i = 0; i < tabs.size(); i++)
+      {
+	if (((Page) tabs.elementAt(i)).getComponent() == component)
+	  {
+	    index = i;
+	    break;
+	  }
+      }
+    return index;
+  }
+
+  /**
+   * This method returns a tab index given an (x,y) location. The origin of
+   * the (x,y) pair will be the JTabbedPane's top left position. The  tab
+   * returned will be the one that contains the point. This method is
+   * delegated to the UI.
+   *
+   * @param x The x coordinate of the point.
+   * @param y The y coordinate of the point.
+   *
+   * @return The index of the tab that contains the point.
+   */
+  public int indexAtLocation(int x, int y)
+  {
+    return ((TabbedPaneUI) ui).tabForCoordinate(this, x, y);
+  }
+
+  /**
+   * This method returns the tooltip text given a mouse event.
+   *
+   * @param event The mouse event.
+   *
+   * @return The tool tip text that is associated with this mouse event.
+   */
+  public String getToolTipText(MouseEvent event)
+  {
+    int index = indexAtLocation(event.getX(), event.getY());
+    return ((Page) tabs.elementAt(index)).getTip();
+  }
+
+  /**
+   * Returns a string describing the attributes for the 
+   * <code>JTabbedPane</code> component, for use in debugging.  The return 
+   * value is guaranteed to be non-<code>null</code>, but the format of the 
+   * string may vary between implementations.
+   *
+   * @return A string describing the attributes of the 
+   *     <code>JTabbedPane</code>.
+   */
+  protected String paramString()
+  {
+    StringBuffer sb = new StringBuffer(super.paramString());
+    sb.append(",tabPlacement=");
+    if (tabPlacement == TOP)
+      sb.append("TOP");
+    if (tabPlacement == BOTTOM)
+      sb.append("BOTTOM");
+    if (tabPlacement == LEFT)
+      sb.append("LEFT");
+    if (tabPlacement == RIGHT)
+      sb.append("RIGHT");
+    return sb.toString();
+  }
+
+  /**
+   * Returns the object that provides accessibility features for this
+   * <code>JTabbedPane</code> component.
+   *
+   * @return The accessible context (an instance of 
+   *         {@link AccessibleJTabbedPane}).
+   */
+  public AccessibleContext getAccessibleContext()
+  {
+    if (accessibleContext == null)
+      {
+        AccessibleJTabbedPane ctx = new AccessibleJTabbedPane();
+        addChangeListener(ctx);
+        accessibleContext = ctx;
+      }
+
+    return accessibleContext;
+  }
+}

Added: llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JTable.java
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JTable.java?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JTable.java (added)
+++ llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JTable.java Thu Nov  8 16:56:19 2007
@@ -0,0 +1,5121 @@
+/* JTable.java -- 
+   Copyright (C) 2002, 2004, 2005, 2006  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;
+
+import java.awt.Color;
+import java.awt.Component;
+import java.awt.Cursor;
+import java.awt.Dimension;
+import java.awt.Font;
+import java.awt.FontMetrics;
+import java.awt.Point;
+import java.awt.Rectangle;
+import java.awt.event.FocusListener;
+import java.beans.PropertyChangeEvent;
+import java.beans.PropertyChangeListener;
+import java.text.DateFormat;
+import java.text.NumberFormat;
+import java.util.Date;
+import java.util.EventObject;
+import java.util.Hashtable;
+import java.util.Locale;
+import java.util.Vector;
+
+import javax.accessibility.Accessible;
+import javax.accessibility.AccessibleComponent;
+import javax.accessibility.AccessibleContext;
+import javax.accessibility.AccessibleExtendedTable;
+import javax.accessibility.AccessibleRole;
+import javax.accessibility.AccessibleSelection;
+import javax.accessibility.AccessibleState;
+import javax.accessibility.AccessibleStateSet;
+import javax.accessibility.AccessibleTable;
+import javax.accessibility.AccessibleTableModelChange;
+import javax.swing.event.CellEditorListener;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ListSelectionEvent;
+import javax.swing.event.ListSelectionListener;
+import javax.swing.event.TableColumnModelEvent;
+import javax.swing.event.TableColumnModelListener;
+import javax.swing.event.TableModelEvent;
+import javax.swing.event.TableModelListener;
+import javax.swing.plaf.TableUI;
+import javax.swing.table.DefaultTableCellRenderer;
+import javax.swing.table.DefaultTableColumnModel;
+import javax.swing.table.DefaultTableModel;
+import javax.swing.table.JTableHeader;
+import javax.swing.table.TableCellEditor;
+import javax.swing.table.TableCellRenderer;
+import javax.swing.table.TableColumn;
+import javax.swing.table.TableColumnModel;
+import javax.swing.table.TableModel;
+
+/**
+ * The table component, displaying information, organized in rows and columns.
+ * The table can be placed in the scroll bar and have the optional header
+ * that is always visible. Cell values may be editable after double clicking
+ * on the cell. Cell columns may have various data types, that are 
+ * displayed and edited by the different renderers and editors. It is possible
+ * to set different column width. The columns are also resizeable by 
+ * dragging the column boundary in the header.
+ */
+public class JTable
+  extends JComponent
+  implements TableModelListener, Scrollable, TableColumnModelListener,
+             ListSelectionListener, CellEditorListener, Accessible
+{
+  /**
+   * Provides accessibility support for <code>JTable</code>.
+   *
+   * @author Roman Kennke (kennke at aicas.com)
+   */
+  protected class AccessibleJTable
+    extends AccessibleJComponent
+    implements AccessibleSelection, ListSelectionListener, TableModelListener,
+    TableColumnModelListener, CellEditorListener, PropertyChangeListener,
+    AccessibleExtendedTable
+  {
+
+    /**
+     * Provides accessibility support for table cells.
+     *
+     * @author Roman Kennke (kennke at aicas.com)
+     */
+    protected class AccessibleJTableCell
+      extends AccessibleContext
+      implements Accessible, AccessibleComponent
+    {
+
+      /**
+       * The table of this cell.
+       */
+      private JTable table;
+
+      /**
+       * The row index of this cell.
+       */
+      private int row;
+
+      /**
+       * The column index of this cell.
+       */
+      private int column;
+
+      /**
+       * The index of this cell inside the AccessibleJTable parent.
+       */
+      private int index;
+
+      /**
+       * Creates a new <code>AccessibleJTableCell</code>.
+       *
+       * @param t the table
+       * @param r the row
+       * @param c the column
+       * @param i the index of this cell inside the accessible table parent
+       */
+      public AccessibleJTableCell(JTable t, int r, int c, int i)
+      {
+        table = t;
+        row = r;
+        column = c;
+        index = i;
+      }
+
+      /**
+       * Returns the accessible row for the table cell.
+       *
+       * @return the accessible row for the table cell
+       */
+      public AccessibleRole getAccessibleRole()
+      {
+        // TODO: What is the role of the table cell?
+        // Seems like the RI returns UNKNOWN here for 'normal' cells, might
+        // be different for special renderers though (not tested yet).
+        return AccessibleRole.UNKNOWN;
+      }
+
+      /**
+       * Returns the accessible state set of this accessible table cell.
+       *
+       * @return the accessible state set of this accessible table cell
+       */
+      public AccessibleStateSet getAccessibleStateSet()
+      {
+        AccessibleStateSet state = new AccessibleStateSet();
+
+        // Figure out the SHOWING state.
+        Rectangle visibleRect = getVisibleRect();
+        Rectangle cellRect = getCellRect(row, column, false);
+        if (visibleRect.intersects(cellRect))
+          state.add(AccessibleState.SHOWING);
+
+        // Figure out SELECTED state.
+        if (isCellSelected(row, column))
+          state.add(AccessibleState.SELECTED);
+
+        // Figure out ACTIVE state.
+        if (row == getSelectedRow() && column == getSelectedColumn())
+          state.add(AccessibleState.ACTIVE);
+
+        // TRANSIENT seems to be always set in the RI.
+        state.add(AccessibleState.TRANSIENT);
+
+        // TODO: Any other state to handle here?
+        return state;
+      }
+
+      /**
+       * Returns the index of this cell in the parent object.
+       *
+       * @return the index of this cell in the parent object
+       */
+      public int getAccessibleIndexInParent()
+      {
+        return index;
+      }
+
+      /**
+       * Returns the number of children of this object. Table cells cannot have
+       * children, so we return <code>0</code> here.
+       *
+       * @return <code>0</code>
+       */
+      public int getAccessibleChildrenCount()
+      {
+        return 0;
+      }
+
+      /**
+       * Returns the accessible child at index <code>i</code>. Table cells
+       * don't have children, so we return <code>null</code> here.
+       *
+       * @return <code>null</code>
+       */
+      public Accessible getAccessibleChild(int i)
+      {
+        return null;
+      }
+
+      /**
+       * Returns the locale setting for this accessible table cell.
+       *
+       * @return the locale setting for this accessible table cell
+       */
+      public Locale getLocale()
+      {
+        // TODO: For now, we return english here. This must be fixed as soon
+        // as we have a localized Swing.
+        return Locale.ENGLISH;
+      }
+
+      /**
+       * Returns the accessible context of this table cell. Since accessible
+       * table cells are their own accessible context, we return
+       * <code>this</code>.
+       *
+       * @return the accessible context of this table cell
+       */
+      public AccessibleContext getAccessibleContext()
+      {
+        return this;
+      }
+
+      /**
+       * Returns the background color of this cell.
+       *
+       * @return the background color of this cell
+       */
+      public Color getBackground()
+      {
+        return table.getBackground();
+      }
+
+      /**
+       * Sets the background of the cell. Since table cells cannot have
+       * individual background colors, this method does nothing. Set the
+       * background directly on the table instead.
+       * 
+       * @param color not used
+       */
+      public void setBackground(Color color)
+      {
+        // This method does nothing. See API comments.
+      }
+
+      /**
+       * Returns the foreground color of the table cell.
+       *
+       * @return the foreground color of the table cell
+       */
+      public Color getForeground()
+      {
+        return table.getForeground();
+      }
+
+      /**
+       * Sets the foreground of the cell. Since table cells cannot have
+       * individual foreground colors, this method does nothing. Set the
+       * foreground directly on the table instead.
+       * 
+       * @param color not used
+       */
+      public void setForeground(Color color)
+      {
+        // This method does nothing. See API comments.
+      }
+
+      /**
+       * Returns the cursor for this table cell.
+       *
+       * @return the cursor for this table cell
+       */
+      public Cursor getCursor()
+      {
+        return table.getCursor();
+      }
+
+      /**
+       * Sets the cursor of the cell. Since table cells cannot have
+       * individual cursors, this method does nothing. Set the
+       * cursor directly on the table instead.
+       * 
+       * @param cursor not used
+       */
+      public void setCursor(Cursor cursor)
+      {
+        // This method does nothing. See API comments.
+      }
+
+      /**
+       * Returns the font of the table cell.
+       *
+       * @return the font of the table cell
+       */
+      public Font getFont()
+      {
+        return table.getFont();
+      }
+
+      /**
+       * Sets the font of the cell. Since table cells cannot have
+       * individual fonts, this method does nothing. Set the
+       * font directly on the table instead.
+       * 
+       * @param font not used
+       */
+      public void setFont(Font font)
+      {
+        // This method does nothing. See API comments.
+      }
+
+      /**
+       * Returns the font metrics for a specified font.
+       *
+       * @param font the font for which we return the metrics
+       *
+       * @return the font metrics for a specified font
+       */
+      public FontMetrics getFontMetrics(Font font)
+      {
+        return table.getFontMetrics(font);
+      }
+
+      /**
+       * Returns <code>true</code> if this table cell is enabled,
+       * <code>false</code> otherwise.
+       *
+       * @return <code>true</code> if this table cell is enabled,
+       *         <code>false</code> otherwise
+       */
+      public boolean isEnabled()
+      {
+        return table.isEnabled();
+      }
+
+      /**
+       * Table cells cannot be disabled or enabled individually, so this method
+       * does nothing. Set the enabled flag on the table itself.
+       *
+       * @param b not used here
+       */
+      public void setEnabled(boolean b)
+      {
+        // This method does nothing. See API comments.
+      }
+
+      /**
+       * Returns <code>true</code> if this cell is visible, <code>false</code>
+       * otherwise.
+       *
+       * @return <code>true</code> if this cell is visible, <code>false</code>
+       *         otherwise
+       */
+      public boolean isVisible()
+      {
+        return table.isVisible();
+      }
+
+      /**
+       * The visibility cannot be set on individual table cells, so this method
+       * does nothing. Set the visibility on the table itself.
+       *
+       * @param b not used
+       */
+      public void setVisible(boolean b)
+      {
+        // This method does nothing. See API comments.
+      }
+
+      /**
+       * Returns <code>true</code> if this table cell is currently showing on
+       * screen.
+       *
+       * @return <code>true</code> if this table cell is currently showing on
+       *         screen
+       */
+      public boolean isShowing()
+      {
+        return table.isShowing();
+      }
+
+      /**
+       * Returns <code>true</code> if this table cell contains the location
+       * at <code>point</code>, <code>false</code> otherwise.
+       * <code>point</code> is interpreted as relative to the coordinate system
+       * of the table cell.
+       *
+       * @return <code>true</code> if this table cell contains the location
+       *         at <code>point</code>, <code>false</code> otherwise
+       */
+      public boolean contains(Point point)
+      {
+        Rectangle cellRect = table.getCellRect(row, column, true);
+        cellRect.x = 0;
+        cellRect.y = 0;
+        return cellRect.contains(point);
+      }
+
+      /**
+       * Returns the screen location of the table cell.
+       *
+       * @return the screen location of the table cell
+       */
+      public Point getLocationOnScreen()
+      {
+        Point tableLoc = table.getLocationOnScreen();
+        Rectangle cellRect = table.getCellRect(row, column, true);
+        tableLoc.x += cellRect.x;
+        tableLoc.y += cellRect.y;
+        return tableLoc;
+      }
+
+      /**
+       * Returns the location of this cell relative to the table's bounds.
+       *
+       * @return the location of this cell relative to the table's bounds
+       */
+      public Point getLocation()
+      {
+        Rectangle cellRect = table.getCellRect(row, column, true);
+        return new Point(cellRect.x, cellRect.y);
+      }
+
+      /**
+       * The location of the table cells cannot be manipulated directly, so
+       * this method does nothing.
+       *
+       * @param point not used
+       */
+      public void setLocation(Point point)
+      {
+        // This method does nothing. See API comments.
+      }
+
+      /**
+       * Returns the bounds of the cell relative to its table.
+       *
+       * @return the bounds of the cell relative to its table
+       */
+      public Rectangle getBounds()
+      {
+        return table.getCellRect(row, column, true);
+      }
+
+      /**
+       * The bounds of the table cells cannot be manipulated directly, so
+       * this method does nothing.
+       *
+       * @param rectangle not used
+       */
+      public void setBounds(Rectangle rectangle)
+      {
+        // This method does nothing. See API comments.
+      }
+
+      /**
+       * Returns the size of the table cell.
+       *
+       * @return the size of the table cell
+       */
+      public Dimension getSize()
+      {
+        Rectangle cellRect = table.getCellRect(row, column, true);
+        return new Dimension(cellRect.width, cellRect.height);
+      }
+
+      /**
+       * The size cannot be set on table cells directly, so this method does
+       * nothing.
+       *
+       * @param dimension not used
+       */
+      public void setSize(Dimension dimension)
+      {
+        // This method does nothing. See API comments.
+      }
+
+      /**
+       * Table cells have no children, so we return <code>null</code> here.
+       *
+       * @return <code>null</code>
+       */
+      public Accessible getAccessibleAt(Point point)
+      {
+        return null;
+      }
+
+      /**
+       * Returns <code>true</code> if this table cell is focus traversable,
+       * <code>false</code> otherwise.
+       *
+       * @return <code>true</code> if this table cell is focus traversable,
+       *         <code>false</code> otherwise
+       */
+      public boolean isFocusTraversable()
+      {
+        return table.isFocusable();
+      }
+
+      /**
+       * Requests that this table cell gets the keyboard focus.
+       */
+      public void requestFocus()
+      {
+        // We first set the selection models' lead selection to this cell.
+        table.getColumnModel().getSelectionModel()
+        .setLeadSelectionIndex(column);
+        table.getSelectionModel().setLeadSelectionIndex(row);
+        // Now we request that the table receives focus.
+        table.requestFocus();
+      }
+
+      /**
+       * Adds a focus listener to this cell. The focus listener is really
+       * added to the table, so there is no way to find out when an individual
+       * cell changes the focus.
+       *
+       * @param listener the focus listener to add
+       */
+      public void addFocusListener(FocusListener listener)
+      {
+        table.addFocusListener(listener);
+      }
+
+      /**
+       * Removes a focus listener from the cell. The focus listener is really
+       * removed from the table.
+       *
+       * @param listener the listener to remove
+       */
+      public void removeFocusListener(FocusListener listener)
+      {
+        table.removeFocusListener(listener);
+      }
+        
+    }
+
+    protected class AccessibleJTableModelChange
+      implements AccessibleTableModelChange
+    {
+      protected int type;
+      protected int firstRow;
+      protected int lastRow;
+      protected int firstColumn;
+      protected int lastColumn;
+
+      protected AccessibleJTableModelChange(int type, int firstRow,
+                                            int lastRow, int firstColumn,
+                                            int lastColumn)
+      {
+        this.type = type;
+        this.firstRow = firstRow;
+        this.lastRow = lastRow;
+        this.firstColumn = firstColumn;
+        this.lastColumn = lastColumn;
+      }
+
+      public int getType()
+      {
+        return type;
+      }
+
+      public int getFirstRow()
+      {
+        return firstRow;
+      }
+
+      public int getLastRow()
+      {
+        return lastRow;
+      }
+
+      public int getFirstColumn()
+      {
+        return firstColumn;
+      }
+
+      public int getLastColumn()
+      {
+        return lastColumn;
+      }
+    }
+
+    /**
+     * The RI returns an instance with this name in
+     * {@link #getAccessibleColumnHeader()}, this makes sense, so we do the
+     * same.
+     */
+    private class AccessibleTableHeader
+      implements AccessibleTable
+    {
+
+      /**
+       * The JTableHeader wrapped by this class.
+       */
+      private JTableHeader header;
+
+      /**
+       * Creates a new instance.
+       *
+       * @param h the JTableHeader to wrap
+       */
+      private AccessibleTableHeader(JTableHeader h)
+      {
+        header = h;
+      }
+
+      /**
+       * Returns the caption for the table header.
+       *
+       * @return the caption for the table header
+       */
+      public Accessible getAccessibleCaption()
+      {
+        // The RI seems to always return null here, so do we.
+        return null;
+      }
+
+      /**
+       * Sets the caption for the table header.
+       *
+       * @param caption the caption to set
+       */
+      public void setAccessibleCaption(Accessible caption)
+      {
+        // This seems to be a no-op in the RI, so we do the same.
+      }
+
+      /**
+       * Returns the caption for the table header.
+       *
+       * @return the caption for the table header
+       */
+      public Accessible getAccessibleSummary()
+      {
+        // The RI seems to always return null here, so do we.
+        return null;
+      }
+
+      /**
+       * Sets the summary for the table header.
+       *
+       * @param summary the caption to set
+       */
+      public void setAccessibleSummary(Accessible summary)
+      {
+        // This seems to be a no-op in the RI, so we do the same.
+      }
+
+      /**
+       * Returns the number of rows, which is always 1 for the table header.
+       *
+       * @return the number of rows
+       */
+      public int getAccessibleRowCount()
+      {
+        return 1;
+      }
+
+      /**
+       * Returns the number of columns in the table header.
+       *
+       * @return the number of columns in the table header
+       */
+      public int getAccessibleColumnCount()
+      {
+        return header.getColumnModel().getColumnCount();
+      }
+
+      /**
+       * Returns the accessible child at the specified row and column.
+       * The row number is ignored here, and we return an
+       * AccessibleJTableHeaderCell here with the renderer component as
+       * component.
+       *
+       * @param r the row number
+       * @param c the column number
+       *
+       * @return the accessible child at the specified row and column
+       */
+      public Accessible getAccessibleAt(int r, int c)
+      {
+        TableColumn column = header.getColumnModel().getColumn(c);
+        TableCellRenderer rend = column.getHeaderRenderer();
+        if (rend == null)
+          rend = header.getDefaultRenderer();
+        Component comp =
+          rend.getTableCellRendererComponent(header.getTable(),
+                                             column.getHeaderValue(), false,
+                                             false, -1, c);
+        return new AccessibleJTableHeaderCell(header, comp, r, c);
+      }
+
+      public int getAccessibleRowExtentAt(int r, int c)
+      {
+        // TODO Auto-generated method stub
+        return 0;
+      }
+
+      public int getAccessibleColumnExtentAt(int r, int c)
+      {
+        // TODO Auto-generated method stub
+        return 0;
+      }
+
+      public AccessibleTable getAccessibleRowHeader()
+      {
+        // TODO Auto-generated method stub
+        return null;
+      }
+
+      public void setAccessibleRowHeader(AccessibleTable header)
+      {
+        // TODO Auto-generated method stub
+        
+      }
+
+      public AccessibleTable getAccessibleColumnHeader()
+      {
+        // TODO Auto-generated method stub
+        return null;
+      }
+
+      public void setAccessibleColumnHeader(AccessibleTable header)
+      {
+        // TODO Auto-generated method stub
+        
+      }
+
+      public Accessible getAccessibleRowDescription(int r)
+      {
+        // TODO Auto-generated method stub
+        return null;
+      }
+
+      public void setAccessibleRowDescription(int r, Accessible description)
+      {
+        // TODO Auto-generated method stub
+        
+      }
+
+      public Accessible getAccessibleColumnDescription(int c)
+      {
+        // TODO Auto-generated method stub
+        return null;
+      }
+
+      public void setAccessibleColumnDescription(int c, Accessible description)
+      {
+        // TODO Auto-generated method stub
+        
+      }
+
+      public boolean isAccessibleSelected(int r, int c)
+      {
+        // TODO Auto-generated method stub
+        return false;
+      }
+
+      public boolean isAccessibleRowSelected(int r)
+      {
+        // TODO Auto-generated method stub
+        return false;
+      }
+
+      public boolean isAccessibleColumnSelected(int c)
+      {
+        // TODO Auto-generated method stub
+        return false;
+      }
+
+      public int[] getSelectedAccessibleRows()
+      {
+        // TODO Auto-generated method stub
+        return null;
+      }
+
+      public int[] getSelectedAccessibleColumns()
+      {
+        // TODO Auto-generated method stub
+        return null;
+      }
+        
+    }
+
+    /**
+     * The RI returns an instance of such class for table header cells. This
+     * makes sense so I added this class. This still needs to be fully
+     * implemented, I just don't feel motivated enough to do so just now.
+     */
+    private class AccessibleJTableHeaderCell
+      extends AccessibleContext
+      implements Accessible, AccessibleComponent
+    {
+
+      JTableHeader header;
+      
+      int columnIndex;
+      
+      /**
+       * 
+       * @param h  the table header.
+       * @param comp
+       * @param r
+       * @param c  the column index.
+       */
+      private AccessibleJTableHeaderCell(JTableHeader h, Component comp, int r,
+                                         int c)
+      {
+        header = h;
+        columnIndex = c;
+      }
+
+      /**
+       * Returns the header renderer.
+       * 
+       * @return The header renderer.
+       */
+      Component getColumnHeaderRenderer()
+      {
+        TableColumn tc = header.getColumnModel().getColumn(columnIndex);
+        TableCellRenderer r = tc.getHeaderRenderer();
+        if (r == null)
+          r = header.getDefaultRenderer();
+        return r.getTableCellRendererComponent(header.getTable(), 
+            tc.getHeaderValue(), false, false, -1, columnIndex);
+      }
+      
+      /**
+       * Returns the accessible role for the table header cell.
+       * 
+       * @return The accessible role.
+       */
+      public AccessibleRole getAccessibleRole()
+      {
+        Component renderer = getColumnHeaderRenderer();
+        if (renderer instanceof Accessible)
+          {
+            Accessible ac = (Accessible) renderer;
+            return ac.getAccessibleContext().getAccessibleRole();
+          }
+        return null;
+      }
+
+      public AccessibleStateSet getAccessibleStateSet()
+      {
+        // TODO Auto-generated method stub
+        return null;
+      }
+
+      public int getAccessibleIndexInParent()
+      {
+        // TODO Auto-generated method stub
+        return 0;
+      }
+
+      public int getAccessibleChildrenCount()
+      {
+        // TODO Auto-generated method stub
+        return 0;
+      }
+
+      public Accessible getAccessibleChild(int i)
+      {
+        // TODO Auto-generated method stub
+        return null;
+      }
+
+      public Locale getLocale()
+      {
+        // TODO Auto-generated method stub
+        return null;
+      }
+
+      /**
+       * Returns the accessible context.
+       * 
+       * @return <code>this</code>.
+       */
+      public AccessibleContext getAccessibleContext()
+      {
+        return this;
+      }
+
+      public Color getBackground()
+      {
+        // TODO Auto-generated method stub
+        return null;
+      }
+
+      public void setBackground(Color color)
+      {
+        // TODO Auto-generated method stub
+        
+      }
+
+      public Color getForeground()
+      {
+        // TODO Auto-generated method stub
+        return null;
+      }
+
+      public void setForeground(Color color)
+      {
+        // TODO Auto-generated method stub
+        
+      }
+
+      public Cursor getCursor()
+      {
+        // TODO Auto-generated method stub
+        return null;
+      }
+
+      public void setCursor(Cursor cursor)
+      {
+        // TODO Auto-generated method stub
+        
+      }
+
+      public Font getFont()
+      {
+        // TODO Auto-generated method stub
+        return null;
+      }
+
+      public void setFont(Font font)
+      {
+        // TODO Auto-generated method stub
+        
+      }
+
+      public FontMetrics getFontMetrics(Font font)
+      {
+        // TODO Auto-generated method stub
+        return null;
+      }
+
+      public boolean isEnabled()
+      {
+        // TODO Auto-generated method stub
+        return false;
+      }
+
+      public void setEnabled(boolean b)
+      {
+        // TODO Auto-generated method stub
+        
+      }
+
+      public boolean isVisible()
+      {
+        // TODO Auto-generated method stub
+        return false;
+      }
+
+      public void setVisible(boolean b)
+      {
+        // TODO Auto-generated method stub
+        
+      }
+
+      public boolean isShowing()
+      {
+        // TODO Auto-generated method stub
+        return false;
+      }
+
+      public boolean contains(Point point)
+      {
+        // TODO Auto-generated method stub
+        return false;
+      }
+
+      public Point getLocationOnScreen()
+      {
+        // TODO Auto-generated method stub
+        return null;
+      }
+
+      public Point getLocation()
+      {
+        // TODO Auto-generated method stub
+        return null;
+      }
+
+      public void setLocation(Point point)
+      {
+        // TODO Auto-generated method stub
+        
+      }
+
+      public Rectangle getBounds()
+      {
+        // TODO Auto-generated method stub
+        return null;
+      }
+
+      public void setBounds(Rectangle rectangle)
+      {
+        // TODO Auto-generated method stub
+        
+      }
+
+      public Dimension getSize()
+      {
+        // TODO Auto-generated method stub
+        return null;
+      }
+
+      public void setSize(Dimension dimension)
+      {
+        // TODO Auto-generated method stub
+        
+      }
+
+      public Accessible getAccessibleAt(Point point)
+      {
+        // TODO Auto-generated method stub
+        return null;
+      }
+
+      public boolean isFocusTraversable()
+      {
+        // TODO Auto-generated method stub
+        return false;
+      }
+
+      public void requestFocus()
+      {
+        // TODO Auto-generated method stub
+        
+      }
+
+      public void addFocusListener(FocusListener listener)
+      {
+        // TODO Auto-generated method stub
+        
+      }
+
+      public void removeFocusListener(FocusListener listener)
+      {
+        // TODO Auto-generated method stub
+        
+      }
+      
+    }
+
+    /**
+     * The last selected row. This is needed to track the selection in
+     * {@link #valueChanged(ListSelectionEvent)}.
+     */
+    private int lastSelectedRow;
+
+    /**
+     * The last selected column. This is needed to track the selection in
+     * {@link #valueChanged(ListSelectionEvent)}.
+     */
+    private int lastSelectedColumn;
+
+    /**
+     * The caption of the table.
+     */
+    private Accessible caption;
+
+    /**
+     * The summary of the table.
+     */
+    private Accessible summary;
+
+    /**
+     * Accessible descriptions for rows.
+     */
+    private Accessible[] rowDescriptions;
+
+    /**
+     * Accessible descriptions for columns.
+     */
+    private Accessible[] columnDescriptions;
+
+    /**
+     * Creates a new <code>AccessibleJTable</code>.
+     *
+     * @since JDK1.5
+     */
+    protected AccessibleJTable()
+    {
+      getModel().addTableModelListener(this);
+      getSelectionModel().addListSelectionListener(this);
+      getColumnModel().addColumnModelListener(this);
+      lastSelectedRow = getSelectedRow();
+      lastSelectedColumn = getSelectedColumn();
+      TableCellEditor editor = getCellEditor();
+      if (editor != null)
+        editor.addCellEditorListener(this);
+    }
+
+    /**
+     * Returns the accessible role for the <code>JTable</code> component.
+     *
+     * @return {@link AccessibleRole#TABLE}.
+     */
+    public AccessibleRole getAccessibleRole()
+    {
+      return AccessibleRole.TABLE;
+    }
+    
+    /**
+     * Returns the accessible table.
+     * 
+     * @return <code>this</code>.
+     */
+    public AccessibleTable getAccessibleTable()
+    {
+      return this;
+    }
+    
+    /**
+     * Returns the number of selected items in this table.
+     */
+    public int getAccessibleSelectionCount()
+    {
+      return getSelectedColumnCount();
+    }
+
+    /**
+     * Returns the selected accessible object with the specified index
+     * <code>i</code>. This basically returns the i-th selected cell in the
+     * table when going though it row-wise, and inside the rows, column-wise.
+     *
+     * @param i the index of the selected object to find
+     *
+     * @return the selected accessible object with the specified index
+     *         <code>i</code>
+     */
+    public Accessible getAccessibleSelection(int i)
+    {
+      Accessible found = null;
+
+      int[] selectedRows = getSelectedRows();
+      int[] selectedColumns = getSelectedColumns();
+      int numCols = getColumnCount();
+      int numRows = getRowCount();
+
+      // We have to go through every selected row and column and count until we
+      // find the specified index. This is potentially inefficient, but I can't
+      // think of anything better atm.
+      if (getRowSelectionAllowed() && getColumnSelectionAllowed())
+        {
+          int current = -1;
+          int newIndex = current;
+          int lastSelectedRow = -1;
+          // Go through the selected rows array, don't forget the selected
+          // cells inside the not-selected rows' columns.
+          for (int j = 0; i < selectedRows.length; i++)
+            {
+              // Handle unselected rows between this selected and the last
+              // selected row, if any.
+              int selectedRow = selectedRows[j];
+              int r = -1;
+              int ci = -1;
+              for (r = lastSelectedRow + 1;
+                   r < selectedRow && current < i; r++)
+                {
+                  for (ci = 0; ci < selectedColumns.length && current < i;
+                       ci++)
+                    {
+                      current++;
+                    }
+                }
+              if (current == i)
+                {
+                  // We found the cell in the above loops, now get out of here.
+                  found = getAccessibleChild(r * numCols
+                                             + selectedColumns[ci]);
+                  break;
+                }
+
+              // If we're still here, handle the current selected row.
+              if (current < i && current + numCols >= i)
+                {
+                  // The cell must be in that row, which one is it?
+                  found = getAccessibleChild(r * numCols + (i - current));
+                  break;
+                }
+              current += numCols;
+            }
+          if (found == null)
+            {
+              // The cell can still be in the last couple of unselected rows.
+              int r = 0;
+              int ci = 0;
+              for (r = lastSelectedRow + 1;
+                   r < numRows && current < i; r++)
+                {
+                  for (ci = 0; ci < selectedColumns.length && current < i;
+                       ci++)
+                    {
+                      current++;
+                    }
+                }
+              if (current == i)
+                {
+                  // We found the cell in the above loops, now get out of here.
+                  found = getAccessibleChild(r * numCols
+                                             + selectedColumns[ci]);
+                }
+            }
+        }
+      // One or more rows can be completely selected.
+      else if (getRowSelectionAllowed())
+        {
+          int c = i % numCols;
+          int r = selectedRows[i / numCols];
+          found = getAccessibleChild(r * numCols + c);
+        }
+      // One or more columns can be completely selected.
+      else if (getRowSelectionAllowed())
+        {
+          int numSelectedColumns = selectedColumns.length;
+          int c = selectedColumns[i % numSelectedColumns];
+          int r = i / numSelectedColumns;
+          found = getAccessibleChild(r * numCols + c);
+        }
+
+      return found;
+    }
+
+    /**
+     * Returns <code>true</code> if the accessible child with the index
+     * <code>i</code> is selected, <code>false</code> otherwise.
+     *
+     * @param i the index of the accessible to check
+     *
+     * @return <code>true</code> if the accessible child with the index
+     *         <code>i</code> is selected, <code>false</code> otherwise
+     */
+    public boolean isAccessibleChildSelected(int i)
+    {
+      int r = getAccessibleRowAtIndex(i);
+      int c = getAccessibleColumnAtIndex(i);
+      return isCellSelected(r, c);
+    }
+
+    /**
+     * Adds the accessible child with the specified index <code>i</code> to the
+     * selection.
+     *
+     * @param i the index of the accessible child to add to the selection
+     */
+    public void addAccessibleSelection(int i)
+    {
+      int r = getAccessibleRowAtIndex(i);
+      int c = getAccessibleColumnAtIndex(i);
+      changeSelection(r, c, true, false);
+    }
+
+    /**
+     * Removes the accessible child with the specified index <code>i</code>
+     * from the current selection. This will only work on tables that have
+     * cell selection enabled (<code>rowSelectionAllowed == false &&
+     * columnSelectionAllowed == false</code>).
+     *
+     * @param i the index of the accessible to be removed from the selection
+     */
+    public void removeAccessibleSelection(int i)
+    {
+      if (! getRowSelectionAllowed() && ! getColumnSelectionAllowed())
+        {
+          int r = getAccessibleRowAtIndex(i);
+          int c = getAccessibleColumnAtIndex(i);
+          removeRowSelectionInterval(r, r);
+          removeColumnSelectionInterval(c, c);
+        }
+    }
+
+    /**
+     * Deselects all selected accessible children.
+     */
+    public void clearAccessibleSelection()
+    {
+      clearSelection();
+    }
+
+    /**
+     * Selects all accessible children that can be selected. This will only
+     * work on tables that support multiple selections and that have individual
+     * cell selection enabled.
+     */
+    public void selectAllAccessibleSelection()
+    {
+      selectAll();
+    }
+
+    /**
+     * Receives notification when the row selection changes and fires
+     * appropriate property change events.
+     *
+     * @param event the list selection event
+     */
+    public void valueChanged(ListSelectionEvent event)
+    {
+      firePropertyChange(AccessibleContext.ACCESSIBLE_SELECTION_PROPERTY,
+                         Boolean.FALSE, Boolean.TRUE);
+      int r = getSelectedRow();
+      int c = getSelectedColumn();
+      if (r != lastSelectedRow || c != lastSelectedColumn)
+        {
+          Accessible o = getAccessibleAt(lastSelectedRow,
+                                         lastSelectedColumn);
+          Accessible n = getAccessibleAt(r, c);
+          firePropertyChange(AccessibleContext
+                             .ACCESSIBLE_ACTIVE_DESCENDANT_PROPERTY, o, n);
+          lastSelectedRow = r;
+          lastSelectedColumn = c;
+        }
+    }
+
+    /**
+     * Receives notification when the table model changes. Depending on the
+     * type of change, this method calls {@link #tableRowsInserted} or
+     * {@link #tableRowsDeleted}.
+     *
+     * @param event the table model event
+     */
+    public void tableChanged(TableModelEvent event)
+    {
+      switch (event.getType())
+        {
+        case TableModelEvent.INSERT:
+          tableRowsInserted(event);
+          break;
+        case TableModelEvent.DELETE:
+          tableRowsDeleted(event);
+          break;
+        }
+    }
+
+    /**
+     * Receives notification when one or more rows have been inserted into the
+     * table and fires appropriate property change events.
+     *
+     * @param event the table model event
+     */
+    public void tableRowsInserted(TableModelEvent event)
+    {
+      handleRowChange(event);
+    }
+
+    /**
+     * Receives notification when one or more rows have been deleted from the
+     * table.
+     *
+     * @param event the table model event
+     */
+    public void tableRowsDeleted(TableModelEvent event)
+    {
+      handleRowChange(event);
+    }
+
+    /**
+     * Fires a PropertyChangeEvent for inserted or deleted rows.
+     *
+     * @param event the table model event
+     */
+    private void handleRowChange(TableModelEvent event)
+    {
+      firePropertyChange(AccessibleContext.ACCESSIBLE_VISIBLE_DATA_PROPERTY,
+                         null, null);
+      int firstColumn = event.getColumn();
+      int lastColumn = event.getColumn();
+      if (firstColumn == TableModelEvent.ALL_COLUMNS)
+        {
+          firstColumn = 0;
+          lastColumn = getColumnCount() - 1;
+        }
+      AccessibleJTableModelChange change = new AccessibleJTableModelChange
+         (event.getType(), event.getFirstRow(), event.getLastRow(),
+          firstColumn, lastColumn);
+      firePropertyChange(AccessibleContext.ACCESSIBLE_TABLE_MODEL_CHANGED,
+                         null, change);
+    }
+
+    public void columnAdded(TableColumnModelEvent event)
+    {
+      firePropertyChange(AccessibleContext.ACCESSIBLE_VISIBLE_DATA_PROPERTY,
+                         null, null);
+      handleColumnChange(AccessibleTableModelChange.INSERT,
+                         event.getFromIndex(), event.getToIndex());
+    }
+
+    public void columnRemoved(TableColumnModelEvent event)
+    {
+      firePropertyChange(AccessibleContext.ACCESSIBLE_VISIBLE_DATA_PROPERTY,
+                         null, null);
+      handleColumnChange(AccessibleTableModelChange.DELETE,
+                         event.getFromIndex(), event.getToIndex());
+    }
+
+    public void columnMoved(TableColumnModelEvent event)
+    {
+      firePropertyChange(AccessibleContext.ACCESSIBLE_VISIBLE_DATA_PROPERTY,
+                         null, null);
+      handleColumnChange(AccessibleTableModelChange.DELETE,
+                         event.getFromIndex(), event.getFromIndex());
+      handleColumnChange(AccessibleTableModelChange.INSERT,
+                         event.getFromIndex(), event.getToIndex());
+    }
+
+    /**
+     * Fires a PropertyChangeEvent for inserted or deleted columns.
+     *
+     * @param type the type of change
+     * @param from the start of the change
+     * @param to the target of the change
+     */
+    private void handleColumnChange(int type, int from, int to)
+    {
+      AccessibleJTableModelChange change =
+        new AccessibleJTableModelChange(type, 0, 0, from, to);
+      firePropertyChange(AccessibleContext.ACCESSIBLE_TABLE_MODEL_CHANGED,
+                         null, change);
+    }
+
+    public void columnMarginChanged(ChangeEvent event)
+    {
+      firePropertyChange(AccessibleContext.ACCESSIBLE_VISIBLE_DATA_PROPERTY,
+                         null, null);
+    }
+
+    public void columnSelectionChanged(ListSelectionEvent event)
+    {
+      // AFAICS, nothing is done here.
+    }
+
+    public void editingCanceled(ChangeEvent event)
+    {
+      // AFAICS, nothing is done here.
+    }
+
+    public void editingStopped(ChangeEvent event)
+    {
+      firePropertyChange(AccessibleContext.ACCESSIBLE_VISIBLE_DATA_PROPERTY,
+                         null, null);
+    }
+
+    /**
+     * Receives notification when any of the JTable's properties changes. This
+     * is used to replace the listeners on the table's model, selection model,
+     * column model and cell editor.
+     *
+     * @param e the property change event
+     */
+    public void propertyChange(PropertyChangeEvent e)
+    {
+      String propName = e.getPropertyName(); 
+      if (propName.equals("tableModel"))
+        {
+          TableModel oldModel = (TableModel) e.getOldValue();
+          oldModel.removeTableModelListener(this);
+          TableModel newModel = (TableModel) e.getNewValue();
+          newModel.addTableModelListener(this);
+        }
+      else if (propName.equals("columnModel"))
+        {
+          TableColumnModel oldModel = (TableColumnModel) e.getOldValue();
+          oldModel.removeColumnModelListener(this);
+          TableColumnModel newModel = (TableColumnModel) e.getNewValue();
+          newModel.addColumnModelListener(this);
+        }
+      else if (propName.equals("selectionModel"))
+        {
+          ListSelectionModel oldModel = (ListSelectionModel) e.getOldValue();
+          oldModel.removeListSelectionListener(this);
+          ListSelectionModel newModel = (ListSelectionModel) e.getNewValue();
+          newModel.addListSelectionListener(this);
+        }
+      else if (propName.equals("cellEditor"))
+        {
+          CellEditor oldEd = (CellEditor) e.getOldValue();
+          oldEd.removeCellEditorListener(this);
+          CellEditor newEd = (CellEditor) e.getNewValue();
+          newEd.addCellEditorListener(this);
+        }
+    }
+
+    /**
+     * Returns the row number of an accessible child (cell) with the specified
+     * index.
+     *
+     * @param index the index of the cell of which the row number is queried
+     * 
+     * @return the row number of an accessible child (cell) with the specified
+     *         index 
+     */
+    public int getAccessibleRow(int index)
+    {
+      return getAccessibleRowAtIndex(index);
+    }
+
+    /**
+     * Returns the column number of an accessible child (cell) with the
+     * specified index.
+     *
+     * @param index the index of the cell of which the column number is queried
+     * 
+     * @return the column number of an accessible child (cell) with the
+     *         specified index 
+     */
+    public int getAccessibleColumn(int index)
+    {
+      return getAccessibleColumnAtIndex(index);
+    }
+
+    /**
+     * Returns the index of the accessible child at the specified row and
+     * column.
+     *
+     * @param r the row number
+     * @param c the column number
+     *
+     * @return the index of the accessible child at the specified row and
+     *         column
+     */
+    public int getAccessibleIndex(int r, int c)
+    {
+      return getAccessibleIndexAt(r, c);
+    }
+
+    /**
+     * Returns the caption of the table.
+     *
+     * @return the caption of the table
+     *
+     * @see #setAccessibleCaption(Accessible)
+     */
+    public Accessible getAccessibleCaption()
+    {
+      return caption;
+    }
+
+    /**
+     * Sets the caption for the table.
+     *
+     * @param c the caption to set
+     */
+    public void setAccessibleCaption(Accessible c)
+    {
+      caption = c;
+    }
+
+    /**
+     * Returns the summary for the table.
+     *
+     * @return the summary for the table
+     */
+    public Accessible getAccessibleSummary()
+    {
+      return summary;
+    }
+
+    /**
+     * Sets the summary for the table.
+     *
+     * @param s the summary to set
+     */
+    public void setAccessibleSummary(Accessible s)
+    {
+      summary = s;
+    }
+
+    /**
+     * Returns the number of rows in the table.
+     *
+     * @return the number of rows in the table
+     */
+    public int getAccessibleRowCount()
+    {
+      return getRowCount();
+    }
+
+    /**
+     * Returns the number of columns in the table.
+     *
+     * @return the number of columns in the table
+     */
+    public int getAccessibleColumnCount()
+    {
+      return getColumnCount();
+    }
+
+    /**
+     * Returns the accessible child at the given index.
+     *
+     * @param index  the child index.
+     * 
+     * @return The accessible child.
+     */
+    public Accessible getAccessibleChild(int index)
+    {
+      int r = getAccessibleRow(index);
+      int c = getAccessibleColumn(index);
+      return getAccessibleAt(r, c);  
+    }
+    
+    /**
+     * Returns the accessible child (table cell) at the specified row and
+     * column.
+     *
+     * @param r the row number
+     * @param c the column number
+     *
+     * @return the accessible child (table cell) at the specified row and
+     *         column
+     */
+    public Accessible getAccessibleAt(int r, int c)
+    {
+      TableCellRenderer cellRenderer = getCellRenderer(r, c);
+      Component renderer = cellRenderer.getTableCellRendererComponent(
+          JTable.this, getValueAt(r, c), isCellSelected(r, c), false, r, c);
+      if (renderer instanceof Accessible)
+        return (Accessible) renderer;
+      return null;
+    }
+
+    /**
+     * Returns the number of rows that the specified cell occupies. The
+     * standard table cells only occupy one row, so we return <code>1</code>
+     * here.
+     *
+     * @param r the row number
+     * @param c the column number
+     *
+     * @return the number of rows that the specified cell occupies
+     */
+    public int getAccessibleRowExtentAt(int r, int c)
+    {
+      return 1;
+    }
+
+    /**
+     * Returns the number of columns that the specified cell occupies. The
+     * standard table cells only occupy one column, so we return <code>1</code>
+     * here.
+     *
+     * @param r the row number
+     * @param c the column number
+     *
+     * @return the number of rows that the specified cell occupies
+     */
+    public int getAccessibleColumnExtentAt(int r, int c)
+    {
+      return 1;
+    }
+
+    /**
+     * Returns the accessible row header.
+     *
+     * @return the accessible row header
+     */
+    public AccessibleTable getAccessibleRowHeader()
+    {
+      // The RI seems to always return null here, so do we.
+      return null;
+    }
+
+    /**
+     * Sets the accessible row header.
+     *
+     * @param header the header to set
+     */
+    public void setAccessibleRowHeader(AccessibleTable header)
+    {
+      // In the RI this seems to be a no-op.    
+    }
+
+    /**
+     * Returns the column header.
+     *
+     * @return the column header, or <code>null</code> if there is no column
+     *         header
+     */
+    public AccessibleTable getAccessibleColumnHeader()
+    {
+      JTableHeader h = getTableHeader();
+      AccessibleTable header = null;
+      if (h != null)
+        header = new AccessibleTableHeader(h);
+      return header;
+    }
+
+    /**
+     * Sets the accessible column header. The default implementation doesn't
+     * allow changing the header this way, so this is a no-op.
+     *
+     * @param header the accessible column header to set
+     */
+    public void setAccessibleColumnHeader(AccessibleTable header)
+    {
+      // The RI doesn't seem to do anything, so we also do nothing.
+    }
+
+    /**
+     * Returns the accessible description for the row with the specified index,
+     * or <code>null</code> if no description has been set.
+     *
+     * @param r the row for which the description is queried
+     *
+     * @return the accessible description for the row with the specified index,
+     *         or <code>null</code> if no description has been set
+     */
+    public Accessible getAccessibleRowDescription(int r)
+    {
+      Accessible descr = null;
+      if (rowDescriptions != null)
+        descr = rowDescriptions[r];
+      return descr;
+    }
+
+    /**
+     * Sets the accessible description for the row with the specified index.
+     *
+     * @param r the row number for which to set the description
+     * @param description the description to set
+     */
+    public void setAccessibleRowDescription(int r, Accessible description)
+    {
+      if (rowDescriptions == null)
+        rowDescriptions = new Accessible[getAccessibleRowCount()];
+      rowDescriptions[r] = description;
+    }
+
+    /**
+     * Returns the accessible description for the column with the specified
+     * index, or <code>null</code> if no description has been set.
+     *
+     * @param c the column for which the description is queried
+     *
+     * @return the accessible description for the column with the specified
+     *         index, or <code>null</code> if no description has been set
+     */
+    public Accessible getAccessibleColumnDescription(int c)
+    {
+      Accessible descr = null;
+      if (columnDescriptions != null)
+        descr = columnDescriptions[c];
+      return descr;
+    }
+
+    /**
+     * Sets the accessible description for the column with the specified index.
+     *
+     * @param c the column number for which to set the description
+     * @param description the description to set
+     */
+    public void setAccessibleColumnDescription(int c, Accessible description)
+    {
+      if (columnDescriptions == null)
+        columnDescriptions = new Accessible[getAccessibleRowCount()];
+      columnDescriptions[c] = description;
+    }
+
+    /**
+     * Returns <code>true</code> if the accessible child at the specified
+     * row and column is selected, <code>false</code> otherwise.
+     *
+     * @param r the row number of the child
+     * @param c the column number of the child
+     *
+     * @return <code>true</code> if the accessible child at the specified
+     *         row and column is selected, <code>false</code> otherwise
+     */
+    public boolean isAccessibleSelected(int r, int c)
+    {
+      return isCellSelected(r, c);
+    }
+
+    /**
+     * Returns <code>true</code> if the row with the specified index is
+     * selected, <code>false</code> otherwise.
+     *
+     * @param r the row number
+     *
+     * @return <code>true</code> if the row with the specified index is
+     *        selected, <code>false</code> otherwise
+     */
+    public boolean isAccessibleRowSelected(int r)
+    {
+      return isRowSelected(r);
+    }
+
+    /**
+     * Returns <code>true</code> if the column with the specified index is
+     * selected, <code>false</code> otherwise.
+     *
+     * @param c the column number
+     *
+     * @return <code>true</code> if the column with the specified index is
+     *        selected, <code>false</code> otherwise
+     */
+    public boolean isAccessibleColumnSelected(int c)
+    {
+      return isColumnSelected(c);
+    }
+
+    /**
+     * Returns the indices of all selected rows.
+     *
+     * @return the indices of all selected rows
+     */
+    public int[] getSelectedAccessibleRows()
+    {
+      return getSelectedRows();
+    }
+
+    /**
+     * Returns the indices of all selected columns.
+     *
+     * @return the indices of all selected columns
+     */
+    public int[] getSelectedAccessibleColumns()
+    {
+      return getSelectedColumns();
+    }
+
+    /**
+     * Returns the accessible row at the specified index.
+     *
+     * @param index the index for which to query the row
+     *
+     * @return the row number at the specified table index
+     */
+    public int getAccessibleRowAtIndex(int index)
+    {
+      // TODO: Back this up by a Mauve test and update API docs accordingly.
+      return index / getColumnCount();
+    }
+
+    /**
+     * Returns the accessible column at the specified index.
+     *
+     * @param index the index for which to query the column
+     *
+     * @return the column number at the specified table index
+     */
+    public int getAccessibleColumnAtIndex(int index)
+    {
+      // TODO: Back this up by a Mauve test and update API docs accordingly.
+      return index % getColumnCount();
+    }
+
+    /**
+     * Returns the accessible child index at the specified column and row.
+     *
+     * @param row the row
+     * @param column the column
+     *
+     * @return the index of the accessible child at the specified row and
+     *         column
+     */
+    public int getAccessibleIndexAt(int row, int column)
+    {
+      // TODO: Back this up by a Mauve test and update API docs accordingly.
+      return row * getColumnCount() + column;
+    }
+  }
+  /**
+   * Handles property changes from the <code>TableColumn</code>s of this
+   * <code>JTable</code>.
+   *
+   * More specifically, this triggers a {@link #revalidate()} call if the
+   * preferredWidth of one of the observed columns changes.
+   */
+  class TableColumnPropertyChangeHandler implements PropertyChangeListener
+  {
+    /**
+     * Receives notification that a property of the observed TableColumns has
+     * changed.
+     * 
+     * @param ev the property change event
+     */
+    public void propertyChange(PropertyChangeEvent ev)
+    {
+      if (ev.getPropertyName().equals("preferredWidth"))
+        {
+          JTableHeader header = getTableHeader();
+          if (header != null)
+            // Do nothing if the table is in the resizing mode.
+            if (header.getResizingColumn() == null)
+              {
+                TableColumn col = (TableColumn) ev.getSource();
+                header.setResizingColumn(col);
+                doLayout();
+                header.setResizingColumn(null);
+              }
+        }
+    }
+  }
+
+  /**
+   * A cell renderer for boolean values.
+   */
+  private class BooleanCellRenderer
+    extends DefaultTableCellRenderer
+  {
+    /**
+     * The CheckBox that is used for rendering.
+     */
+    private final JCheckBox checkBox;
+    
+    /**
+     * Creates a new checkbox based boolean cell renderer. The checkbox is
+     * centered by default.
+     */
+    BooleanCellRenderer()
+    {
+       checkBox = new JCheckBox();
+       checkBox.setHorizontalAlignment(SwingConstants.CENTER);
+    }
+   
+    /**
+     * Get the check box.
+     */
+    JCheckBox getCheckBox()
+    {
+      return checkBox;
+    }
+
+    /**
+     * Returns the component that is used for rendering the value.
+     * 
+     * @param table the JTable
+     * @param value the value of the object
+     * @param isSelected is the cell selected?
+     * @param hasFocus has the cell the focus?
+     * @param row the row to render
+     * @param column the cell to render
+     * @return this component (the default table cell renderer)
+     */
+    public Component getTableCellRendererComponent(JTable table, Object value,
+                                                   boolean isSelected,
+                                                   boolean hasFocus, int row,
+                                                   int column)
+    {
+      if (isSelected)
+        {
+          checkBox.setBackground(table.getSelectionBackground());
+          checkBox.setForeground(table.getSelectionForeground());
+        }
+      else
+        {
+          checkBox.setBackground(table.getBackground());
+          checkBox.setForeground(table.getForeground());
+        }
+
+      if (hasFocus)
+        {
+          checkBox.setBorder(
+            UIManager.getBorder("Table.focusCellHighlightBorder"));
+          if (table.isCellEditable(row, column))
+            {
+              checkBox.setBackground(
+                UIManager.getColor("Table.focusCellBackground"));
+              checkBox.setForeground(
+                UIManager.getColor("Table.focusCellForeground"));
+            }
+        }
+      else
+        checkBox.setBorder(BorderFactory.createEmptyBorder(1, 1, 1, 1));
+
+      // Null is rendered as false.
+      if (value == null)
+        checkBox.setSelected(false);
+      else
+        {
+          Boolean boolValue = (Boolean) value;
+          checkBox.setSelected(boolValue.booleanValue());
+        }
+      return checkBox;
+    }
+  }
+
+  /**
+   * A cell renderer for Date values.
+   */
+  private class DateCellRenderer
+    extends DefaultTableCellRenderer
+  {
+    /**
+     * Returns the component that is used for rendering the value.
+     *
+     * @param table the JTable
+     * @param value the value of the object
+     * @param isSelected is the cell selected?
+     * @param hasFocus has the cell the focus?
+     * @param row the row to render
+     * @param column the cell to render
+     * 
+     * @return this component (the default table cell renderer)
+     */
+    public Component getTableCellRendererComponent(JTable table, Object value,
+                                                   boolean isSelected,
+                                                   boolean hasFocus, int row,
+                                                   int column)
+    {
+      super.getTableCellRendererComponent(table, value, isSelected, hasFocus,
+                                          row, column);
+      if (value instanceof Date)
+        {
+          Date dateValue = (Date) value;
+          DateFormat df = DateFormat.getDateInstance(DateFormat.SHORT);
+          setText(df.format(dateValue));
+        }
+      return this;
+    }
+  }
+
+  /**
+   * A cell renderer for Double values.
+   */
+  private class DoubleCellRenderer
+    extends DefaultTableCellRenderer
+  {
+    /**
+     * Creates a new instance of NumberCellRenderer.
+     */
+    public DoubleCellRenderer()
+    {
+      setHorizontalAlignment(JLabel.RIGHT);
+    }
+
+    /**
+     * Returns the component that is used for rendering the value.
+     *
+     * @param table the JTable
+     * @param value the value of the object
+     * @param isSelected is the cell selected?
+     * @param hasFocus has the cell the focus?
+     * @param row the row to render
+     * @param column the cell to render
+     * 
+     * @return this component (the default table cell renderer)
+     */
+    public Component getTableCellRendererComponent(JTable table, Object value,
+                                                   boolean isSelected,
+                                                   boolean hasFocus, int row,
+                                                   int column)
+    {
+      super.getTableCellRendererComponent(table, value, isSelected, hasFocus,
+                                          row, column);
+      if (value instanceof Double)
+        {
+          Double doubleValue = (Double) value;
+          NumberFormat nf = NumberFormat.getInstance();
+          setText(nf.format(doubleValue.doubleValue()));
+        }
+      return this;
+    }
+  }
+
+  /**
+   * A cell renderer for Float values.
+   */
+  private class FloatCellRenderer
+    extends DefaultTableCellRenderer
+  {
+    /**
+     * Creates a new instance of NumberCellRenderer.
+     */
+    public FloatCellRenderer()
+    {
+      setHorizontalAlignment(JLabel.RIGHT);
+    }
+
+    /**
+     * Returns the component that is used for rendering the value.
+     *
+     * @param table the JTable
+     * @param value the value of the object
+     * @param isSelected is the cell selected?
+     * @param hasFocus has the cell the focus?
+     * @param row the row to render
+     * @param column the cell to render
+     * 
+     * @return this component (the default table cell renderer)
+     */
+    public Component getTableCellRendererComponent(JTable table, Object value,
+                                                   boolean isSelected,
+                                                   boolean hasFocus, int row,
+                                                   int column)
+    {
+      super.getTableCellRendererComponent(table, value, isSelected, hasFocus,
+                                          row, column);
+      if (value instanceof Float)
+        {
+          Float floatValue = (Float) value;
+          NumberFormat nf = NumberFormat.getInstance();
+          setText(nf.format(floatValue.floatValue()));
+        }
+      return this;
+    }
+  }
+
+  /**
+   * A cell renderer for Number values.
+   */
+  private class NumberCellRenderer
+    extends DefaultTableCellRenderer
+  {
+    /**
+     * Creates a new instance of NumberCellRenderer.
+     */
+    public NumberCellRenderer()
+    {
+      setHorizontalAlignment(JLabel.RIGHT);
+    }
+  }
+
+  /**
+   * A cell renderer for Icon values.
+   */
+  private class IconCellRenderer
+    extends DefaultTableCellRenderer
+  {
+    IconCellRenderer()
+    {
+      setHorizontalAlignment(SwingConstants.CENTER);
+    }
+    
+    
+    /**
+     * Returns the component that is used for rendering the value.
+     *
+     * @param table the JTable
+     * @param value the value of the object
+     * @param isSelected is the cell selected?
+     * @param hasFocus has the cell the focus?
+     * @param row the row to render
+     * @param column the cell to render
+     * 
+     * @return this component (the default table cell renderer)
+     */
+    public Component getTableCellRendererComponent(JTable table, Object value,
+                                                   boolean isSelected,
+                                                   boolean hasFocus, int row,
+                                                   int column)
+    {
+      super.getTableCellRendererComponent(table, value, isSelected, hasFocus,
+                                          row, column);
+      if (value instanceof Icon)
+        {
+          Icon iconValue = (Icon) value;
+          setIcon(iconValue);
+        }
+      else
+        {
+          setIcon(null);
+        }
+      setText("");
+      return this;
+    }
+  }
+  
+    /**
+     * The JTable text component (used in editing) always has the table
+     * as its parent. The scrollRectToVisible must be adjusted taking the
+     * relative component position.
+     *
+     * @author Audrius Meskauskas (AudriusA at Bioinformatics.org)
+     */
+    private class TableTextField extends JTextField
+    {
+      /**
+       * Create the text field without the border.
+       */
+      TableTextField()
+      {
+        setBorder(BorderFactory.createLineBorder(getGridColor(), 2));
+      }
+    }    
+  
+
+  private static final long serialVersionUID = 3876025080382781659L;
+  
+  /**
+   * This table, for referring identically name methods from inner classes.
+   */
+  final JTable this_table = this;
+
+
+  /**
+   * When resizing columns, do not automatically change any columns. In this
+   * case the table should be enclosed in a {@link JScrollPane} in order to
+   * accomodate cases in which the table size exceeds its visible area.
+   */
+  public static final int AUTO_RESIZE_OFF = 0;
+
+  /**
+   * When resizing column <code>i</code>, automatically change only the
+   * single column <code>i+1</code> to provide or absorb excess space
+   * requirements.
+   */
+  public static final int AUTO_RESIZE_NEXT_COLUMN = 1;
+
+  /**
+   * When resizing column <code>i</code> in a table of <code>n</code>
+   * columns, automatically change all columns in the range <code>[i+1,
+   * n)</code>, uniformly, to provide or absorb excess space requirements.
+   */
+  public static final int AUTO_RESIZE_SUBSEQUENT_COLUMNS = 2;
+  
+  /**
+   * When resizing column <code>i</code> in a table of <code>n</code>
+   * columns, automatically change all columns in the range <code>[0,
+   * n)</code> (with the exception of column i) uniformly, to provide or
+   * absorb excess space requirements.
+   */
+  public static final int AUTO_RESIZE_ALL_COLUMNS = 4;
+
+  /**
+   * When resizing column <code>i</code> in a table of <code>n</code>
+   * columns, automatically change column <code>n-1</code> (the last column
+   * in the table) to provide or absorb excess space requirements.
+   */
+  public static final int AUTO_RESIZE_LAST_COLUMN = 3;
+
+  /**
+   * A table mapping {@link java.lang.Class} objects to 
+   * {@link TableCellEditor} objects. This table is consulted by the 
+   * FIXME
+   */
+  protected Hashtable defaultEditorsByColumnClass = new Hashtable();
+
+  /**
+   * A table mapping {@link java.lang.Class} objects to 
+   * {@link TableCellEditor} objects. This table is consulted by the 
+   * FIXME
+   */
+  protected Hashtable defaultRenderersByColumnClass = new Hashtable();
+
+  /**
+   * The column that is edited, -1 if the table is not edited currently.
+   */
+  protected int editingColumn;
+
+  /**
+   * The row that is edited, -1 if the table is not edited currently.
+   */
+  protected int editingRow;
+
+  /**
+   * The component that is used for editing.
+   * <code>null</code> if the table is not editing currently.
+   *
+   */
+  protected transient Component editorComp;
+
+
+  /**
+   * Whether or not the table should automatically compute a matching
+   * {@link TableColumnModel} and assign it to the {@link #columnModel}
+   * property when the {@link #dataModel} property is changed. 
+   *
+   * @see #setModel(TableModel)
+   * @see #createDefaultColumnsFromModel()
+   * @see #setColumnModel(TableColumnModel)
+   * @see #setAutoCreateColumnsFromModel(boolean)
+   * @see #getAutoCreateColumnsFromModel()
+   */
+  protected boolean autoCreateColumnsFromModel;
+
+  /**
+   * A numeric code specifying the resizing behavior of the table. Must be
+   * one of {@link #AUTO_RESIZE_ALL_COLUMNS} (the default), {@link
+   * #AUTO_RESIZE_LAST_COLUMN}, {@link #AUTO_RESIZE_NEXT_COLUMN}, {@link
+   * #AUTO_RESIZE_SUBSEQUENT_COLUMNS}, or {@link #AUTO_RESIZE_OFF}.
+   * 
+   * @see #doLayout()
+   * @see #setAutoResizeMode(int)
+   * @see #getAutoResizeMode()
+   */
+  protected int autoResizeMode;
+
+  /**
+   * The height in pixels of any row of the table. All rows in a table are
+   * of uniform height. This differs from column width, which varies on a
+   * per-column basis, and is stored in the individual columns of the
+   * {@link #columnModel}.
+   * 
+   * @see #getRowHeight()
+   * @see #setRowHeight(int)
+   * @see TableColumn#getWidth()
+   * @see TableColumn#setWidth(int)
+   */
+  protected int rowHeight;
+
+  /**
+   * The height in pixels of the gap left between any two rows of the table. 
+   * 
+   * @see #setRowMargin(int)
+   * @see #getRowHeight()
+   * @see #getIntercellSpacing()
+   * @see #setIntercellSpacing(Dimension)
+   * @see TableColumnModel#getColumnMargin()
+   * @see TableColumnModel#setColumnMargin(int)
+   */
+  protected int rowMargin;
+
+  /**
+   * Whether or not the table should allow row selection. If the table
+   * allows both row <em>and</em> column selection, it is said to allow
+   * "cell selection". Previous versions of the JDK supported cell
+   * selection as an independent concept, but it is now represented solely
+   * in terms of simultaneous row and column selection.
+   *
+   * @see TableColumnModel#getColumnSelectionAllowed()
+   * @see #setRowSelectionAllowed(boolean)
+   * @see #getRowSelectionAllowed()
+   * @see #getCellSelectionEnabled()
+   * @see #setCellSelectionEnabled(boolean)
+   */
+  protected boolean rowSelectionAllowed;
+
+  /**
+   * Obsolete. Use {@link #rowSelectionAllowed}, {@link 
+   * #getColumnSelectionAllowed}, or the combined methods {@link
+   * #getCellSelectionEnabled} and {@link #setCellSelectionEnabled(boolean)}.
+   */
+  protected boolean cellSelectionEnabled;
+  
+  /**
+   * The model for data stored in the table. Confusingly, the published API
+   * requires that this field be called <code>dataModel</code>, despite its
+   * property name. The table listens to its model as a {@link
+   * TableModelListener}.
+   *
+   * @see #tableChanged(TableModelEvent)
+   * @see TableModel#addTableModelListener(TableModelListener)
+   */
+  protected TableModel dataModel;
+
+  /**
+   * <p>A model of various aspects of the columns of the table, <em>not
+   * including</em> the data stored in them. The {@link TableColumnModel}
+   * is principally concerned with holding a set of {@link TableColumn}
+   * objects, each of which describes the display parameters of a column
+   * and the numeric index of the column from the data model which the
+   * column is presenting.</p>
+   *
+   * <p>The TableColumnModel also contains a {@link ListSelectionModel} which
+   * indicates which columns are currently selected. This selection model
+   * works in combination with the {@link #selectionModel} of the table
+   * itself to specify a <em>table selection</em>: a combination of row and
+   * column selections.</p>
+   *
+   * <p>Most application programmers do not need to work with this property
+   * at all: setting {@link #autoCreateColumnsFromModel} will construct the
+   * columnModel automatically, and the table acts as a facade for most of
+   * the interesting properties of the columnModel anyways.</p>
+   * 
+   * @see #setColumnModel(TableColumnModel)
+   * @see #getColumnModel()
+   */
+  protected TableColumnModel columnModel;
+
+  /**
+   * A model of the rows of this table which are currently selected. This
+   * model is used in combination with the column selection model held as a
+   * member of the {@link #columnModel} property, to represent the rows and
+   * columns (or both: cells) of the table which are currently selected.
+   *
+   * @see #rowSelectionAllowed
+   * @see #setSelectionModel(ListSelectionModel)
+   * @see #getSelectionModel()
+   * @see TableColumnModel#getSelectionModel()
+   * @see ListSelectionModel#addListSelectionListener(ListSelectionListener)   
+   */
+  protected ListSelectionModel selectionModel;
+
+  /**
+   * The current cell editor. 
+   */
+  protected TableCellEditor cellEditor;
+
+  /**
+   * Whether or not drag-and-drop is enabled on this table.
+   *
+   * @see #setDragEnabled(boolean)
+   * @see #getDragEnabled()
+   */
+  private boolean dragEnabled;
+
+  /**
+   * The color to paint the grid lines of the table, when either {@link
+   * #showHorizontalLines} or {@link #showVerticalLines} is set.
+   *
+   * @see #setGridColor(Color)
+   * @see #getGridColor()
+   */
+  protected Color gridColor;
+
+  /**
+   * The size this table would prefer its viewport assume, if it is
+   * contained in a {@link JScrollPane}.
+   *
+   * @see #setPreferredScrollableViewportSize(Dimension)
+   * @see #getPreferredScrollableViewportSize()
+   */
+  protected Dimension preferredViewportSize;
+
+  /**
+   * The color to paint the background of selected cells. Fires a property
+   * change event with name {@link #SELECTION_BACKGROUND_CHANGED_PROPERTY}
+   * when its value changes.
+   *
+   * @see #setSelectionBackground(Color)
+   * @see #getSelectionBackground()
+   */
+  protected Color selectionBackground;
+
+  /**
+   * The name carried in property change events when the {@link
+   * #selectionBackground} property changes.
+   */
+  private static final String SELECTION_BACKGROUND_CHANGED_PROPERTY = "selectionBackground";
+
+  /**
+   * The color to paint the foreground of selected cells. Fires a property
+   * change event with name {@link #SELECTION_FOREGROUND_CHANGED_PROPERTY}
+   * when its value changes.
+   *
+   * @see #setSelectionForeground(Color)
+   * @see #getSelectionForeground()
+   */
+  protected Color selectionForeground;
+
+  /**
+   * The name carried in property change events when the
+   * {@link #selectionForeground} property changes.
+   */
+  private static final String SELECTION_FOREGROUND_CHANGED_PROPERTY = "selectionForeground";
+
+  /**
+   * The showHorizontalLines property.
+   */
+  protected boolean showHorizontalLines;
+
+  /**
+   * The showVerticalLines property.
+   */
+  protected boolean showVerticalLines;
+
+  /**
+   * The tableHeader property.
+   */
+  protected JTableHeader tableHeader;
+
+  /**
+   * The property handler for this table's columns.
+   */
+  TableColumnPropertyChangeHandler tableColumnPropertyChangeHandler =
+    new TableColumnPropertyChangeHandler();
+
+  /**
+   * Whether cell editors should receive keyboard focus when the table is
+   * activated.
+   */
+  private boolean surrendersFocusOnKeystroke = false;
+
+  /**
+   * A Rectangle object to be reused in {@link #getCellRect}. 
+   */
+  private Rectangle rectCache = new Rectangle();
+
+  /**
+   * Indicates if the rowHeight property has been set by a client program or by
+   * the UI.
+   *
+   * @see #setUIProperty(String, Object)
+   * @see LookAndFeel#installProperty(JComponent, String, Object)
+   */
+  private boolean clientRowHeightSet = false;
+
+  /**
+   * Stores the sizes and positions of each row, when using non-uniform row
+   * heights. Initially the height of all rows is equal and stored in
+   * {link #rowHeight}. However, when an application calls
+   * {@link #setRowHeight(int,int)}, the table switches to non-uniform
+   * row height mode which stores the row heights in the SizeSequence
+   * object instead.
+   *
+   * @see #setRowHeight(int)
+   * @see #getRowHeight()
+   * @see #getRowHeight(int)
+   * @see #setRowHeight(int, int)
+   */
+  private SizeSequence rowHeights;
+  
+  /**
+   * This editor serves just a marker that the value must be simply changed to
+   * the opposite one instead of starting the editing session.
+   */
+  private transient TableCellEditor booleanInvertingEditor; 
+  
+  /**
+   * Creates a new <code>JTable</code> instance.
+   */
+  public JTable ()
+  {
+    this(null, null, null);
+  }
+
+  /**
+   * Creates a new <code>JTable</code> instance with the given number
+   * of rows and columns.
+   *
+   * @param numRows an <code>int</code> value
+   * @param numColumns an <code>int</code> value
+   */
+  public JTable (int numRows, int numColumns)
+  {
+    this(new DefaultTableModel(numRows, numColumns));
+  }
+
+  /**
+   * Creates a new <code>JTable</code> instance, storing the given data 
+   * array and heaving the given column names. To see the column names,
+   * you must place the JTable into the {@link JScrollPane}.
+   *
+   * @param data an <code>Object[][]</code> the table data
+   * @param columnNames an <code>Object[]</code> the column headers
+   */
+  public JTable(Object[][] data, Object[] columnNames)
+  {
+    this(new DefaultTableModel(data, columnNames));
+  }
+
+  /**
+   * Creates a new <code>JTable</code> instance, using the given data model
+   * object that provides information about the table content. The table model
+   * object is asked for the table size, other features and also receives
+   * notifications in the case when the table has been edited by the user.
+   * 
+   * @param model
+   *          the table model.
+   */
+  public JTable (TableModel model)
+  {
+    this(model, null, null);
+  }
+
+  /**
+   * Creates a new <code>JTable</code> instance, using the given model object
+   * that provides information about the table content. The table data model
+   * object is asked for the table size, other features and also receives
+   * notifications in the case when the table has been edited by the user. The
+   * table column model provides more detailed control on the table column
+   * related features.
+   * 
+   * @param dm
+   *          the table data mode
+   * @param cm
+   *          the table column model
+   */
+  public JTable (TableModel dm, TableColumnModel cm)
+  {
+    this(dm, cm, null);
+  }
+
+  /**
+   * Creates a new <code>JTable</code> instance, providing data model,
+   * column model and list selection model. The list selection model
+   * manages the selections.
+   *
+   * @param dm data model (manages table data)
+   * @param cm column model (manages table columns)
+   * @param sm list selection model (manages table selections)
+   */
+  public JTable (TableModel dm, TableColumnModel cm, ListSelectionModel sm)
+  {
+    boolean autoCreate = false;
+    TableColumnModel columnModel;
+    if (cm != null)
+        columnModel = cm;
+    else 
+      {
+        columnModel = createDefaultColumnModel();
+        autoCreate = true;
+      }
+    
+    // Initialise the intercelar spacing before setting the column model to
+    // avoid firing unnecessary events.
+    // The initial incellar spacing is new Dimenstion(1,1). 
+    rowMargin = 1;
+    columnModel.setColumnMargin(1);
+    setColumnModel(columnModel);
+    
+    setSelectionModel(sm == null ? createDefaultSelectionModel() : sm);
+    setModel(dm == null ? createDefaultDataModel() : dm);
+    setAutoCreateColumnsFromModel(autoCreate);
+    initializeLocalVars();
+    // The following four lines properly set the lead selection indices.
+    // After this, the UI will handle the lead selection indices.
+    // FIXME: this should probably not be necessary, if the UI is installed
+    // before the TableModel is set then the UI will handle things on its
+    // own, but certain variables need to be set before the UI can be installed
+    // so we must get the correct order for all the method calls in this
+    // constructor.
+    selectionModel.setAnchorSelectionIndex(0);    
+    selectionModel.setLeadSelectionIndex(0);
+    columnModel.getSelectionModel().setAnchorSelectionIndex(0);
+    columnModel.getSelectionModel().setLeadSelectionIndex(0);
+    updateUI();
+  }
+  
+  /**
+   * Creates a new <code>JTable</code> instance that uses data and column
+   * names, stored in {@link Vector}s.
+   *
+   * @param data the table data
+   * @param columnNames the table column names.
+   */
+  public JTable(Vector data, Vector columnNames)
+  {
+    this(new DefaultTableModel(data, columnNames));
+  }  
+  
+  /**
+   * Initialize local variables to default values.
+   */
+  protected void initializeLocalVars()
+  {
+    setTableHeader(createDefaultTableHeader());
+    if (autoCreateColumnsFromModel)
+      createDefaultColumnsFromModel();
+    this.columnModel.addColumnModelListener(this);
+
+    this.autoResizeMode = AUTO_RESIZE_SUBSEQUENT_COLUMNS;
+    setRowHeight(16);
+    this.rowMargin = 1;
+    this.rowSelectionAllowed = true;
+    // this.accessibleContext = new AccessibleJTable();
+    this.cellEditor = null;
+    // COMPAT: Both Sun and IBM have drag enabled
+    this.dragEnabled = true;
+    this.preferredViewportSize = new Dimension(450,400);
+    this.showHorizontalLines = true;
+    this.showVerticalLines = true;
+    this.editingColumn = -1;
+    this.editingRow = -1;
+  }
+  
+  /**
+   * Add the new table column. The table column class allows to specify column
+   * features more precisely, setting the preferred width, column data type
+   * (column class) and table headers.
+   * 
+   * There is no need the add columns to the table if the default column 
+   * handling is sufficient.
+   * 
+   * @param column
+   *          the new column to add.
+   */
+  public void addColumn(TableColumn column)
+  {
+    if (column.getHeaderValue() == null)
+      {
+        String name = dataModel.getColumnName(column.getModelIndex());
+        column.setHeaderValue(name);
+      }
+    
+    columnModel.addColumn(column);
+    column.addPropertyChangeListener(tableColumnPropertyChangeHandler);
+  }
+  
+  /**
+   * Create the default editors for this table. The default method creates
+   * the editor for Booleans.
+   * 
+   * Other fields are edited as strings at the moment.
+   */
+  protected void createDefaultEditors()
+  {
+    JCheckBox box = new BooleanCellRenderer().getCheckBox();
+    box.setBorder(BorderFactory.createLineBorder(getGridColor(), 2));
+    box.setBorderPainted(true);
+    booleanInvertingEditor = new DefaultCellEditor(box);    
+    setDefaultEditor(Boolean.class, booleanInvertingEditor);
+  }
+  
+  /**
+   * Create the default renderers for this table. The default method creates
+   * renderers for Boolean, Number, Double, Date, Icon and ImageIcon.
+   *
+   */
+  protected void createDefaultRenderers()
+  {
+    setDefaultRenderer(Boolean.class, new BooleanCellRenderer());
+    setDefaultRenderer(Number.class, new NumberCellRenderer());
+    setDefaultRenderer(Double.class, new DoubleCellRenderer());
+    setDefaultRenderer(Double.class, new FloatCellRenderer());
+    setDefaultRenderer(Date.class, new DateCellRenderer());
+    setDefaultRenderer(Icon.class, new IconCellRenderer());
+    setDefaultRenderer(ImageIcon.class, new IconCellRenderer());    
+  }
+  
+  /**
+   * @deprecated 1.0.2, replaced by <code>new JScrollPane(JTable)</code>
+   */
+  public static JScrollPane createScrollPaneForTable(JTable table)
+  {
+    return new JScrollPane(table);
+  }
+  
+  /**
+   * Create the default table column model that is used if the user-defined
+   * column model is not provided. The default method creates
+   * {@link DefaultTableColumnModel}.
+   * 
+   * @return the created table column model.
+   */
+  protected TableColumnModel createDefaultColumnModel()
+  {
+    return new DefaultTableColumnModel();
+  }
+
+  /**
+   * Create the default table data model that is used if the user-defined
+   * data model is not provided. The default method creates
+   * {@link DefaultTableModel}.
+   * 
+   * @return the created table data model.
+   */
+  protected TableModel createDefaultDataModel()
+  {
+    return new DefaultTableModel();
+  }
+
+  /**
+   * Create the default table selection model that is used if the user-defined
+   * selection model is not provided. The default method creates
+   * {@link DefaultListSelectionModel}.
+   * 
+   * @return the created table data model.
+   */
+  protected ListSelectionModel createDefaultSelectionModel()
+  {
+    return new DefaultListSelectionModel();
+  }
+  
+  /**
+   * Create the default table header, if the user - defined table header is not
+   * provided.
+   * 
+   * @return the default table header.
+   */
+  protected JTableHeader createDefaultTableHeader()
+  {
+    return new JTableHeader(columnModel);
+  }
+  
+  /**
+   * Invoked when the column is added. Revalidates and repains the table.
+   */
+  public void columnAdded (TableColumnModelEvent event)
+  {
+    revalidate();
+    repaint();
+  }
+
+  /**
+   * Invoked when the column margin is changed. 
+   * Revalidates and repains the table.
+   */
+  public void columnMarginChanged (ChangeEvent event)
+  {
+    revalidate();
+    repaint();
+  }
+
+  /**
+   * Invoked when the column is moved. Revalidates and repains the table.
+   */
+  public void columnMoved (TableColumnModelEvent event)
+  {
+    if (isEditing())
+      editingCanceled(null);
+    revalidate();
+    repaint();
+  }
+
+  /**
+   * Invoked when the column is removed. Revalidates and repains the table.
+   */
+  public void columnRemoved (TableColumnModelEvent event)
+  {
+    revalidate();
+    repaint();
+  }
+  
+  /**
+   * Invoked when the the column selection changes, repaints the changed
+   * columns. It is not recommended to override this method, register the
+   * listener instead.
+   */
+  public void columnSelectionChanged (ListSelectionEvent event)
+  {
+    // We must limit the indices to the bounds of the JTable's model, because
+    // we might get values of -1 or greater then columnCount in the case
+    // when columns get removed.
+    int idx0 = Math.max(0, Math.min(getColumnCount() - 1,
+                                    event.getFirstIndex()));
+    int idxn = Math.max(0, Math.min(getColumnCount() - 1,
+                                    event.getLastIndex()));
+
+    int minRow = 0;
+    int maxRow = getRowCount() - 1;
+    if (getRowSelectionAllowed())
+      {
+        minRow = selectionModel.getMinSelectionIndex();
+        maxRow = selectionModel.getMaxSelectionIndex();
+        int leadRow = selectionModel.getLeadSelectionIndex();
+        if (minRow == -1 && maxRow == -1)
+          {
+            minRow = leadRow;
+            maxRow = leadRow;
+          }
+        else
+          {
+            // In this case we need to repaint also the range to leadRow, not
+            // only between min and max.
+            if (leadRow != -1)
+              {
+                minRow = Math.min(minRow, leadRow);
+                maxRow = Math.max(maxRow, leadRow);
+              }
+          }
+      }
+    if (minRow != -1 && maxRow != -1)
+      {
+        Rectangle first = getCellRect(minRow, idx0, false);
+        Rectangle last = getCellRect(maxRow, idxn, false);
+        Rectangle dirty = SwingUtilities.computeUnion(first.x, first.y,
+                                                      first.width,
+                                                      first.height, last);
+        repaint(dirty);
+      }
+  }
+ 
+  /**
+   * Invoked when the editing is cancelled.
+   */
+  public void editingCanceled (ChangeEvent event)
+  {
+    if (editorComp!=null)
+      {
+        remove(editorComp);
+        repaint(editorComp.getBounds());        
+        editorComp = null;
+      }
+  }
+  
+  /**
+   * Finish the current editing session and update the table with the
+   * new value by calling {@link #setValueAt}.
+   * 
+   * @param event the change event
+   */
+  public void editingStopped (ChangeEvent event)
+  {
+    if (editorComp!=null)
+      {
+        remove(editorComp);        
+        setValueAt(cellEditor.getCellEditorValue(), editingRow, editingColumn);            
+        repaint(editorComp.getBounds());
+        editorComp = null;
+      }
+    requestFocusInWindow();
+  }
+
+  /**
+   * Invoked when the table changes.
+   * <code>null</code> means everything changed.
+   */
+  public void tableChanged (TableModelEvent event)
+  {
+    // update the column model from the table model if the structure has
+    // changed and the flag autoCreateColumnsFromModel is set
+    if (event == null || (event.getFirstRow() == TableModelEvent.HEADER_ROW))
+      handleCompleteChange(event);
+    else if (event.getType() == TableModelEvent.INSERT)
+      handleInsert(event);
+    else if (event.getType() == TableModelEvent.DELETE)
+      handleDelete(event);
+    else
+      handleUpdate(event);
+  }
+
+  /**
+   * Handles a request for complete relayout. This is the case when
+   * event.getFirstRow() == TableModelEvent.HEADER_ROW.
+   *
+   * @param ev the table model event
+   */
+  private void handleCompleteChange(TableModelEvent ev)
+  {
+    clearSelection();
+    checkSelection();
+    rowHeights = null;
+    if (getAutoCreateColumnsFromModel())
+      createDefaultColumnsFromModel();
+    else
+      resizeAndRepaint();
+  }
+
+  /**
+   * Handles table model insertions.
+   *
+   * @param ev the table model event
+   */
+  private void handleInsert(TableModelEvent ev)
+  {
+    // Sync selection model with data model.
+    int first = ev.getFirstRow();
+    if (first < 0)
+      first = 0;
+    int last = ev.getLastRow();
+    if (last < 0)
+      last = getRowCount() - 1;
+    selectionModel.insertIndexInterval(first, last - first + 1, true);
+    checkSelection();
+
+    // For variable height rows we must update the SizeSequence thing.
+    if (rowHeights != null)
+      {
+        rowHeights.insertEntries(first, last - first + 1, rowHeight);
+        // TODO: We repaint the whole thing when the rows have variable
+        // heights. We might want to handle this better though.
+        repaint();
+      }
+    else
+      {
+        // Repaint the dirty region and revalidate.
+        int rowHeight = getRowHeight();
+        Rectangle dirty = new Rectangle(0, first * rowHeight,
+                                        getColumnModel().getTotalColumnWidth(),
+                                        (getRowCount() - first) * rowHeight);
+        repaint(dirty);
+      }
+    revalidate();
+  }
+
+  /**
+   * Handles table model deletions.
+   *
+   * @param ev the table model event
+   */
+  private void handleDelete(TableModelEvent ev)
+  {
+    // Sync selection model with data model.
+    int first = ev.getFirstRow();
+    if (first < 0)
+      first = 0;
+    int last = ev.getLastRow();
+    if (last < 0)
+      last = getRowCount() - 1;
+
+    selectionModel.removeIndexInterval(first, last);
+
+    checkSelection();
+
+    if (dataModel.getRowCount() == 0)
+      clearSelection();
+
+    // For variable height rows we must update the SizeSequence thing.
+    if (rowHeights != null)
+      {
+        rowHeights.removeEntries(first, last - first + 1);
+        // TODO: We repaint the whole thing when the rows have variable
+        // heights. We might want to handle this better though.
+        repaint();
+      }
+    else
+      {
+        // Repaint the dirty region and revalidate.
+        int rowHeight = getRowHeight();
+        int oldRowCount = getRowCount() + last - first + 1;
+        Rectangle dirty = new Rectangle(0, first * rowHeight,
+                                        getColumnModel().getTotalColumnWidth(),
+                                        (oldRowCount - first) * rowHeight);
+        repaint(dirty);
+      }
+    revalidate();
+  }
+
+  /**
+   * Handles table model updates without structural changes.
+   *
+   * @param ev the table model event
+   */
+  private void handleUpdate(TableModelEvent ev)
+  {
+    if (rowHeights == null)
+      {
+        // Some cells have been changed without changing the structure.
+        // Figure out the dirty rectangle and repaint.
+        int firstRow = ev.getFirstRow();
+        int lastRow = ev.getLastRow();
+        int col = ev.getColumn();
+        Rectangle dirty;
+        if (col == TableModelEvent.ALL_COLUMNS)
+          {
+            // All columns changed. 
+            dirty = new Rectangle(0, firstRow * getRowHeight(),
+                                  getColumnModel().getTotalColumnWidth(), 0);
+          }
+        else
+          {
+            // Only one cell or column of cells changed.
+            // We need to convert to view column first.
+            int column = convertColumnIndexToModel(col);
+            dirty = getCellRect(firstRow, column, false);
+          }
+
+        // Now adjust the height of the dirty region.
+        dirty.height = (lastRow + 1) * getRowHeight();
+        // .. and repaint.
+        repaint(dirty);
+      }
+    else
+      {
+        // TODO: We repaint the whole thing when the rows have variable
+        // heights. We might want to handle this better though.
+        repaint();
+      }
+  }
+
+  /**
+   * Helper method for adjusting the lead and anchor indices when the
+   * table structure changed. This sets the lead and anchor to -1 if there's
+   * no more rows, or set them to 0 when they were at -1 and there are actually
+   * some rows now.
+   */
+  private void checkSelection()
+  {
+    TableModel m = getModel();
+    ListSelectionModel sm = selectionModel;
+    if (m != null)
+      {
+        int lead = sm.getLeadSelectionIndex();
+        int c = m.getRowCount();
+        if (c == 0 && lead != -1)
+          {
+            // No rows in the model, reset lead and anchor to -1.
+            sm.setValueIsAdjusting(true);
+            sm.setAnchorSelectionIndex(-1);
+            sm.setLeadSelectionIndex(-1);
+            sm.setValueIsAdjusting(false);
+          }
+        else if (c != 0 && lead == -1)
+          {
+            // We have rows, but no lead/anchor. Set them to 0. We
+            // do a little trick here so that the actual selection is not
+            // touched.
+            if (sm.isSelectedIndex(0))
+              sm.addSelectionInterval(0, 0);
+            else
+              sm.removeSelectionInterval(0, 0);
+          }
+        // Nothing to do in the other cases.
+      }
+  }
+
+  /**
+   * Invoked when another table row is selected. It is not recommended
+   * to override thid method, register the listener instead.
+   */
+  public void valueChanged (ListSelectionEvent event)
+  {
+    // If we are in the editing process, end the editing session.
+    if (isEditing())
+      editingStopped(null);
+    
+    // Repaint the changed region.
+    int first = Math.max(0, Math.min(getRowCount() - 1, event.getFirstIndex()));
+    int last = Math.max(0, Math.min(getRowCount() - 1, event.getLastIndex()));
+    Rectangle rect1 = getCellRect(first, 0, false);
+    Rectangle rect2 = getCellRect(last, getColumnCount() - 1, false);
+    Rectangle dirty = SwingUtilities.computeUnion(rect2.x, rect2.y,
+                                                  rect2.width, rect2.height,
+                                                  rect1);
+    repaint(dirty);
+  }
+
+ /**
+   * Returns index of the column that contains specified point 
+   * or -1 if this table doesn't contain this point.
+   *
+   * @param point point to identify the column
+   * @return index of the column that contains specified point or 
+   * -1 if this table doesn't contain this point.
+   */
+  public int columnAtPoint(Point point)
+  {
+    int ncols = getColumnCount();
+    Dimension gap = getIntercellSpacing();
+    TableColumnModel cols = getColumnModel();
+    int x = point.x;
+
+    for (int i = 0; i < ncols; ++i)
+      {
+        int width = cols.getColumn(i).getWidth()
+                    + (gap == null ? 0 : gap.width);
+        if (0 <= x && x < width)
+          return i;
+        x -= width;
+      }
+    return -1;
+  }
+
+  /**
+   * Returns index of the row that contains specified point or -1 if this table
+   * doesn't contain this point.
+   * 
+   * @param point point to identify the row
+   * @return index of the row that contains specified point or -1 if this table
+   *         doesn't contain this point.
+   */
+  public int rowAtPoint(Point point)
+  {
+    if (point != null)
+      {
+        int nrows = getRowCount();
+        int r;
+        int y = point.y;
+        if (rowHeights == null)
+          {
+            int height = getRowHeight();
+            r = y / height;
+          }
+        else
+          r = rowHeights.getIndex(y);
+
+        if (r < 0 || r >= nrows)
+          return -1;
+        else
+          return r;
+      }
+    else
+      return -1;
+  }
+
+  /** 
+   * Calculate the visible rectangle for a particular row and column. The
+   * row and column are specified in visual terms; the column may not match
+   * the {@link #dataModel} column.
+   *
+   * @param row the visible row to get the cell rectangle of
+   *
+   * @param column the visible column to get the cell rectangle of, which may
+   * differ from the {@link #dataModel} column
+   *
+   * @param includeSpacing whether or not to include the cell margins in the
+   * resulting cell. If <code>false</code>, the result will only contain the
+   * inner area of the target cell, not including its margins.
+   *
+   * @return a rectangle enclosing the specified cell
+   */
+  public Rectangle getCellRect(int row,
+                               int column,
+                               boolean includeSpacing)
+  {
+    Rectangle cellRect = new Rectangle(0, 0, 0, 0);
+
+    // Check for valid range vertically.
+    if (row >= getRowCount())
+      {
+        cellRect.height = getHeight();
+      }
+    else if (row >= 0)
+      {
+        cellRect.height = getRowHeight(row);
+        if (rowHeights == null)
+          cellRect.y = row * cellRect.height;
+        else
+          cellRect.y = rowHeights.getPosition(row);
+
+        if (! includeSpacing)
+          {
+            // The rounding here is important.
+            int rMargin = getRowMargin();
+            cellRect.y += rMargin / 2;
+            cellRect.height -= rMargin;
+          }
+      }
+    // else row < 0, y = height = 0
+
+    // Check for valid range horizontally.
+    if (column < 0)
+      {
+        if (! getComponentOrientation().isLeftToRight())
+          {
+            cellRect.x = getWidth();
+          }
+      }
+    else if (column >= getColumnCount())
+      {
+        if (getComponentOrientation().isLeftToRight())
+          {
+            cellRect.x = getWidth();
+          }
+      }
+    else
+      {
+        TableColumnModel tcm = getColumnModel();
+        if (getComponentOrientation().isLeftToRight())
+          {
+            for (int i = 0; i < column; i++)
+              cellRect.x += tcm.getColumn(i).getWidth();
+          }
+        else
+          {
+            for (int i = tcm.getColumnCount() - 1; i > column; i--)
+              cellRect.x += tcm.getColumn(i).getWidth();
+          }
+        cellRect.width = tcm.getColumn(column).getWidth();
+        if (! includeSpacing)
+          {
+            // The rounding here is important.
+            int cMargin = tcm.getColumnMargin();
+            cellRect.x += cMargin / 2;
+            cellRect.width -= cMargin;
+          }
+      }
+
+    return cellRect;
+  }
+
+  public void clearSelection()
+  {
+    selectionModel.clearSelection();
+    getColumnModel().getSelectionModel().clearSelection();
+  }
+
+  /**
+   * Get the value of the selectedRow property by delegation to
+   * the {@link ListSelectionModel#getMinSelectionIndex} method of the
+   * {@link #selectionModel} field.
+   *
+   * @return The current value of the selectedRow property
+   */
+  public int getSelectedRow ()
+  {    
+    return selectionModel.getMinSelectionIndex();
+  }
+  
+  /**
+   * Get the value of the {@link #selectionModel} property.
+   *
+   * @return The current value of the property
+   */
+  public ListSelectionModel getSelectionModel()
+  {
+    //Neither Sun nor IBM returns null if rowSelection not allowed
+    return selectionModel;
+  }
+  
+  public int getScrollableBlockIncrement(Rectangle visibleRect, int orientation, int direction)
+  {
+    if (orientation == SwingConstants.VERTICAL)
+      return visibleRect.height * direction;
+    else
+      return visibleRect.width * direction;
+  }
+
+  /**
+   * Get the value of the <code>scrollableTracksViewportHeight</code> property.
+   *
+   * @return The constant value <code>false</code>
+   */
+  public boolean getScrollableTracksViewportHeight()
+  {
+    return false;
+  }
+  
+  /**
+   * Get the value of the <code>scrollableTracksViewportWidth</code> property.
+   *
+   * @return <code>true</code> unless the {@link #autoResizeMode} property is
+   * <code>AUTO_RESIZE_OFF</code>
+   */
+  public boolean getScrollableTracksViewportWidth()
+  {
+    if (autoResizeMode == AUTO_RESIZE_OFF)
+      return false;
+    else
+      return true;
+  }
+  
+  /**
+   * Return the preferred scrolling amount (in pixels) for the given scrolling
+   * direction and orientation. This method handles a partially exposed row by
+   * returning the distance required to completely expose the item. When
+   * scrolling the top item is completely exposed.
+   * 
+   * @param visibleRect the currently visible part of the component.
+   * @param orientation the scrolling orientation
+   * @param direction the scrolling direction (negative - up, positive -down).
+   *          The values greater than one means that more mouse wheel or similar
+   *          events were generated, and hence it is better to scroll the longer
+   *          distance.
+   * @author Audrius Meskauskas (audriusa at bioinformatics.org)
+   */
+  public int getScrollableUnitIncrement(Rectangle visibleRect, int orientation,
+                                        int direction)
+  {
+    int h = (rowHeight + rowMargin);
+    int delta = h * direction;
+
+    // Round so that the top would start from the row boundary
+    if (orientation == SwingConstants.VERTICAL)
+      {
+        // Completely expose the top row
+        int near = ((visibleRect.y + delta + h / 2) / h) * h;
+        int diff = visibleRect.y + delta - near;
+        delta -= diff;
+      }
+    return delta;
+    // TODO when scrollng horizontally, scroll into the column boundary.
+  }
+
+  /**
+   * Get the cell editor, suitable for editing the given cell. The default
+   * method requests the editor from the column model. If the column model does
+   * not provide the editor, the call is forwarded to the
+   * {@link #getDefaultEditor(Class)} with the parameter, obtained from
+   * {@link TableModel#getColumnClass(int)}.
+   * 
+   * @param row the cell row
+   * @param column the cell column
+   * @return the editor to edit that cell
+   */
+  public TableCellEditor getCellEditor(int row, int column)
+  {
+    TableCellEditor editor = columnModel.getColumn(column).getCellEditor();
+
+    if (editor == null)
+      {
+        int mcolumn = convertColumnIndexToModel(column);
+        editor = getDefaultEditor(dataModel.getColumnClass(mcolumn));
+      }
+
+    return editor;
+  }
+  
+  /**
+   * Get the default editor for editing values of the given type
+   * (String, Boolean and so on).
+   * 
+   * @param columnClass the class of the value that will be edited.
+   * 
+   * @return the editor, suitable for editing this data type
+   */
+  public TableCellEditor getDefaultEditor(Class columnClass)
+  {
+    if (defaultEditorsByColumnClass.containsKey(columnClass))
+      return (TableCellEditor) defaultEditorsByColumnClass.get(columnClass);
+    else
+      {
+        JTextField t = new TableTextField();        
+        TableCellEditor r = new DefaultCellEditor(t);
+        defaultEditorsByColumnClass.put(columnClass, r);
+        return r;
+      }
+  }
+  
+  /**
+   * Get the cell renderer for rendering the given cell.
+   * 
+   * @param row the cell row
+   * @param column the cell column
+   * @return the cell renderer to render that cell.
+   */
+  public TableCellRenderer getCellRenderer(int row, int column)
+  {
+    TableCellRenderer renderer = columnModel.getColumn(column).getCellRenderer();
+    if (renderer == null)
+      {
+        int mcolumn = convertColumnIndexToModel(column);
+        renderer = getDefaultRenderer(dataModel.getColumnClass(mcolumn));
+      }
+    return renderer;
+  }
+  
+  /**
+   * Set default renderer for rendering the given data type.
+   * 
+   * @param columnClass the data type (String, Boolean and so on) that must be
+   *          rendered.
+   * @param rend the renderer that will rend this data type
+   */
+  public void setDefaultRenderer(Class columnClass, TableCellRenderer rend)
+  {
+    defaultRenderersByColumnClass.put(columnClass, rend);
+  }
+  
+  /**
+   * Get the default renderer for rendering the given data type.
+   * 
+   * @param columnClass the data that must be rendered
+   * 
+   * @return the appropriate defauld renderer for rendering that data type.
+   */
+  public TableCellRenderer getDefaultRenderer(Class columnClass)
+  {
+    if (defaultRenderersByColumnClass.containsKey(columnClass))
+      return (TableCellRenderer) defaultRenderersByColumnClass.get(columnClass);
+    else
+      {
+        TableCellRenderer r = new DefaultTableCellRenderer();
+        defaultRenderersByColumnClass.put(columnClass, r);
+        return r;
+      }
+  }
+  
+  /**
+   * Convert the table model index into the table column number.
+   * The model number need not match the real column position. The columns
+   * may be rearranged by the user with mouse at any time by dragging the
+   * column headers.
+   *
+   * @param vc the column number (0=first).
+   * 
+   * @return the table column model index of this column.
+   * 
+   * @see TableColumn#getModelIndex()
+   */
+  public int convertColumnIndexToModel(int vc)
+  {
+    if (vc < 0)
+      return vc;
+    else
+      return columnModel.getColumn(vc).getModelIndex();
+  }
+  
+  /**
+   * Convert the table column number to the table column model index.
+   * The model number need not match the real column position. The columns
+   * may be rearranged by the user with mouse at any time by dragging the
+   * column headers.
+   *  
+   * @param mc the table column index (0=first).
+   * 
+   * @return the table column number in the model
+   * 
+   * @see TableColumn#getModelIndex() 
+   */
+  public int convertColumnIndexToView(int mc)
+  {
+    if (mc < 0)
+      return mc;
+    int ncols = getColumnCount();
+    for (int vc = 0; vc < ncols; ++vc)
+      {
+        if (columnModel.getColumn(vc).getModelIndex() == mc)
+          return vc;
+      }
+    return -1;
+  }
+  
+  /**
+   * Prepare the renderer for rendering the given cell.
+   * 
+   * @param renderer the renderer being prepared
+   * @param row the row of the cell being rendered
+   * @param column the column of the cell being rendered
+   * 
+   * @return the component which .paint() method will paint the cell.
+   */
+  public Component prepareRenderer(TableCellRenderer renderer,
+                                   int row,
+                                   int column)
+  {
+    boolean rowSelAllowed = getRowSelectionAllowed();
+    boolean colSelAllowed = getColumnSelectionAllowed();
+    boolean isSel = false;
+    if (rowSelAllowed && colSelAllowed || !rowSelAllowed && !colSelAllowed)
+      isSel = isCellSelected(row, column);
+    else
+      isSel = isRowSelected(row) && getRowSelectionAllowed()
+           || isColumnSelected(column) && getColumnSelectionAllowed();
+
+    // Determine the focused cell. The focused cell is the cell at the
+    // leadSelectionIndices of the row and column selection model.
+    ListSelectionModel rowSel = getSelectionModel();
+    ListSelectionModel colSel = getColumnModel().getSelectionModel();
+    boolean hasFocus = hasFocus() && isEnabled()
+                       && rowSel.getLeadSelectionIndex() == row
+                       && colSel.getLeadSelectionIndex() == column;
+
+    return renderer.getTableCellRendererComponent(this,
+                                                  dataModel.getValueAt(row, 
+						                       convertColumnIndexToModel(column)),
+                                                  isSel,
+                                                  hasFocus,
+                                                  row, column);
+  }
+
+
+  /**
+   * Get the value of the {@link #autoCreateColumnsFromModel} property.
+   *
+   * @return The current value of the property
+   */
+  public boolean getAutoCreateColumnsFromModel()
+  {
+    return autoCreateColumnsFromModel;
+  }
+
+  /**
+   * Get the value of the {@link #autoResizeMode} property.
+   *
+   * @return The current value of the property
+   */
+  public int getAutoResizeMode()
+  {
+    return autoResizeMode;
+  }
+
+  /**
+   * Get the value of the {@link #rowHeight} property.
+   *
+   * @return The current value of the property
+   */
+  public int getRowHeight()
+  {
+    return rowHeight;
+  }
+
+  /**
+   * Get the height of the specified row.
+   *
+   * @param row the row whose height to return
+   */
+  public int getRowHeight(int row)
+  {
+    int rh = rowHeight;
+    if (rowHeights != null)
+      rh = rowHeights.getSize(row);
+    return rh;
+  }
+
+
+  /**
+   * Get the value of the {@link #rowMargin} property.
+   *
+   * @return The current value of the property
+   */
+  public int getRowMargin()
+  {
+    return rowMargin;
+  }
+
+  /**
+   * Get the value of the {@link #rowSelectionAllowed} property.
+   *
+   * @return The current value of the property
+   * 
+   * @see #setRowSelectionAllowed(boolean)
+   */
+  public boolean getRowSelectionAllowed()
+  {
+    return rowSelectionAllowed;
+  }
+
+  /**
+   * Get the value of the {@link #cellSelectionEnabled} property.
+   *
+   * @return The current value of the property
+   */
+  public boolean getCellSelectionEnabled()
+  {
+    return getColumnSelectionAllowed() && getRowSelectionAllowed();
+  }
+
+  /**
+   * Get the value of the {@link #dataModel} property.
+   *
+   * @return The current value of the property
+   */
+  public TableModel getModel()
+  {
+    return dataModel;
+  }
+
+  /**
+   * Get the value of the <code>columnCount</code> property by
+   * delegation to the {@link #columnModel} field.
+   *
+   * @return The current value of the columnCount property
+   */
+  public int getColumnCount()
+  {
+    return columnModel.getColumnCount();    
+  }
+
+  /**
+   * Get the value of the <code>rowCount</code> property by
+   * delegation to the {@link #dataModel} field.
+   *
+   * @return The current value of the rowCount property
+   */
+  public int getRowCount()
+  {
+    return dataModel.getRowCount();
+  }
+
+  /**
+   * Get the value of the {@link #columnModel} property.
+   *
+   * @return The current value of the property
+   */
+  public TableColumnModel getColumnModel()
+  {
+    return columnModel;
+  }
+
+  /**
+   * Get the value of the <code>selectedColumn</code> property by
+   * delegation to the {@link #columnModel} field.
+   *
+   * @return The current value of the selectedColumn property
+   */
+  public int getSelectedColumn()
+  {
+    return columnModel.getSelectionModel().getMinSelectionIndex();
+  }
+
+  private static int countSelections(ListSelectionModel lsm)
+  {
+    int lo = lsm.getMinSelectionIndex();
+    int hi = lsm.getMaxSelectionIndex();
+    int sum = 0;
+    if (lo != -1 && hi != -1)
+      {
+        switch (lsm.getSelectionMode())
+          {
+          case ListSelectionModel.SINGLE_SELECTION:
+            sum = 1;
+            break;
+            
+          case ListSelectionModel.SINGLE_INTERVAL_SELECTION:
+            sum = hi - lo + 1;
+            break;
+            
+          case ListSelectionModel.MULTIPLE_INTERVAL_SELECTION:        
+            for (int i = lo; i <= hi; ++i)
+              if (lsm.isSelectedIndex(i))        
+                ++sum;
+            break;
+          }
+      }
+    return sum;
+  }
+
+  private static int[] getSelections(ListSelectionModel lsm)
+  {
+    int sz = countSelections(lsm);
+    int [] ret = new int[sz];
+
+    int lo = lsm.getMinSelectionIndex();
+    int hi = lsm.getMaxSelectionIndex();
+    int j = 0;
+    if (lo != -1 && hi != -1)
+      {
+        switch (lsm.getSelectionMode())
+          {
+          case ListSelectionModel.SINGLE_SELECTION:
+            ret[0] = lo;
+            break;      
+      
+          case ListSelectionModel.SINGLE_INTERVAL_SELECTION:            
+            for (int i = lo; i <= hi; ++i)
+              ret[j++] = i;
+            break;
+            
+          case ListSelectionModel.MULTIPLE_INTERVAL_SELECTION:        
+            for (int i = lo; i <= hi; ++i)
+              if (lsm.isSelectedIndex(i))        
+                ret[j++] = i;
+            break;
+          }
+      }
+    return ret;
+  }
+
+  /**
+   * Get the value of the <code>selectedColumnCount</code> property by
+   * delegation to the {@link #columnModel} field.
+   *
+   * @return The current value of the selectedColumnCount property
+   */  
+  public int getSelectedColumnCount()
+  {
+    return countSelections(columnModel.getSelectionModel());
+  }
+
+  /**
+   * Get the value of the <code>selectedColumns</code> property by
+   * delegation to the {@link #columnModel} field.
+   *
+   * @return The current value of the selectedColumns property
+   */
+  public int[] getSelectedColumns()
+  {
+    return getSelections(columnModel.getSelectionModel());
+  }
+
+  /**
+   * Get the value of the <code>columnSelectionAllowed</code> property.
+   *
+   * @return The current value of the columnSelectionAllowed property
+   * 
+   * @see #setColumnSelectionAllowed(boolean)
+   */
+  public boolean getColumnSelectionAllowed()
+  {
+    return getColumnModel().getColumnSelectionAllowed();
+  }
+
+  /**
+   * Get the value of the <code>selectedRowCount</code> property by
+   * delegation to the {@link #selectionModel} field.
+   *
+   * @return The current value of the selectedRowCount property
+   */
+  public int getSelectedRowCount()
+  {
+    return countSelections(selectionModel);
+  }
+
+  /**
+   * Get the value of the <code>selectedRows</code> property by
+   * delegation to the {@link #selectionModel} field.
+   *
+   * @return The current value of the selectedRows property
+   */
+  public int[] getSelectedRows()
+  {
+    return getSelections(selectionModel);
+  }
+
+  /**
+   * Get the value of the {@link #accessibleContext} property.
+   *
+   * @return The current value of the property
+   */
+  public AccessibleContext getAccessibleContext()
+  {
+    if (accessibleContext == null)
+      {
+        AccessibleJTable ctx = new AccessibleJTable();
+        addPropertyChangeListener(ctx);
+        TableColumnModel tcm = getColumnModel();
+        tcm.addColumnModelListener(ctx);
+        tcm.getSelectionModel().addListSelectionListener(ctx);
+        getSelectionModel().addListSelectionListener(ctx);
+        
+        accessibleContext = ctx;
+      }
+    return accessibleContext;
+  }
+
+  /**
+   * Get the value of the {@link #cellEditor} property.
+   *
+   * @return The current value of the property
+   */
+  public TableCellEditor getCellEditor()
+  {
+    return cellEditor;
+  }
+
+  /**
+   * Get the value of the {@link #dragEnabled} property.
+   *
+   * @return The current value of the property
+   */
+  public boolean getDragEnabled()
+  {
+    return dragEnabled;
+  }
+
+  /**
+   * Get the value of the {@link #gridColor} property.
+   *
+   * @return The current value of the property
+   */
+  public Color getGridColor()
+  {
+    return gridColor;
+  }
+
+  /**
+   * Get the value of the <code>intercellSpacing</code> property.
+   *
+   * @return The current value of the property
+   */
+  public Dimension getIntercellSpacing()
+  {
+    return new Dimension(columnModel.getColumnMargin(), rowMargin);
+  }
+
+  /**
+   * Get the value of the {@link #preferredViewportSize} property.
+   *
+   * @return The current value of the property
+   */
+  public Dimension getPreferredScrollableViewportSize()
+  {
+    return preferredViewportSize;
+  }
+
+  /**
+   * Get the value of the {@link #selectionBackground} property.
+   *
+   * @return The current value of the property
+   */
+  public Color getSelectionBackground()
+  {
+    return selectionBackground;
+  }
+
+  /**
+   * Get the value of the {@link #selectionForeground} property.
+   *
+   * @return The current value of the property
+   */
+  public Color getSelectionForeground()
+  {
+    return selectionForeground;
+  }
+
+  /**
+   * Get the value of the {@link #showHorizontalLines} property.
+   *
+   * @return The current value of the property
+   */
+  public boolean getShowHorizontalLines()
+  {
+    return showHorizontalLines;
+  }
+
+  /**
+   * Get the value of the {@link #showVerticalLines} property.
+   *
+   * @return The current value of the property
+   */
+  public boolean getShowVerticalLines()
+  {
+    return showVerticalLines;
+  }
+
+  /**
+   * Get the value of the {@link #tableHeader} property.
+   *
+   * @return The current value of the property
+   */
+  public JTableHeader getTableHeader()
+  {
+    return tableHeader;
+  }
+
+  /**
+   * Removes specified column from displayable columns of this table.
+   *
+   * @param column column to removed
+   */
+  public void removeColumn(TableColumn column)
+  {    
+    columnModel.removeColumn(column);
+  }
+
+  /**
+   * Moves column at the specified index to new given location.
+   *
+   * @param column index of the column to move
+   * @param targetColumn index specifying new location of the column
+   */ 
+  public void moveColumn(int column,int targetColumn) 
+  {
+    columnModel.moveColumn(column, targetColumn);
+  }
+
+  /**
+   * Set the value of the {@link #autoCreateColumnsFromModel} flag.  If the
+   * flag changes from <code>false</code> to <code>true</code>, the
+   * {@link #createDefaultColumnsFromModel()} method is called.
+   *
+   * @param autoCreate  the new value of the flag.
+   */ 
+  public void setAutoCreateColumnsFromModel(boolean autoCreate)
+  {
+    if (autoCreateColumnsFromModel != autoCreate)
+    {
+      autoCreateColumnsFromModel = autoCreate;
+      if (autoCreate)
+        createDefaultColumnsFromModel();
+    }
+  }
+
+  /**
+   * Set the value of the {@link #autoResizeMode} property.
+   *
+   * @param a The new value of the autoResizeMode property
+   */ 
+  public void setAutoResizeMode(int a)
+  {
+    autoResizeMode = a;
+    revalidate();
+    repaint();
+  }
+
+  /**
+   * Sets the height for all rows in the table. If you want to change the
+   * height of a single row instead, use {@link #setRowHeight(int, int)}.
+   *
+   * @param r the height to set for all rows
+   *
+   * @see #getRowHeight()
+   * @see #setRowHeight(int, int)
+   * @see #getRowHeight(int)
+   */ 
+  public void setRowHeight(int r)
+  {
+    if (r < 1)
+      throw new IllegalArgumentException();
+
+    clientRowHeightSet = true;
+
+    rowHeight = r;
+    rowHeights = null;
+    revalidate();
+    repaint();
+  }
+  
+  /**
+   * Sets the height of a single row in the table.
+   * 
+   * @param rh the new row height
+   * @param row the row to change the height of
+   */
+  public void setRowHeight(int row, int rh)
+  {
+    if (rowHeights == null)
+      {
+        rowHeights = new SizeSequence(getRowCount(), rowHeight);
+      }
+    rowHeights.setSize(row, rh);
+  }
+  
+  /**
+   * Set the value of the {@link #rowMargin} property.
+   *
+   * @param r The new value of the rowMargin property
+   */ 
+  public void setRowMargin(int r)
+  {
+    rowMargin = r;
+    revalidate();
+    repaint();
+  }
+
+  /**
+   * Set the value of the {@link #rowSelectionAllowed} property.
+   *
+   * @param r The new value of the rowSelectionAllowed property
+   * 
+   * @see #getRowSelectionAllowed()
+   */ 
+  public void setRowSelectionAllowed(boolean r)
+  {
+    if (rowSelectionAllowed != r) 
+      {
+        rowSelectionAllowed = r;
+        firePropertyChange("rowSelectionAllowed", !r, r);
+        repaint();
+      }
+  }
+
+  /**
+   * Set the value of the {@link #cellSelectionEnabled} property.
+   *
+   * @param c The new value of the cellSelectionEnabled property
+   */ 
+  public void setCellSelectionEnabled(boolean c)
+  {
+    setColumnSelectionAllowed(c);
+    setRowSelectionAllowed(c);
+    // for backward-compatibility sake:
+    cellSelectionEnabled = true;
+  }
+
+  /**
+   * <p>Set the value of the {@link #dataModel} property.</p>
+   *
+   * <p>Unregister <code>this</code> as a {@link TableModelListener} from
+   * previous {@link #dataModel} and register it with new parameter
+   * <code>m</code>.</p>
+   *
+   * @param m The new value of the model property
+   */ 
+  public void setModel(TableModel m)
+  {
+    // Throw exception is m is null.
+    if (m == null)
+      throw new IllegalArgumentException();
+   
+    // Don't do anything if setting the current model again.
+    if (dataModel == m)
+      return;
+
+    TableModel oldModel = dataModel;
+
+    // Remove table as TableModelListener from old model.
+    if (dataModel != null)
+      dataModel.removeTableModelListener(this);
+    
+    if (m != null)
+      {
+        // Set property.
+        dataModel = m;
+
+        // Add table as TableModelListener to new model.
+        dataModel.addTableModelListener(this);
+
+        // Notify the tableChanged method.
+        tableChanged(new TableModelEvent(dataModel,
+                                         TableModelEvent.HEADER_ROW));
+
+        // Automatically create columns.
+        if (autoCreateColumnsFromModel)
+          createDefaultColumnsFromModel();
+      }
+
+    // This property is bound, so we fire a property change event.
+    firePropertyChange("model", oldModel, dataModel);
+
+    // Repaint table.
+    revalidate();
+    repaint();
+  }
+
+  /**
+   * <p>Set the value of the {@link #columnModel} property.</p>
+   *
+   * <p>Unregister <code>this</code> as a {@link TableColumnModelListener}
+   * from previous {@link #columnModel} and register it with new parameter
+   * <code>c</code>.</p>
+   *
+   * @param c The new value of the columnModel property
+   */ 
+  public void setColumnModel(TableColumnModel c)
+  {
+    if (c == null)
+      throw new IllegalArgumentException();
+    TableColumnModel tmp = columnModel;
+    if (tmp != null)
+      tmp.removeColumnModelListener(this);
+    if (c != null)
+      c.addColumnModelListener(this);
+    columnModel = c;
+    if (dataModel != null && columnModel != null)
+      {
+        int ncols = getColumnCount();
+        TableColumn column;
+        for (int i = 0; i < ncols; ++i)
+          {
+            column = columnModel.getColumn(i); 
+            if (column.getHeaderValue()==null)
+              column.setHeaderValue(dataModel.getColumnName(i));
+          }
+      }
+
+    // according to Sun's spec we also have to set the tableHeader's
+    // column model here
+    if (tableHeader != null)
+      tableHeader.setColumnModel(c);
+
+    revalidate();
+    repaint();
+  }
+
+  /**
+   * Set the value of the <code>columnSelectionAllowed</code> property.
+   *
+   * @param c The new value of the property
+   * 
+   * @see #getColumnSelectionAllowed()
+   */ 
+  public void setColumnSelectionAllowed(boolean c)
+  {
+    if (columnModel.getColumnSelectionAllowed() != c)
+      {
+        columnModel.setColumnSelectionAllowed(c);
+        firePropertyChange("columnSelectionAllowed", !c, c);
+        repaint();
+      }
+  }
+
+  /**
+   * <p>Set the value of the {@link #selectionModel} property.</p>
+   *
+   * <p>Unregister <code>this</code> as a {@link ListSelectionListener}
+   * from previous {@link #selectionModel} and register it with new
+   * parameter <code>s</code>.</p>
+   *
+   * @param s The new value of the selectionModel property
+   */ 
+  public void setSelectionModel(ListSelectionModel s)
+  {
+    if (s == null)
+      throw new IllegalArgumentException();
+    ListSelectionModel tmp = selectionModel;
+    if (tmp != null)
+      tmp.removeListSelectionListener(this);
+    if (s != null)
+      s.addListSelectionListener(this);
+    selectionModel = s;
+    checkSelection();
+  }
+
+  /**
+   * Set the value of the <code>selectionMode</code> property by
+   * delegation to the {@link #selectionModel} field. The same selection
+   * mode is set for row and column selection models.
+   *
+   * @param s The new value of the property
+   */ 
+  public void setSelectionMode(int s)
+  { 
+    selectionModel.setSelectionMode(s);    
+    columnModel.getSelectionModel().setSelectionMode(s);
+    
+    repaint();
+  }
+
+  /**
+   * <p>Set the value of the {@link #cellEditor} property.</p>
+   *
+   * <p>Unregister <code>this</code> as a {@link CellEditorListener} from
+   * previous {@link #cellEditor} and register it with new parameter
+   * <code>c</code>.</p>
+   *
+   * @param c The new value of the cellEditor property
+   */ 
+  public void setCellEditor(TableCellEditor c)
+  {
+    TableCellEditor tmp = cellEditor;
+    if (tmp != null)
+      tmp.removeCellEditorListener(this);
+    if (c != null)
+      c.addCellEditorListener(this);
+    cellEditor = c;
+  }
+
+  /**
+   * Set the value of the {@link #dragEnabled} property.
+   *
+   * @param d The new value of the dragEnabled property
+   */ 
+  public void setDragEnabled(boolean d)
+  {
+    dragEnabled = d;
+  }
+
+  /**
+   * Set the value of the {@link #gridColor} property.
+   *
+   * @param g The new value of the gridColor property
+   */ 
+  public void setGridColor(Color g)
+  {
+    gridColor = g;
+    repaint();
+  }
+
+  /**
+   * Set the value of the <code>intercellSpacing</code> property.
+   *
+   * @param i The new value of the intercellSpacing property
+   */ 
+  public void setIntercellSpacing(Dimension i)
+  {
+    rowMargin = i.height;
+    columnModel.setColumnMargin(i.width);
+    repaint();
+  }
+
+  /**
+   * Set the value of the {@link #preferredViewportSize} property.
+   *
+   * @param p The new value of the preferredViewportSize property
+   */ 
+  public void setPreferredScrollableViewportSize(Dimension p)
+  {
+    preferredViewportSize = p;
+    revalidate();
+    repaint();
+  }
+
+  /**
+   * <p>Set the value of the {@link #selectionBackground} property.</p>
+   *
+   * <p>Fire a PropertyChangeEvent with name {@link
+   * #SELECTION_BACKGROUND_CHANGED_PROPERTY} to registered listeners, if
+   * selectionBackground changed.</p>
+   *
+   * @param s The new value of the selectionBackground property
+   */ 
+  public void setSelectionBackground(Color s)
+  {
+    Color tmp = selectionBackground;
+    selectionBackground = s;
+    if (((tmp == null && s != null)
+         || (s == null && tmp != null)
+         || (tmp != null && s != null && !tmp.equals(s))))
+      firePropertyChange(SELECTION_BACKGROUND_CHANGED_PROPERTY, tmp, s);
+    repaint();
+  }
+
+  /**
+   * <p>Set the value of the {@link #selectionForeground} property.</p>
+   *
+   * <p>Fire a PropertyChangeEvent with name {@link
+   * #SELECTION_FOREGROUND_CHANGED_PROPERTY} to registered listeners, if
+   * selectionForeground changed.</p>
+   *
+   * @param s The new value of the selectionForeground property
+   */ 
+  public void setSelectionForeground(Color s)
+  {
+    Color tmp = selectionForeground;
+    selectionForeground = s;
+    if (((tmp == null && s != null)
+         || (s == null && tmp != null)
+         || (tmp != null && s != null && !tmp.equals(s))))
+      firePropertyChange(SELECTION_FOREGROUND_CHANGED_PROPERTY, tmp, s);
+    repaint();
+  }
+
+  /**
+   * Set the value of the <code>showGrid</code> property.
+   *
+   * @param s The new value of the showGrid property
+   */ 
+  public void setShowGrid(boolean s)
+  {
+    setShowVerticalLines(s);
+    setShowHorizontalLines(s);
+  }
+
+  /**
+   * Set the value of the {@link #showHorizontalLines} property.
+   *
+   * @param s The new value of the showHorizontalLines property
+   */ 
+  public void setShowHorizontalLines(boolean s)
+  {
+    showHorizontalLines = s;
+    repaint();
+  }
+
+  /**
+   * Set the value of the {@link #showVerticalLines} property.
+   *
+   * @param s The new value of the showVerticalLines property
+   */ 
+  public void setShowVerticalLines(boolean s)
+  {
+    showVerticalLines = s;
+    repaint();
+  }
+
+  /**
+   * Set the value of the {@link #tableHeader} property.
+   *
+   * @param t The new value of the tableHeader property
+   */ 
+  public void setTableHeader(JTableHeader t)
+  {
+    if (tableHeader != null)
+      tableHeader.setTable(null);
+    tableHeader = t;
+    if (tableHeader != null)
+      tableHeader.setTable(this);
+    revalidate();
+    repaint();
+  }
+
+  protected void configureEnclosingScrollPane()
+  {
+    JScrollPane jsp = (JScrollPane) SwingUtilities.getAncestorOfClass(JScrollPane.class, this);
+    if (jsp != null && tableHeader != null)
+      {
+        jsp.setColumnHeaderView(tableHeader);
+      }
+  }
+
+  protected void unconfigureEnclosingScrollPane()
+  {
+    JScrollPane jsp = (JScrollPane) SwingUtilities.getAncestorOfClass(JScrollPane.class, this);
+    if (jsp != null)
+      {
+        jsp.setColumnHeaderView(null);
+      }    
+  }
+
+
+  public void addNotify()
+  {
+    super.addNotify();
+    configureEnclosingScrollPane();
+  }
+
+  public void removeNotify()
+  {
+    super.addNotify();
+    unconfigureEnclosingScrollPane();
+  }
+
+
+  /**
+   * This distributes the superfluous width in a table evenly on its columns.
+   *
+   * The implementation used here is different to that one described in
+   * the JavaDocs. It is much simpler, and seems to work very well.
+   *
+   * TODO: correctly implement the algorithm described in the JavaDoc
+   */
+  private void distributeSpill(TableColumn[] cols, int spill)
+  {
+    int average = spill / cols.length;
+    for (int i = 0; i < cols.length; i++)
+      {
+        if (cols[i] != null)
+          cols[i].setWidth(cols[i].getPreferredWidth() + average);
+      }
+  }
+  
+  /**
+   * This distributes the superfluous width in a table, setting the width of the
+   * column being resized strictly to its preferred width.
+   */
+  private void distributeSpillResizing(TableColumn[] cols, int spill,
+                                       TableColumn resizeIt)
+  {
+    int average = 0;
+    if (cols.length != 1)
+      average = spill / (cols.length-1);
+    for (int i = 0; i < cols.length; i++)
+      {
+        if (cols[i] != null && !cols[i].equals(resizeIt))
+          cols[i].setWidth(cols[i].getPreferredWidth() + average);
+      }
+    resizeIt.setWidth(resizeIt.getPreferredWidth());
+  }  
+  
+  /**
+   * Set the widths of all columns, taking they preferred widths into
+   * consideration. The excess space, if any, will be distrubuted between
+   * all columns. This method also handles special cases when one of the
+   * collumns is currently being resized.
+   * 
+   * @see TableColumn#setPreferredWidth(int)
+   */
+  public void doLayout()
+  {
+    TableColumn resizingColumn = null;
+    
+    int ncols = getColumnCount();
+    if (ncols < 1)
+      return;
+
+    int prefSum = 0;
+    int rCol = -1;
+
+    if (tableHeader != null)
+      resizingColumn = tableHeader.getResizingColumn();
+
+    for (int i = 0; i < ncols; ++i)
+      {
+        TableColumn col = columnModel.getColumn(i);
+        int p = col.getPreferredWidth();
+        prefSum += p;
+        if (resizingColumn == col)
+          rCol = i;
+      }
+
+    int spill = getWidth() - prefSum;
+
+    if (resizingColumn != null)
+      {
+        TableColumn col;
+        TableColumn [] cols;
+        
+        switch (getAutoResizeMode())
+          {
+          case AUTO_RESIZE_LAST_COLUMN:
+            col = columnModel.getColumn(ncols-1);
+            col.setWidth(col.getPreferredWidth() + spill);
+            break;
+            
+          case AUTO_RESIZE_NEXT_COLUMN:
+            col = columnModel.getColumn(ncols-1);
+            col.setWidth(col.getPreferredWidth() + spill);
+            break;
+
+          case AUTO_RESIZE_ALL_COLUMNS:
+            cols = new TableColumn[ncols];
+            for (int i = 0; i < ncols; ++i)
+              cols[i] = columnModel.getColumn(i);
+            distributeSpillResizing(cols, spill, resizingColumn);
+            break;
+
+          case AUTO_RESIZE_SUBSEQUENT_COLUMNS:
+            
+            // Subtract the width of the non-resized columns from the spill.
+            int w = 0;
+            int wp = 0;
+            TableColumn column;
+            for (int i = 0; i < rCol; i++)
+              {
+                column = columnModel.getColumn(i);
+                w += column.getWidth();
+                wp+= column.getPreferredWidth();
+              }
+
+            // The number of columns right from the column being resized.
+            int n = ncols-rCol-1;
+            if (n>0)
+              {
+                // If there are any columns on the right sied to resize.
+                spill = (getWidth()-w) - (prefSum-wp);
+                int average = spill / n;
+            
+                 // For all columns right from the column being resized:
+                for (int i = rCol+1; i < ncols; i++)
+                  {
+                    column = columnModel.getColumn(i);
+                    column.setWidth(column.getPreferredWidth() + average);
+                  }
+              }
+            resizingColumn.setWidth(resizingColumn.getPreferredWidth());
+            break;
+
+          case AUTO_RESIZE_OFF:
+          default:
+            int prefWidth = resizingColumn.getPreferredWidth();
+            resizingColumn.setWidth(prefWidth);
+          }
+      }
+    else
+      {
+        TableColumn [] cols = new TableColumn[ncols];
+        for (int i = 0; i < ncols; ++i)
+          cols[i] = columnModel.getColumn(i);
+        distributeSpill(cols, spill);
+      }
+    
+    if (editorComp!=null)
+      moveToCellBeingEdited(editorComp);
+    
+    int leftBoundary = getLeftResizingBoundary();
+    int width = getWidth() - leftBoundary;
+    repaint(leftBoundary, 0, width, getHeight());
+    if (tableHeader != null)
+      tableHeader.repaint(leftBoundary, 0, width, tableHeader.getHeight());
+  }
+  
+  /**
+   * Get the left boundary of the rectangle which changes during the column
+   * resizing.
+   */
+  int getLeftResizingBoundary()
+  {
+    if (tableHeader == null || getAutoResizeMode() == AUTO_RESIZE_ALL_COLUMNS)
+      return 0;
+    else
+      {
+        TableColumn resizingColumn = tableHeader.getResizingColumn();
+        if (resizingColumn == null)
+          return 0;
+
+        int rc = convertColumnIndexToView(resizingColumn.getModelIndex());
+        int p = 0;
+
+        for (int i = 0; i < rc; i++)
+          p += columnModel.getColumn(i).getWidth();
+        
+        return p;
+      }
+  }
+  
+  
+  /**
+   * @deprecated Replaced by <code>doLayout()</code>
+   */
+  public void sizeColumnsToFit(boolean lastColumnOnly)
+  {
+    doLayout();
+  }
+  
+  /**
+   * Obsolete since JDK 1.4. Please use <code>doLayout()</code>.
+   */
+  public void sizeColumnsToFit(int resizingColumn)
+  {
+    doLayout();
+  }
+
+  public String getUIClassID()
+  {
+    return "TableUI";
+  }
+
+  /**
+   * This method returns the table's UI delegate.
+   *
+   * @return The table's UI delegate.
+   */
+  public TableUI getUI()
+  {
+    return (TableUI) ui;
+  }
+
+  /**
+   * This method sets the table's UI delegate.
+   *
+   * @param ui The table's UI delegate.
+   */
+  public void setUI(TableUI ui)
+  {
+    super.setUI(ui);
+    // The editors and renderers must be recreated because they constructors
+    // may use the look and feel properties.
+    createDefaultEditors();
+    createDefaultRenderers();
+  }
+
+  public void updateUI()
+  {
+    setUI((TableUI) UIManager.getUI(this));
+  }
+  
+  /**
+   * Get the class (datatype) of the column. The cells are rendered and edited
+   * differently, depending from they data type.
+   * 
+   * @param column the column (not the model index).
+   * 
+   * @return the class, defining data type of that column (String.class for
+   * String, Boolean.class for boolean and so on).
+   */
+  public Class getColumnClass(int column)
+  {
+    return getModel().getColumnClass(convertColumnIndexToModel(column));
+  }
+  
+  /**
+   * Get the name of the column. If the column has the column identifier set,
+   * the return value is the result of the .toString() method call on that
+   * identifier. If the identifier is not explicitly set, the returned value
+   * is calculated by 
+   * {@link javax.swing.table.AbstractTableModel#getColumnName(int)}.
+   * 
+   * @param column the column
+   * 
+   * @return the name of that column.
+   */
+  public String getColumnName(int column)
+  {
+    int modelColumn = columnModel.getColumn(column).getModelIndex();
+    return dataModel.getColumnName(modelColumn);
+  }
+  
+  /**
+   * Get the column, currently being edited
+   * 
+   * @return the column, currently being edited.
+   */
+  public int getEditingColumn()
+  {
+    return editingColumn;
+  }
+  
+  /**
+   * Set the column, currently being edited
+   * 
+   * @param column the column, currently being edited.
+   */
+  public void setEditingColumn(int column)
+  {
+    editingColumn = column;
+  }
+  
+  /**
+   * Get the row currently being edited.
+   * 
+   * @return the row, currently being edited.
+   */
+  public int getEditingRow()
+  {
+    return editingRow;
+  }
+  
+  /**
+   * Set the row currently being edited.
+   * 
+   * @param row the row, that will be edited
+   */
+  public void setEditingRow(int row)
+  {
+    editingRow = row;
+  }
+  
+  /**
+   * Get the editor component that is currently editing one of the cells
+   * 
+   * @return the editor component or null, if none of the cells is being
+   * edited.
+   */
+  public Component getEditorComponent()
+  {
+    return editorComp;
+  }
+  
+  /**
+   * Check if one of the table cells is currently being edited.
+   * 
+   * @return true if there is a cell being edited.
+   */
+  public boolean isEditing()
+  {
+    return editorComp != null;
+  }
+  
+  /**
+   * Set the default editor for the given column class (column data type).
+   * By default, String is handled by text field and Boolean is handled by
+   * the check box.
+   *  
+   * @param columnClass the column data type
+   * @param editor the editor that will edit this data type
+   * 
+   * @see TableModel#getColumnClass(int)
+   */
+  public void setDefaultEditor(Class columnClass, TableCellEditor editor)
+  {
+    if (editor != null)
+      defaultEditorsByColumnClass.put(columnClass, editor);
+    else
+      defaultEditorsByColumnClass.remove(columnClass);
+  }
+  
+  public void addColumnSelectionInterval(int index0, int index1)
+  {
+    if ((index0 < 0 || index0 > (getColumnCount()-1)
+         || index1 < 0 || index1 > (getColumnCount()-1)))
+      throw new IllegalArgumentException("Column index out of range.");
+    
+    getColumnModel().getSelectionModel().addSelectionInterval(index0, index1);
+  }
+  
+  public void addRowSelectionInterval(int index0, int index1)
+  {            
+    if ((index0 < 0 || index0 > (getRowCount()-1)
+         || index1 < 0 || index1 > (getRowCount()-1)))
+      throw new IllegalArgumentException("Row index out of range.");
+      	
+    getSelectionModel().addSelectionInterval(index0, index1);
+  }
+  
+  public void setColumnSelectionInterval(int index0, int index1)
+  {
+    if ((index0 < 0 || index0 > (getColumnCount()-1)
+         || index1 < 0 || index1 > (getColumnCount()-1)))
+      throw new IllegalArgumentException("Column index out of range.");
+
+    getColumnModel().getSelectionModel().setSelectionInterval(index0, index1);
+  }
+  
+  public void setRowSelectionInterval(int index0, int index1)
+  {    
+    if ((index0 < 0 || index0 > (getRowCount()-1)
+         || index1 < 0 || index1 > (getRowCount()-1)))
+      throw new IllegalArgumentException("Row index out of range.");
+
+    getSelectionModel().setSelectionInterval(index0, index1);
+  }
+  
+  public void removeColumnSelectionInterval(int index0, int index1)  
+  {
+    if ((index0 < 0 || index0 > (getColumnCount()-1)
+         || index1 < 0 || index1 > (getColumnCount()-1)))
+      throw new IllegalArgumentException("Column index out of range.");
+
+    getColumnModel().getSelectionModel().removeSelectionInterval(index0, index1);
+  }
+  
+  public void removeRowSelectionInterval(int index0, int index1)
+  {
+    if ((index0 < 0 || index0 > (getRowCount()-1)
+         || index1 < 0 || index1 > (getRowCount()-1)))
+      throw new IllegalArgumentException("Row index out of range.");
+
+    getSelectionModel().removeSelectionInterval(index0, index1);
+  }
+  
+  /**
+   * Checks if the given column is selected.
+   * 
+   * @param column the column
+   * 
+   * @return true if the column is selected (as reported by the selection
+   * model, associated with the column model), false otherwise.
+   */
+  public boolean isColumnSelected(int column)
+  {
+    return getColumnModel().getSelectionModel().isSelectedIndex(column);
+  }
+  
+  /**
+   * Checks if the given row is selected.
+   * 
+   * @param row the row
+   * 
+   * @return true if the row is selected (as reported by the selection model),
+   * false otherwise.
+   */
+  public boolean isRowSelected(int row)
+  {
+    return getSelectionModel().isSelectedIndex(row);
+  }
+  
+  /**
+   * Checks if the given cell is selected. The cell is selected if both
+   * the cell row and the cell column are selected.
+   * 
+   * @param row the cell row
+   * @param column the cell column
+   * 
+   * @return true if the cell is selected, false otherwise
+   */
+  public boolean isCellSelected(int row, int column)
+  {
+    return isRowSelected(row) && isColumnSelected(column);
+  }
+  
+  /**
+   * Select all table.
+   */
+  public void selectAll()
+  {
+    // The table is empty - nothing to do!
+    if (getRowCount() == 0 || getColumnCount() == 0)
+      return;
+    
+    // rowLead and colLead store the current lead selection indices
+    int rowLead = selectionModel.getLeadSelectionIndex();
+    int colLead = getColumnModel().getSelectionModel().getLeadSelectionIndex();
+    // the following calls to setSelectionInterval change the lead selection
+    // indices
+    setColumnSelectionInterval(0, getColumnCount() - 1);
+    setRowSelectionInterval(0, getRowCount() - 1);
+    // the following addSelectionInterval calls restore the lead selection
+    // indices to their previous values
+    addColumnSelectionInterval(colLead,colLead);
+    addRowSelectionInterval(rowLead, rowLead);
+  }
+  
+  /**
+   * Get the cell value at the given position.
+   * 
+   * @param row the row to get the value
+   * @param column the actual column number (not the model index) 
+   * to get the value.
+   * 
+   * @return the cell value, as returned by model.
+   */
+  public Object getValueAt(int row, int column)
+  {
+    return dataModel.getValueAt(row, convertColumnIndexToModel(column));
+  }
+  
+  /**
+   * Set value for the cell at the given position. The modified cell is
+   * repainted.
+   * 
+   * @param value the value to set
+   * @param row the row of the cell being modified
+   * @param column the column of the cell being modified
+   */
+  public void setValueAt(Object value, int row, int column)
+  {
+    dataModel.setValueAt(value, row, convertColumnIndexToModel(column));
+    
+    repaint(getCellRect(row, column, true));
+  }
+  
+  /**
+   * Get table column with the given identified.
+   * 
+   * @param identifier the column identifier
+   * 
+   * @return the table column with this identifier
+   * 
+   * @throws IllegalArgumentException if <code>identifier</code> is 
+   *         <code>null</code> or there is no column with that identifier.
+   * 
+   * @see TableColumn#setIdentifier(Object)
+   */
+  public TableColumn getColumn(Object identifier)
+  {
+    return columnModel.getColumn(columnModel.getColumnIndex(identifier));
+  }
+
+  /**
+   * Returns <code>true</code> if the specified cell is editable, and
+   * <code>false</code> otherwise.
+   *
+   * @param row  the row index.
+   * @param column  the column index.
+   *
+   * @return true if the cell is editable, false otherwise.
+   */
+  public boolean isCellEditable(int row, int column)
+  {
+    return dataModel.isCellEditable(row, convertColumnIndexToModel(column));
+  }
+
+  /**
+   * Clears any existing columns from the <code>JTable</code>'s
+   * {@link TableColumnModel} and creates new columns to match the values in
+   * the data ({@link TableModel}) used by the table.
+   *
+   * @see #setAutoCreateColumnsFromModel(boolean)
+   */
+  public void createDefaultColumnsFromModel()
+  {
+    assert columnModel != null : "The columnModel must not be null.";
+
+    // remove existing columns
+    int columnIndex = columnModel.getColumnCount() - 1;
+    while (columnIndex >= 0)
+    {
+      columnModel.removeColumn(columnModel.getColumn(columnIndex));
+      columnIndex--;
+    }
+  
+    // add new columns to match the TableModel
+    int columnCount = dataModel.getColumnCount();
+    for (int c = 0; c < columnCount; c++)
+    {
+      TableColumn column = new TableColumn(c);
+      column.setIdentifier(dataModel.getColumnName(c));
+      column.setHeaderValue(dataModel.getColumnName(c));
+      columnModel.addColumn(column);
+      column.addPropertyChangeListener(tableColumnPropertyChangeHandler);
+    }
+  }
+
+  public void changeSelection (int rowIndex, int columnIndex, boolean toggle, boolean extend)
+  {
+    if (toggle && extend)
+      {
+        // Leave the selection state as is, but move the anchor
+        //   index to the specified location
+        selectionModel.setAnchorSelectionIndex(rowIndex);
+        getColumnModel().getSelectionModel().setAnchorSelectionIndex(columnIndex);
+      }
+    else if (toggle)
+      {
+        // Toggle the state of the specified cell
+        if (isCellSelected(rowIndex,columnIndex))
+          {
+            selectionModel.removeSelectionInterval(rowIndex,rowIndex);
+            getColumnModel().getSelectionModel().removeSelectionInterval(columnIndex,columnIndex);
+          }
+        else
+          {
+            selectionModel.addSelectionInterval(rowIndex,rowIndex);
+            getColumnModel().getSelectionModel().addSelectionInterval(columnIndex,columnIndex);
+          }
+      }
+    else if (extend)
+      {
+        // Extend the previous selection from the anchor to the 
+        // specified cell, clearing all other selections
+        selectionModel.setLeadSelectionIndex(rowIndex);
+        getColumnModel().getSelectionModel().setLeadSelectionIndex(columnIndex);
+      }
+    else
+      {
+        // Clear the previous selection and ensure the new cell
+        // is selected
+         selectionModel.clearSelection();
+        selectionModel.setSelectionInterval(rowIndex,rowIndex);
+        getColumnModel().getSelectionModel().clearSelection();
+        getColumnModel().getSelectionModel().setSelectionInterval(columnIndex, columnIndex);
+        
+        
+      }
+  }
+
+  /**
+   * Programmatically starts editing the specified cell.
+   * 
+   * @param row the row of the cell to edit.
+   * @param column the column of the cell to edit.
+   */
+  public boolean editCellAt(int row, int column)
+  {
+    // Complete the previous editing session, if still active.
+    if (isEditing())
+      editingStopped(new ChangeEvent("editingStopped"));
+
+    TableCellEditor editor = getCellEditor(row, column);
+    
+    // The boolean values are inverted by the single click without the
+    // real editing session.
+    if (editor == booleanInvertingEditor && isCellEditable(row, column))
+      {
+        if (Boolean.TRUE.equals(getValueAt(row, column)))
+          setValueAt(Boolean.FALSE, row, column);
+        else
+          setValueAt(Boolean.TRUE, row, column);
+        return false;
+      }
+    else
+      {
+        editingRow = row;
+        editingColumn = column;
+
+        setCellEditor(editor);
+        editorComp = prepareEditor(cellEditor, row, column);
+
+        // Remove the previous editor components, if present. Only one
+        // editor component at time is allowed in the table.
+        removeAll();
+        add(editorComp);
+        moveToCellBeingEdited(editorComp);
+        scrollRectToVisible(editorComp.getBounds());
+        editorComp.requestFocusInWindow();
+        
+        // Deliver the should select event.
+        return editor.shouldSelectCell(null);        
+      }
+  }
+
+  /**
+   * Move the given component under the cell being edited. 
+   * The table must be in the editing mode.
+   * 
+   * @param component the component to move.
+   */
+  private void moveToCellBeingEdited(Component component)
+  {
+     Rectangle r = getCellRect(editingRow, editingColumn, true);
+     // Adjust bounding box of the editing component, so that it lies
+     // 'above' the grid on all edges, not only right and bottom.
+     // The table grid is painted only at the right and bottom edge of a cell.
+     r.x -= 1;
+     r.y -= 1;
+     r.width += 1;
+     r.height += 1;
+     component.setBounds(r);
+  }
+
+  /**
+   * Programmatically starts editing the specified cell.
+   *
+   * @param row the row of the cell to edit.
+   * @param column the column of the cell to edit.
+   */
+  public boolean editCellAt (int row, int column, EventObject e)
+  {
+    return editCellAt(row, column);
+  }
+
+  /**
+   * Discards the editor object.
+   */
+  public void removeEditor()
+  {
+    editingStopped(new ChangeEvent(this));
+  }
+
+  /**
+   * Prepares the editor by querying for the value and selection state of the
+   * cell at (row, column).
+   *
+   * @param editor the TableCellEditor to set up
+   * @param row the row of the cell to edit
+   * @param column the column of the cell to edit
+   * @return the Component being edited
+   */
+  public Component prepareEditor (TableCellEditor editor, int row, int column)
+  {
+    return editor.getTableCellEditorComponent
+      (this, getValueAt(row, column), isCellSelected(row, column), row, column);
+  }
+
+  /**
+   * This revalidates the <code>JTable</code> and queues a repaint.
+   */
+  protected void resizeAndRepaint()
+  {
+    revalidate();
+    repaint();
+  }
+
+  /**
+   * Sets whether cell editors of this table should receive keyboard focus
+   * when the editor is activated by a keystroke. The default setting is
+   * <code>false</code> which means that the table should keep the keyboard
+   * focus until the cell is selected by a mouse click.
+   *
+   * @param value the value to set
+   *
+   * @since 1.4
+   */
+  public void setSurrendersFocusOnKeystroke(boolean value)
+  {
+    // TODO: Implement functionality of this property (in UI impl).
+    surrendersFocusOnKeystroke = value;
+  }
+  
+  /**
+   * Returns whether cell editors of this table should receive keyboard focus
+   * when the editor is activated by a keystroke. The default setting is
+   * <code>false</code> which means that the table should keep the keyboard
+   * focus until the cell is selected by a mouse click.
+   *
+   * @return whether cell editors of this table should receive keyboard focus
+   *         when the editor is activated by a keystroke
+   *
+   * @since 1.4
+   */
+  public boolean getSurrendersFocusOnKeystroke()
+  {
+    // TODO: Implement functionality of this property (in UI impl).
+    return surrendersFocusOnKeystroke;
+  }
+
+  /**
+   * Helper method for
+   * {@link LookAndFeel#installProperty(JComponent, String, Object)}.
+   * 
+   * @param propertyName the name of the property
+   * @param value the value of the property
+   *
+   * @throws IllegalArgumentException if the specified property cannot be set
+   *         by this method
+   * @throws ClassCastException if the property value does not match the
+   *         property type
+   * @throws NullPointerException if <code>c</code> or
+   *         <code>propertyValue</code> is <code>null</code>
+   */
+  void setUIProperty(String propertyName, Object value)
+  {
+    if (propertyName.equals("rowHeight"))
+      {
+        if (! clientRowHeightSet)
+          {
+            setRowHeight(((Integer) value).intValue());
+            clientRowHeightSet = false;
+          }
+      }
+    else
+      {
+        super.setUIProperty(propertyName, value);
+      }
+  }
+}

Added: llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JTextArea.java
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JTextArea.java?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JTextArea.java (added)
+++ llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JTextArea.java Thu Nov  8 16:56:19 2007
@@ -0,0 +1,607 @@
+/* JTextArea.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;
+
+import java.awt.Dimension;
+import java.awt.FontMetrics;
+import java.awt.Rectangle;
+
+import javax.accessibility.AccessibleContext;
+import javax.accessibility.AccessibleStateSet;
+import javax.swing.text.BadLocationException;
+import javax.swing.text.Document;
+import javax.swing.text.Element;
+import javax.swing.text.JTextComponent;
+import javax.swing.text.PlainDocument;
+import javax.swing.text.View;
+
+/**
+ * The <code>JTextArea</code> component provides a multi-line area for displaying
+ * and editing plain text.  The component is designed to act as a lightweight
+ * replacement for the heavyweight <code>java.awt.TextArea</code> component,
+ * which provides similar functionality using native widgets.
+ * <p>
+ *
+ * This component has additional functionality to the AWT class.  It follows
+ * the same design pattern as seen in other text components, such as
+ * <code>JTextField</code>, <code>JTextPane</code> and <code>JEditorPane</code>,
+ * and embodied in <code>JTextComponent</code>.  These classes separate the text
+ * (the model) from its appearance within the onscreen component (the view).  The
+ * text is held within a <code>javax.swing.text.Document</code> object, which can
+ * also maintain relevant style information where necessary.  As a result, it is the
+ * document that should be monitored for textual changes, via
+ * <code>DocumentEvent</code>s delivered to registered
+ * <code>DocumentListener</code>s, rather than this component.
+ * <p>
+ *
+ * Unlike <code>java.awt.TextArea</code>, <code>JTextArea</code> does not
+ * handle scrolling.  Instead, this functionality is delegated to a
+ * <code>JScrollPane</code>, which can contain the text area and handle
+ * scrolling when required.  Likewise, the word wrapping functionality
+ * of the AWT component is converted to a property of this component
+ * and the <code>rows</code> and <code>columns</code> properties
+ * are used in calculating the preferred size of the scroll pane's
+ * view port.
+ *
+ * @author Michael Koch  (konqueror at gmx.de)
+ * @author Andrew John Hughes  (gnu_andrew at member.fsf.org)
+ * @see java.awt.TextArea
+ * @see javax.swing.text.JTextComponent
+ * @see javax.swing.JTextField
+ * @see javax.swing.JTextPane
+ * @see javax.swing.JEditorPane
+ * @see javax.swing.text.Document
+ * @see javax.swing.event.DocumentEvent
+ * @see javax.swing.event.DocumentListener
+ */
+
+public class JTextArea extends JTextComponent
+{
+  /**
+   * Provides accessibility support for <code>JTextArea</code>.
+   *
+   * @author Roman Kennke (kennke at aicas.com)
+   */
+  protected class AccessibleJTextArea extends AccessibleJTextComponent
+  {
+
+    /**
+     * Creates a new <code>AccessibleJTextArea</code> object.
+     */
+    protected AccessibleJTextArea()
+    {
+      super();
+    }
+
+    /**
+     * Returns the accessible state of this <code>AccessibleJTextArea</code>.
+     *
+     * @return  the accessible state of this <code>AccessibleJTextArea</code>
+     */
+    public AccessibleStateSet getAccessibleStateSet()
+    {
+      AccessibleStateSet state = super.getAccessibleStateSet();
+      // TODO: Figure out what state must be added here to the super's state.
+      return state;
+    }
+  }
+
+  /**
+   * Compatible with Sun's JDK
+   */
+  private static final long serialVersionUID = -6141680179310439825L;
+  
+  /**
+   * The number of rows used by the component.
+   */
+  private int rows;
+
+  /**
+   * The number of columns used by the component.
+   */
+  private int columns;
+
+  /**
+   * Whether line wrapping is enabled or not.
+   */
+  private boolean lineWrap;
+
+  /**
+   * The number of characters equal to a tab within the text.
+   */
+  private int tabSize = 8;
+
+  private boolean wrapStyleWord;
+
+  /**
+   * Creates a new <code>JTextArea</code> object.
+   */
+  public JTextArea()
+  {
+    this(null, null, 0, 0);
+  }
+
+  /**
+   * Creates a new <code>JTextArea</code> object.
+   *
+   * @param text the initial text
+   */
+  public JTextArea(String text)
+  {
+    this(null, text, 0, 0);
+  }
+
+  /**
+   * Creates a new <code>JTextArea</code> object.
+   *
+   * @param rows the number of rows
+   * @param columns the number of cols
+   *
+   * @exception IllegalArgumentException if rows or columns are negative
+   */
+  public JTextArea(int rows, int columns)
+  {
+    this(null, null, rows, columns);
+  }
+
+  /**
+   * Creates a new <code>JTextArea</code> object.
+   *
+   * @param text the initial text
+   * @param rows the number of rows
+   * @param columns the number of cols
+   *
+   * @exception IllegalArgumentException if rows or columns are negative
+   */
+  public JTextArea(String text, int rows, int columns)
+  {
+    this(null, text, rows, columns);
+  }
+
+  /**
+   * Creates a new <code>JTextArea</code> object.
+   *
+   * @param doc the document model to use
+   */
+  public JTextArea(Document doc)
+  {
+    this(doc, null, 0, 0);
+  }
+
+  /**
+   * Creates a new <code>JTextArea</code> object.
+   *
+   * @param doc the document model to use
+   * @param text the initial text
+   * @param rows the number of rows
+   * @param columns the number of cols
+   *
+   * @exception IllegalArgumentException if rows or columns are negative
+   */
+  public JTextArea(Document doc, String text, int rows, int columns)
+  {
+    setDocument(doc == null ? createDefaultModel() : doc);
+    // Only explicitly setText() when there is actual text since
+    // setText() might be overridden and not expected to be called
+    // from the constructor (as in JEdit).
+    if (text != null)
+      setText(text);
+    setRows(rows);
+    setColumns(columns);
+  }
+
+  /**
+   * Appends the supplied text to the current contents
+   * of the document model.
+   *
+   * @param toAppend the text to append
+   */
+  public void append(String toAppend)
+  {
+      try
+	  {
+	      getDocument().insertString(getText().length(), toAppend, null);
+	  }
+      catch (BadLocationException exception)
+	  {
+	      /* This shouldn't happen in theory -- but, if it does...  */
+	      throw new RuntimeException("Unexpected exception occurred.", exception);
+	  }
+      if (toAppend != null && toAppend.length() > 0)
+        revalidate();
+  }
+
+  /**
+   * Creates the default document model.
+   *
+   * @return a new default model
+   */
+  protected Document createDefaultModel()
+  {
+    return new PlainDocument();
+  }
+
+  /**
+   * Returns true if the width of this component should be forced
+   * to match the width of a surrounding view port.  When line wrapping
+   * is turned on, this method returns true.
+   *
+   * @return true if lines are wrapped.
+   */
+  public boolean getScrollableTracksViewportWidth()
+  {
+    return lineWrap ? true : super.getScrollableTracksViewportWidth();
+  }
+
+  /**
+   * Returns the increment that is needed to expose exactly one new line
+   * of text. This is implemented here to return the values of
+   * {@link #getRowHeight} and {@link #getColumnWidth}, depending on
+   * the value of the argument <code>direction</code>.
+   *
+   * @param visibleRect the view area that is visible in the viewport
+   * @param orientation either {@link SwingConstants#VERTICAL} or
+   *     {@link SwingConstants#HORIZONTAL}
+   * @param direction less than zero for up/left scrolling, greater
+   *     than zero for down/right scrolling
+   *
+   * @return the increment that is needed to expose exactly one new row
+   *     or column of text
+   *
+   * @throws IllegalArgumentException if <code>orientation</code> is invalid
+   */
+  public int getScrollableUnitIncrement(Rectangle visibleRect, int orientation,
+                                        int direction)
+  {
+    if (orientation == SwingConstants.VERTICAL)
+      return getRowHeight();
+    else if (orientation == SwingConstants.HORIZONTAL)
+      return getColumnWidth();
+    else
+      throw new IllegalArgumentException("orientation must be either "
+                                     + "javax.swing.SwingConstants.VERTICAL "
+                                     + "or "
+                                     + "javax.swing.SwingConstants.HORIZONTAL"
+                                     );
+  }
+
+  /**
+   * Returns the preferred size of that text component in the case
+   * it is embedded within a JScrollPane. This uses the column and
+   * row settings if they are explicitly set, or fall back to
+   * the superclass's behaviour.
+   *
+   * @return the preferred size of that text component in the case
+   *     it is embedded within a JScrollPane
+   */
+  public Dimension getPreferredScrollableViewportSize()
+  {
+    if ((rows > 0) && (columns > 0))
+      return new Dimension(columns * getColumnWidth(), rows * getRowHeight());
+    else
+      return super.getPreferredScrollableViewportSize();
+  }
+
+  /**
+   * Returns the UI class ID string.
+   *
+   * @return the string "TextAreaUI"
+   */
+  public String getUIClassID()
+  {
+    return "TextAreaUI";
+  }
+
+  /**
+   * Returns the current number of columns.
+   *
+   * @return number of columns
+   */
+  public int getColumns()
+  {
+    return columns;
+  }
+  
+  /**
+   * Sets the number of rows.
+   *
+   * @param columns number of columns
+   *
+   * @exception IllegalArgumentException if columns is negative
+   */
+  public void setColumns(int columns)
+  {
+    if (columns < 0)
+      throw new IllegalArgumentException();
+    
+    if (columns != this.columns)
+      {
+        this.columns = columns;
+        revalidate();
+      }
+  }
+
+  /**
+   * Returns the current number of rows.
+   *
+   * @return number of rows
+   */
+  public int getRows()
+  {
+    return rows;
+  }
+
+  /**
+   * Sets the number of rows.
+   *
+   * @param rows number of rows
+   *
+   * @exception IllegalArgumentException if rows is negative
+   */
+  public void setRows(int rows)
+  {
+    if (rows < 0)
+      throw new IllegalArgumentException();
+   
+    if (rows != this.rows)
+      {
+        this.rows = rows;
+        revalidate();
+      }
+  }
+
+  /**
+   * Checks whether line wrapping is enabled.
+   *
+   * @return <code>true</code> if line wrapping is enabled,
+   * <code>false</code> otherwise
+   */
+  public boolean getLineWrap()
+  {
+    return lineWrap;
+  }
+
+  /**
+   * Enables/disables line wrapping.
+   *
+   * @param flag <code>true</code> to enable line wrapping,
+   * <code>false</code> otherwise
+   */
+  public void setLineWrap(boolean flag)
+  {
+    if (lineWrap == flag)
+      return;
+
+    boolean oldValue = lineWrap;
+    lineWrap = flag;
+    firePropertyChange("lineWrap", oldValue, lineWrap);
+  }
+
+  /**
+   * Checks whether word style wrapping is enabled.
+   *
+   * @return <code>true</code> if word style wrapping is enabled,
+   * <code>false</code> otherwise
+   */
+  public boolean getWrapStyleWord()
+  {
+    return wrapStyleWord;
+  }
+  
+  /**
+   * Enables/Disables word style wrapping.
+   *
+   * @param flag <code>true</code> to enable word style wrapping,
+   * <code>false</code> otherwise
+   */
+  public void setWrapStyleWord(boolean flag)
+  {
+    if (wrapStyleWord == flag)
+      return;
+    
+    boolean oldValue = wrapStyleWord;
+    wrapStyleWord = flag;
+    firePropertyChange("wrapStyleWord", oldValue, wrapStyleWord);
+  }
+  
+  /**
+   * Returns the number of characters used for a tab.
+   * This defaults to 8.
+   *
+   * @return the current number of spaces used for a tab.
+   */
+  public int getTabSize()
+  {
+    return tabSize;
+  }
+
+  /**
+   * Sets the number of characters used for a tab to the
+   * supplied value.  If a change to the tab size property
+   * occurs (i.e. newSize != tabSize), a property change event
+   * is fired.
+   * 
+   * @param newSize The new number of characters to use for a tab.
+   */
+  public void setTabSize(int newSize)
+  {
+    if (tabSize == newSize)
+      return;
+    
+    int oldValue = tabSize;
+    tabSize = newSize;
+    firePropertyChange("tabSize", oldValue, tabSize);
+  }
+
+  protected int getColumnWidth()
+  {
+    FontMetrics metrics = getToolkit().getFontMetrics(getFont());
+    return metrics.charWidth('m');
+  }
+
+  public int getLineCount()
+  {
+    return getDocument().getDefaultRootElement().getElementCount();
+  }
+
+  public int getLineStartOffset(int line)
+     throws BadLocationException
+  {
+    int lineCount = getLineCount();
+    
+    if (line < 0 || line > lineCount)
+      throw new BadLocationException("Non-existing line number", line);
+
+    Element lineElem = getDocument().getDefaultRootElement().getElement(line);
+    return lineElem.getStartOffset();
+  }
+
+  public int getLineEndOffset(int line)
+     throws BadLocationException
+  {
+    int lineCount = getLineCount();
+    
+    if (line < 0 || line > lineCount)
+      throw new BadLocationException("Non-existing line number", line);
+
+    Element lineElem = getDocument().getDefaultRootElement().getElement(line);
+    return lineElem.getEndOffset();
+  }
+
+  public int getLineOfOffset(int offset)
+    throws BadLocationException
+  {
+    Document doc = getDocument();
+
+    if (offset < doc.getStartPosition().getOffset()
+	|| offset >= doc.getEndPosition().getOffset())
+      throw new BadLocationException("offset outside of document", offset);
+
+    return doc.getDefaultRootElement().getElementIndex(offset);
+  }
+
+  protected int getRowHeight()
+  {
+    FontMetrics metrics = getToolkit().getFontMetrics(getFont());
+    return metrics.getHeight();
+  }
+
+  /**
+   * Inserts the supplied text at the specified position.  Nothing
+   * happens in the case that the model or the supplied string is null
+   * or of zero length.
+   *
+   * @param string The string of text to insert.
+   * @param position The position at which to insert the supplied text.
+   * @throws IllegalArgumentException if the position is < 0 or greater
+   * than the length of the current text.
+   */
+  public void insert(String string, int position)
+  {
+    // Retrieve the document model.
+    Document doc = getDocument();
+      
+    // Check the model and string for validity.
+    if (doc == null
+	|| string == null
+	|| string.length() == 0)
+      return;
+
+    // Insert the text into the model.
+    try
+      {
+	doc.insertString(position, string, null);
+      }
+    catch (BadLocationException e)
+      {
+	throw new IllegalArgumentException("The supplied position, "
+					   + position + ", was invalid.");
+      }
+  }
+
+  public void replaceRange(String text, int start, int end)
+  {
+    Document doc = getDocument();
+    
+    if (start > end
+	|| start < doc.getStartPosition().getOffset()
+	|| end >= doc.getEndPosition().getOffset())
+      throw new IllegalArgumentException();
+
+    try
+      {
+        doc.remove(start, end - start);
+        doc.insertString(start, text, null);
+      }
+    catch (BadLocationException e)
+      {
+	// This cannot happen as we check offset above.
+      }
+  }
+
+  /**
+   * Returns the preferred size for the JTextArea. This is the maximum of
+   * the size that is needed to display the content and the requested size
+   * as per {@link #getColumns} and {@link #getRows}.
+   *
+   * @return the preferred size of the JTextArea
+   */
+  public Dimension getPreferredSize()
+  {
+    int reqWidth = getColumns() * getColumnWidth();
+    int reqHeight = getRows() * getRowHeight();
+    View view = getUI().getRootView(this);
+    int neededWidth = (int) view.getPreferredSpan(View.HORIZONTAL);
+    int neededHeight = (int) view.getPreferredSpan(View.VERTICAL);
+    return new Dimension(Math.max(reqWidth, neededWidth),
+                          Math.max(reqHeight, neededHeight));
+  }
+
+  /**
+   * Returns the accessible context associated with the <code>JTextArea</code>.
+   *
+   * @return the accessible context associated with the <code>JTextArea</code>
+   */
+  public AccessibleContext getAccessibleContext()
+  {
+    if (accessibleContext == null)
+      accessibleContext = new AccessibleJTextArea();
+    return accessibleContext;
+  }
+}

Added: llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JTextField.java
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JTextField.java?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JTextField.java (added)
+++ llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JTextField.java Thu Nov  8 16:56:19 2007
@@ -0,0 +1,569 @@
+/* JTextField.java --
+   Copyright (C) 2002, 2004, 2005, 2006  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;
+
+import java.awt.Dimension;
+import java.awt.Font;
+import java.awt.FontMetrics;
+import java.awt.Insets;
+import java.awt.Rectangle;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.beans.PropertyChangeEvent;
+import java.beans.PropertyChangeListener;
+
+import javax.accessibility.AccessibleContext;
+import javax.accessibility.AccessibleStateSet;
+import javax.swing.text.Document;
+import javax.swing.text.JTextComponent;
+import javax.swing.text.PlainDocument;
+import javax.swing.text.TextAction;
+
+public class JTextField extends JTextComponent
+  implements SwingConstants
+{
+  /**
+   * AccessibleJTextField
+   */
+  protected class AccessibleJTextField extends AccessibleJTextComponent
+  {
+    private static final long serialVersionUID = 8255147276740453036L;
+
+    /**
+     * Constructor AccessibleJTextField
+     */
+    protected AccessibleJTextField()
+    {
+      super();
+    }
+
+    /**
+     * Returns the accessible state of this <code>AccessibleJTextField</code>.
+     *
+     * @return the accessible state of this <code>AccessibleJTextField</code>
+     */
+    public AccessibleStateSet getAccessibleStateSet()
+    {
+      AccessibleStateSet state = super.getAccessibleStateSet();
+      // TODO: Figure out what state must be added here to the super's state.
+      return state;
+    }
+  }
+
+  private static final long serialVersionUID = 353853209832607592L;
+
+  private static final Action[] actions;
+
+  /**
+   * Name of the action that gets sent when the content of the text field
+   * gets accepted.
+   */
+  public static final String notifyAction = "notify-field-accept";
+  
+  static
+    {
+      actions = new Action[1];
+      actions[0] = new TextAction(notifyAction)
+      {
+        public void actionPerformed(ActionEvent event)
+        {
+          JTextField textField = (JTextField) event.getSource();
+          textField.fireActionPerformed();
+        }
+      };
+    }
+  
+  private int columns;
+  private int align;
+  
+  /** @since 1.3 */
+  private Action action;
+
+  /** @since 1.3 */
+  private String actionCommand;
+  
+  private PropertyChangeListener actionPropertyChangeListener;
+
+  /**
+   * The horizontal visibility of the textfield.
+   */
+  private BoundedRangeModel horizontalVisibility;
+
+  /**
+   * Creates a new instance of <code>JTextField</code>.
+   */
+  public JTextField()
+  {
+    this(null, null, 0);
+  }
+
+  /**
+   * Creates a new instance of <code>JTextField</code>.
+   *
+   * @param text the initial text
+   */
+  public JTextField(String text)
+  {
+    this(null, text, 0);
+  }
+  
+  /**
+   * Creates a new instance of <code>JTextField</code>.
+   *
+   * @param columns the number of columns
+   *
+   * @exception IllegalArgumentException if columns %lt; 0
+   */
+  public JTextField(int columns)
+  {
+    this(null, null, columns);
+  }
+
+  /**
+   * Creates a new instance of <code>JTextField</code>.
+   *
+   * @param text the initial text
+   * @param columns the number of columns
+   *
+   * @exception IllegalArgumentException if columns %lt; 0
+   */
+  public JTextField(String text, int columns)
+  {
+    this(null, text, columns);
+  }
+
+  /**
+   * Creates a new instance of <code>JTextField</code>.
+   *
+   * @param doc the document to use
+   * @param text the initial text
+   * @param columns the number of columns
+   *
+   * @exception IllegalArgumentException if columns %lt; 0
+   */
+  public JTextField(Document doc, String text, int columns)
+  {
+    if (columns < 0)
+      throw new IllegalArgumentException();
+
+    this.columns = columns;
+
+    // Initialize the horizontal visibility model.
+    horizontalVisibility = new DefaultBoundedRangeModel();
+
+    setDocument(doc == null ? createDefaultModel() : doc);
+
+    if (text != null)
+      setText(text);
+
+    // default value for alignment
+    align = LEADING;
+  }
+
+  /**
+   * Creates the default model for this text field.
+   * This implementation returns an instance of <code>PlainDocument</code>.
+   *
+   * @return a new instance of the default model
+   */
+  protected Document createDefaultModel()
+  {
+    return new PlainDocument();
+  }
+
+  /**
+   * Sets the document to be used for this JTextField.
+   *
+   * This sets the document property <code>filterNewlines</code> to
+   * <code>true</code> and then calls the super behaviour to setup a view and
+   * revalidate the text field.
+   *
+   * @param doc the document to set
+   */
+  public void setDocument(Document doc)
+  {
+    doc.putProperty("filterNewlines", Boolean.TRUE);
+    super.setDocument(doc);
+  }
+
+  /**
+   * Returns the class ID for the UI.
+   *
+   * @return "TextFieldUI";
+   */
+  public String getUIClassID()
+  {
+    return "TextFieldUI";
+  }
+
+  /**
+   * Adds a new listener object to this text field.
+   *
+   * @param listener the listener to add
+   */
+  public void addActionListener(ActionListener listener)
+  {
+    listenerList.add(ActionListener.class, listener);
+  }
+
+  /**
+   * Removes a listener object from this text field.
+   *
+   * @param listener the listener to remove
+   */
+  public void removeActionListener(ActionListener listener)
+  {
+    listenerList.remove(ActionListener.class, listener);
+  }
+
+  /**
+   * Returns all registered <code>ActionListener</code> objects.
+   *
+   * @return an array of listeners
+   *
+   * @since 1.4
+   */
+  public ActionListener[] getActionListeners()
+  {
+    return (ActionListener[]) getListeners(ActionListener.class);
+  }
+
+  /**
+   * Sends an action event to all registered
+   * <code>ActionListener</code> objects.
+   */
+  protected void fireActionPerformed()
+  {
+    ActionEvent event = new ActionEvent(this, 0, getText());
+    ActionListener[] listeners = getActionListeners();
+
+    for (int index = 0; index < listeners.length; ++index)
+      listeners[index].actionPerformed(event);
+  }
+
+  /**
+   * Returns the number of columns of this text field.
+   *
+   * @return the number of columns
+   */
+  public int getColumns()
+  {
+    return columns;
+  }
+
+  /**
+   * Sets the number of columns and then invalidates the layout.
+   * @param columns the number of columns
+   * @throws IllegalArgumentException if columns < 0
+   */
+  public void setColumns(int columns)
+  {
+    if (columns < 0)
+      throw new IllegalArgumentException();
+
+    this.columns = columns;
+    invalidate();
+    //FIXME: do we need this repaint call?
+    repaint();
+  }
+
+  /**
+   * Returns the horizontal alignment, which is one of: JTextField.LEFT, 
+   * JTextField.CENTER, JTextField.RIGHT, JTextField.LEADING, 
+   * JTextField.TRAILING.
+   * @return the horizontal alignment
+   */
+  public int getHorizontalAlignment()
+  {
+    return align;
+  }
+
+  /**
+   * Sets the horizontal alignment of the text.  Calls invalidate and repaint
+   * and fires a property change event.
+   * @param newAlign must be one of: JTextField.LEFT, JTextField.CENTER,
+   * JTextField.RIGHT, JTextField.LEADING, JTextField.TRAILING.
+   * @throws IllegalArgumentException if newAlign is not one of the above.
+   */
+  public void setHorizontalAlignment(int newAlign)
+  {
+    //FIXME: should throw an IllegalArgumentException if newAlign is invalid
+    if (align == newAlign)
+      return;
+
+    int oldAlign = align;
+    align = newAlign;
+    firePropertyChange("horizontalAlignment", oldAlign, newAlign);
+    invalidate();
+    repaint();
+  }
+
+  /**
+   * Sets the current font and revalidates so the font will take effect.
+   */
+  public void setFont(Font newFont)
+  {
+    super.setFont(newFont);
+    revalidate();
+  }
+
+  /**
+   * Returns the preferred size.  If there is a non-zero number of columns, 
+   * this is the number of columns multiplied by the column width, otherwise
+   * it returns super.getPreferredSize().
+   */
+  public Dimension getPreferredSize()
+  {
+    Dimension size = super.getPreferredSize();
+
+    if (columns != 0)
+      {
+        Insets i = getInsets();
+        size.width = columns * getColumnWidth() + i.left + i.right;
+      }
+
+    return size;
+  }
+
+  /**
+   * Returns the scroll offset in pixels.
+   *
+   * @return the scroll offset
+   */
+  public int getScrollOffset()
+  {
+    return horizontalVisibility.getValue();
+  }
+
+  /**
+   * Sets the scroll offset in pixels.
+   * 
+   * @param offset the scroll offset
+   */
+  public void setScrollOffset(int offset)
+  {
+    // Automatically sets to the highest possible value if
+    // offset is bigger than that.
+    horizontalVisibility.setValue(
+                                  Math.min(horizontalVisibility.getMaximum()
+                                           - horizontalVisibility.getExtent(),
+                                           offset));
+    
+  }
+
+  /**
+   * Returns the set of Actions that are commands for the editor.
+   * This is the actions supported by this editor plus the actions
+   * of the UI (returned by JTextComponent.getActions()).
+   */
+  public Action[] getActions()
+  {
+    return TextAction.augmentList(super.getActions(), actions);
+  }
+
+  public void postActionEvent()
+  {
+    String command = actionCommand != null ? actionCommand : getText();
+    ActionEvent event = new ActionEvent(this, 0, command);
+    ActionListener[] listeners = getActionListeners();
+
+    for (int index = 0; index < listeners.length; ++index)
+      listeners[index].actionPerformed(event);
+  }
+  
+  /**
+   * @since 1.3
+   */
+  public Action getAction()
+  {
+    return action;
+  }
+
+  /**
+   * @since 1.3
+   */
+  public void setAction(Action newAction)
+  {
+    if (action == newAction)
+      return;
+
+    if (action != null)
+      {
+        removeActionListener(action);
+        action.removePropertyChangeListener(actionPropertyChangeListener);
+        actionPropertyChangeListener = null;
+      }
+
+    Action oldAction = action;
+    action = newAction;
+
+    if (action != null)
+      {
+        addActionListener(action);
+        actionPropertyChangeListener = createActionPropertyChangeListener(action);
+        action.addPropertyChangeListener(actionPropertyChangeListener);
+      }
+
+    //FIXME: is this a hack?  The horizontal alignment hasn't changed
+    firePropertyChange("horizontalAlignment", oldAction, newAction);
+  }
+
+  /**
+   * Sets the command string used in action events.
+   * @since 1.3
+   */
+  public void setActionCommand(String command)
+  {
+    actionCommand = command;
+  }
+
+  /**
+   * @since 1.3
+   */
+  protected PropertyChangeListener createActionPropertyChangeListener(Action action)
+  {
+    return new PropertyChangeListener()
+    {
+      public void propertyChange(PropertyChangeEvent event)
+      {
+        // Update properties "action" and "horizontalAlignment".
+        String name = event.getPropertyName();
+
+        if (name.equals("enabled"))
+          {
+            boolean enabled = ((Boolean) event.getNewValue()).booleanValue();
+            JTextField.this.setEnabled(enabled);
+          }
+        else if (name.equals(Action.SHORT_DESCRIPTION))
+          {
+            JTextField.this.setToolTipText((String) event.getNewValue());
+          }
+      }
+    };
+  }
+
+  /**
+   * 
+   * @since 1.3
+   */
+  protected void configurePropertiesFromAction(Action action)
+  {
+    if (action != null)
+      {
+        setEnabled(action.isEnabled());
+        setToolTipText((String) action.getValue(Action.SHORT_DESCRIPTION));
+      }
+    else
+      {
+        setEnabled(true);
+        setToolTipText(null);
+      }
+  }
+
+  /**
+   * Returns the column width, which is the width of the character m
+   * for the font in use.
+   * @return the width of the character m for the font in use.
+   */
+  protected int getColumnWidth()
+  {
+    FontMetrics metrics = getToolkit().getFontMetrics(getFont());
+    return metrics.charWidth('m');
+  }
+
+  /**
+   * Returns the accessible context associated with the <code>JTextField</code>.
+   *
+   * @return the accessible context associated with the <code>JTextField</code>
+   */
+  public AccessibleContext getAccessibleContext()
+  {
+    if (accessibleContext == null)
+      accessibleContext = new AccessibleJTextField();
+    return accessibleContext;
+  }
+
+  /**
+   * Returns the bounded range model that describes the horizontal visibility
+   * of the text field in the case when the text does not fit into the
+   * available space. The actual values of this model are managed by the look
+   * and feel implementation.
+   *
+   * @return the bounded range model that describes the horizontal visibility
+   */
+  public BoundedRangeModel getHorizontalVisibility()
+  {
+    return horizontalVisibility;
+  }
+
+  /**
+   * Returns <code>true</code>, unless this is embedded in a
+   * <code>JViewport</code> in which case the viewport takes responsibility of
+   * validating.
+   *
+   * @return <code>true</code>, unless this is embedded in a
+   *         <code>JViewport</code> in which case the viewport takes
+   *         responsibility of validating
+   */
+  public boolean isValidateRoot()
+  {
+    return ! (getParent() instanceof JViewport);
+  }
+  
+  public void scrollRectToVisible(Rectangle r)
+  {
+    int v = horizontalVisibility.getValue();
+    
+    // The extent value is the inner width of the text field.
+    int e = horizontalVisibility.getExtent();
+    Insets i = getInsets();
+    
+    // The x value in the rectangle (usually) denotes the new location
+    // of the caret. We check whether the location lies inside the left or
+    // right border and scroll into the appropriate direction.
+    // The calculation has to be shifted by the BoundedRangeModel's value
+    // because that value was already used to calculate r.x (this happens
+    // as part of a modelToView() call in FieldView).
+    if (r.x < i.left)
+      setScrollOffset(v + r.x - i.left);
+    else if (r.x > e + i.left)
+      setScrollOffset(r.x + v - e - i.left);
+  }
+  
+}

Added: llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JTextPane.java
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JTextPane.java?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JTextPane.java (added)
+++ llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JTextPane.java Thu Nov  8 16:56:19 2007
@@ -0,0 +1,433 @@
+/* JTextPane.java -- A powerful text widget supporting styled text
+   Copyright (C) 2002, 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;
+
+import java.awt.Component;
+
+import javax.swing.text.AbstractDocument;
+import javax.swing.text.AttributeSet;
+import javax.swing.text.BadLocationException;
+import javax.swing.text.Caret;
+import javax.swing.text.Document;
+import javax.swing.text.EditorKit;
+import javax.swing.text.Element;
+import javax.swing.text.MutableAttributeSet;
+import javax.swing.text.SimpleAttributeSet;
+import javax.swing.text.Style;
+import javax.swing.text.StyleConstants;
+import javax.swing.text.StyledDocument;
+import javax.swing.text.StyledEditorKit;
+
+/**
+ * A powerful text component that supports styled content as well as
+ * embedding images and components. It is entirely based on a
+ * {@link StyledDocument} content model and a {@link StyledEditorKit}.
+ *
+ * @author Roman Kennke (roman at kennke.org)
+ * @author Andrew Selkirk
+ */
+public class JTextPane
+  extends JEditorPane
+{
+  /**
+   * Creates a new <code>JTextPane</code> with a <code>null</code> document.
+   */
+  public JTextPane()
+  {
+    super();
+  }
+
+  /**
+   * Creates a new <code>JTextPane</code> and sets the specified
+   * <code>document</code>.
+   *
+   * @param document the content model to use
+   */
+  public JTextPane(StyledDocument document)
+  {
+    this();
+    setStyledDocument(document);
+  }
+
+  /**
+   * Returns the UI class ID. This is <code>TextPaneUI</code>.
+   *
+   * @return <code>TextPaneUI</code>
+   */
+  public String getUIClassID()
+  {
+    return "TextPaneUI";
+  }
+
+  /**
+   * Sets the content model for this <code>JTextPane</code>.
+   * <code>JTextPane</code> can only be used with {@link StyledDocument}s,
+   * if you try to set a different type of <code>Document</code>, an
+   * <code>IllegalArgumentException</code> is thrown.
+   *
+   * @param document the content model to set
+   *
+   * @throws IllegalArgumentException if <code>document</code> is not an
+   *         instance of <code>StyledDocument</code>
+   *
+   * @see #setStyledDocument
+   */
+  public void setDocument(Document document)
+  {
+    if (document != null && !(document instanceof StyledDocument))
+      throw new IllegalArgumentException
+        ("JTextPane can only handle StyledDocuments");
+
+    setStyledDocument((StyledDocument) document);
+  }
+
+  /**
+   * Returns the {@link StyledDocument} that is the content model for
+   * this <code>JTextPane</code>. This is a typed wrapper for
+   * {@link #getDocument()}.
+   *
+   * @return the content model of this <code>JTextPane</code>
+   */
+  public StyledDocument getStyledDocument()
+  {
+    return (StyledDocument) super.getDocument();
+  }
+
+  /**
+   * Sets the content model for this <code>JTextPane</code>.
+   *
+   * @param document the content model to set
+   */
+  public void setStyledDocument(StyledDocument document)
+  {
+    super.setDocument(document);
+  }
+
+  /**
+   * Replaces the currently selected text with the specified
+   * <code>content</code>. If there is no selected text, this results
+   * in a simple insertion at the current caret position. If there is
+   * no <code>content</code> specified, this results in the selection
+   * beeing deleted.
+   *
+   * @param content the text with which the selection is replaced
+   */
+  public void replaceSelection(String content)
+  {
+    Caret caret = getCaret();
+    StyledDocument doc = getStyledDocument();
+    AttributeSet a = getInputAttributes().copyAttributes();
+    if (doc == null)
+      return;
+
+    int dot = caret.getDot();
+    int mark = caret.getMark();
+
+    int p0 = Math.min (dot, mark);
+    int p1 = Math.max (dot, mark);
+
+    try
+      {
+        if (doc instanceof AbstractDocument)
+          ((AbstractDocument)doc).replace(p0, p1 - p0, content, a);
+        else
+          {
+            // Remove selected text.
+            if (dot != mark)
+              doc.remove(p0, p1 - p0);
+            // Insert new text.
+            if (content != null && content.length() > 0)
+              doc.insertString(p0, content, a);
+          }
+      }
+    catch (BadLocationException e)
+      {
+        throw new AssertionError
+          ("No BadLocationException should be thrown here");      
+      }
+  }
+
+  /**
+   * Inserts an AWT or Swing component into the text at the current caret
+   * position.
+   *
+   * @param component the component to be inserted
+   */
+  public void insertComponent(Component component)
+  {
+    SimpleAttributeSet atts = new SimpleAttributeSet();
+    atts.addAttribute(StyleConstants.ComponentAttribute, component);
+    atts.addAttribute(StyleConstants.NameAttribute,
+                      StyleConstants.ComponentElementName);
+    try
+      {
+        getDocument().insertString(getCaret().getDot(), " ", atts);
+      }
+    catch (BadLocationException ex)
+      {
+        AssertionError err = new AssertionError("Unexpected bad location");
+        err.initCause(ex);
+        throw err;
+      }
+  }
+
+  /**
+   * Inserts an <code>Icon</code> into the text at the current caret position.
+   *
+   * @param icon the <code>Icon</code> to be inserted
+   */
+  public void insertIcon(Icon icon)
+  {
+    SimpleAttributeSet atts = new SimpleAttributeSet();
+    atts.addAttribute(StyleConstants.IconAttribute, icon);
+    atts.addAttribute(StyleConstants.NameAttribute,
+                      StyleConstants.IconElementName);
+    try
+      {
+        getDocument().insertString(getCaret().getDot(), " ", atts);
+      }
+    catch (BadLocationException ex)
+      {
+        AssertionError err = new AssertionError("Unexpected bad location");
+        err.initCause(ex);
+        throw err;
+      }
+  }
+
+  /**
+   * Adds a style into the style hierarchy. Unspecified style attributes
+   * can be resolved in the <code>parent</code> style, if one is specified.
+   *
+   * While it is legal to add nameless styles (<code>nm == null</code),
+   * you must be aware that the client application is then responsible
+   * for managing the style hierarchy, since unnamed styles cannot be
+   * looked up by their name.
+   *
+   * @param nm the name of the style or <code>null</code> if the style should
+   *           be unnamed
+   * @param parent the parent in which unspecified style attributes are
+   *           resolved, or <code>null</code> if that is not necessary
+   *
+   * @return the newly created <code>Style</code>
+   */
+  public Style addStyle(String nm, Style parent)
+  {
+    return getStyledDocument().addStyle(nm, parent);
+  }
+
+  /**
+   * Removes a named <code>Style</code> from the style hierarchy.
+   *
+   * @param nm the name of the <code>Style</code> to be removed
+   */
+  public void removeStyle(String nm)
+  {
+    getStyledDocument().removeStyle(nm);
+  }
+
+  /**
+   * Looks up and returns a named <code>Style</code>.
+   *
+   * @param nm the name of the <code>Style</code>
+   *
+   * @return the found <code>Style</code> of <code>null</code> if no such
+   *         <code>Style</code> exists
+   */
+  public Style getStyle(String nm)
+  {
+    return getStyledDocument().getStyle(nm);
+  }
+
+  /**
+   * Returns the logical style of the paragraph at the current caret position.
+   *
+   * @return the logical style of the paragraph at the current caret position
+   */
+  public Style getLogicalStyle()
+  {
+    return getStyledDocument().getLogicalStyle(getCaretPosition());
+  }
+
+  /**
+   * Sets the logical style for the paragraph at the current caret position.
+   *
+   * @param style the style to set for the current paragraph
+   */
+  public void setLogicalStyle(Style style)
+  {
+    getStyledDocument().setLogicalStyle(getCaretPosition(), style);
+  }
+
+  /**
+   * Returns the text attributes for the character at the current caret
+   * position.
+   *
+   * @return the text attributes for the character at the current caret
+   *         position
+   */
+  public AttributeSet getCharacterAttributes()
+  {
+    StyledDocument doc = getStyledDocument();
+    Element el = doc.getCharacterElement(getCaretPosition());
+    return el.getAttributes();
+  }
+
+  /**
+   * Sets text attributes for the current selection. If there is no selection
+   * the text attributes are applied to newly inserted text
+   *
+   * @param attribute the text attributes to set
+   * @param replace if <code>true</code>, the attributes of the current
+   *     selection are overridden, otherwise they are merged
+   *
+   * @see #getInputAttributes
+   */
+  public void setCharacterAttributes(AttributeSet attribute,
+                                     boolean replace)
+  {
+    int dot = getCaret().getDot();
+    int start = getSelectionStart();
+    int end = getSelectionEnd();
+    if (start == dot && end == dot)
+      // There is no selection, update insertAttributes instead
+      {
+        MutableAttributeSet inputAttributes =
+          getStyledEditorKit().getInputAttributes();
+        if (replace)
+          inputAttributes.removeAttributes(inputAttributes);
+        inputAttributes.addAttributes(attribute);
+      }
+    else
+      getStyledDocument().setCharacterAttributes(start, end - start, attribute,
+						 replace);
+  }
+
+  /**
+   * Returns the text attributes of the paragraph at the current caret
+   * position.
+   *
+   * @return the attributes of the paragraph at the current caret position
+   */
+  public AttributeSet getParagraphAttributes()
+  {
+    StyledDocument doc = getStyledDocument();
+    Element el = doc.getParagraphElement(getCaretPosition());
+    return el.getAttributes();
+  }
+
+  /**
+   * Sets text attributes for the paragraph at the current selection.
+   * If there is no selection the text attributes are applied to
+   * the paragraph at the current caret position.
+   *
+   * @param attribute the text attributes to set
+   * @param replace if <code>true</code>, the attributes of the current
+   *     selection are overridden, otherwise they are merged
+   */
+  public void setParagraphAttributes(AttributeSet attribute,
+                                     boolean replace)
+  {
+    // TODO
+  }
+
+  /**
+   * Returns the attributes that are applied to newly inserted text.
+   * This is a {@link MutableAttributeSet}, so you can easily modify these
+   * attributes.
+   *
+   * @return the attributes that are applied to newly inserted text
+   */
+  public MutableAttributeSet getInputAttributes()
+  {
+    return getStyledEditorKit().getInputAttributes();
+  }
+
+  /**
+   * Returns the {@link StyledEditorKit} that is currently used by this
+   * <code>JTextPane</code>.
+   *
+   * @return the current <code>StyledEditorKit</code> of this
+   *         <code>JTextPane</code>
+   */
+  protected final StyledEditorKit getStyledEditorKit()
+  {
+    return (StyledEditorKit) getEditorKit();
+  }
+
+  /**
+   * Creates the default {@link EditorKit} that is used in
+   * <code>JTextPane</code>s. This is an instance of {@link StyledEditorKit}.
+   *
+   * @return the default {@link EditorKit} that is used in
+   *         <code>JTextPane</code>s
+   */
+  protected EditorKit createDefaultEditorKit()
+  {
+    return new StyledEditorKit();
+  }
+
+  /**
+   * Sets the {@link EditorKit} to use for this <code>JTextPane</code>.
+   * <code>JTextPane</code>s can only handle {@link StyledEditorKit}s,
+   * if client programs try to set a different type of <code>EditorKit</code>
+   * then an IllegalArgumentException is thrown
+   *
+   * @param editor the <code>EditorKit</code> to set
+   *
+   * @throws IllegalArgumentException if <code>editor</code> is no
+   *         <code>StyledEditorKit</code>
+   */
+  public final void setEditorKit(EditorKit editor)
+  {
+    if (!(editor instanceof StyledEditorKit))
+      throw new IllegalArgumentException
+        ("JTextPanes can only handle StyledEditorKits");
+    super.setEditorKit(editor);
+  }
+
+  /**
+   * Returns a param string that can be used for debugging.
+   *
+   * @return a param string that can be used for debugging.
+   */
+  protected String paramString()
+  {
+    return super.paramString(); // TODO
+  }
+}

Added: llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JToggleButton.java
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JToggleButton.java?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JToggleButton.java (added)
+++ llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JToggleButton.java Thu Nov  8 16:56:19 2007
@@ -0,0 +1,354 @@
+/* JToggleButton.java -- 
+   Copyright (C) 2002, 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;
+
+import java.awt.event.ActionEvent;
+import java.awt.event.ItemEvent;
+import java.awt.event.ItemListener;
+
+import javax.accessibility.Accessible;
+import javax.accessibility.AccessibleContext;
+import javax.accessibility.AccessibleRole;
+import javax.accessibility.AccessibleState;
+import javax.swing.plaf.ButtonUI;
+
+/**
+ * The <code>JToggleButton</code> component provides a stateful button,
+ * which can be either selected or unselected.  This provides the basis
+ * for the implementations of radio buttons (<code>JRadioButton</code>)
+ * and check boxes (<code>JCheckBox</code>).
+ *
+ * @author Michael Koch  (konqueror at gmx.de)
+ * @author Graydon Hoare  (graydon at redhat.com)
+ * @author Andrew John Hughes  (gnu_andrew at member.fsf.org)
+ * @see JRadioButton
+ * @see JCheckBox
+ * @since 1.2
+ */
+public class JToggleButton extends AbstractButton implements Accessible
+{
+  /**
+   * This class provides accessibility support for the toggle button.
+   */
+  protected class AccessibleJToggleButton
+    extends AccessibleAbstractButton
+    implements ItemListener
+  {
+    private static final long serialVersionUID = -8652952712161229225L;
+
+    /**
+     * Constructor for the accessible toggle button.
+     */
+    public AccessibleJToggleButton()
+    {
+      super();
+      /* Register the accessible toggle button as a listener for item events */
+      addItemListener(this);
+    }
+
+    /**
+     * Returns the accessible role for the toggle button.
+     *
+     * @return An instance of <code>AccessibleRole</code>, describing
+     *         the role of the toggle button.
+     */
+    public AccessibleRole getAccessibleRole()
+    {
+      return AccessibleRole.TOGGLE_BUTTON;
+    }
+    
+    /**
+     * Monitors the toggle button for state changes and fires accessible
+     * property change events when they occur.
+     *
+     * @param event the event that occurred.
+     */
+    public void itemStateChanged(ItemEvent event)
+    {
+        /* Fire a state property change event as the button's state has changed */
+        if (event.getStateChange() == ItemEvent.SELECTED)
+          {
+            /* State has changed from unselected (null) to selected */
+            firePropertyChange(ACCESSIBLE_STATE_PROPERTY, null, AccessibleState.SELECTED);
+          } 
+        else
+          {
+            /* State has changed from selected to unselected (null) */
+            firePropertyChange(ACCESSIBLE_STATE_PROPERTY, AccessibleState.ENABLED, null);
+          }
+    }
+    
+  }
+
+  /**
+   * The model handles the storage and maintenance of the state of
+   * the toggle button.  This follows the same paradigm (the MVC
+   * or Model-View-Controller design pattern) employed by
+   * other Swing components, where the data associated with a component
+   * is stored separately from the display aspects.
+   */
+  public static class ToggleButtonModel extends DefaultButtonModel
+  {
+    /**
+     * Compatible with Sun's JDK.
+     */
+    private static final long serialVersionUID = -1589950750899943974L;
+    
+    /**
+     * Sets the pressed state of the button.  The selected state
+     * of the button also changes follwing the button being pressed.
+     *
+     * @param p true if the button is pressed down.
+     */
+    public void setPressed(boolean p)  
+    {
+      // cannot change PRESSED state unless button is enabled
+      if (! isEnabled())
+        return;
+      
+      // if this call does not represent a CHANGE in state, then return
+      if ((p && isPressed()) || (!p && !isPressed()))
+        return;
+
+      // The JDK first fires events in the following order:
+      // 1. ChangeEvent for selected
+      // 2. ChangeEvent for pressed
+      // 3. ActionEvent
+      // So do we.
+
+      // setPressed(false) == mouse release on us,
+      // if we were armed, we flip the selected state.
+      if (!p && isArmed())
+        {
+          setSelected(! isSelected());
+        }
+
+      // make the change
+      if (p)
+        stateMask = stateMask | PRESSED;
+      else
+        stateMask = stateMask & (~PRESSED);
+      
+      // notify interested ChangeListeners
+      fireStateChanged();
+
+      if (!p && isArmed())
+        {
+          fireActionPerformed(new ActionEvent(this,
+                                              ActionEvent.ACTION_PERFORMED,
+                                              actionCommand));
+        }
+    }
+      
+      /**
+       * Checks if the button is selected.
+       * 
+       * @return <code>true</code> if the button is selected.
+       */
+      public boolean isSelected()
+      {
+        return super.isSelected();
+      }
+      
+      /**
+       * Sets the selected state of the button.
+       * 
+       * @param b true if button is selected
+       */
+      public void setSelected(boolean b)
+      {
+        super.setSelected(b);
+      }  
+  }
+
+  /**
+   * Compatible with Sun's JDK.
+   */
+  private static final long serialVersionUID = -3128248873429850443L;
+    
+  /**
+   * Constructs an unselected toggle button with no text or icon.
+   */ 
+  public JToggleButton()
+  {
+    this(null, null, false);
+  }
+
+  /**
+   * Constructs a toggle button using the labelling, state
+   * and icon specified by the supplied action.
+   *
+   * @param a the action to use to define the properties of the button.
+   */
+  public JToggleButton(Action a)
+  {
+    this();
+    setAction(a);
+  }
+
+  /**
+   * Constructs an unselected toggle button with the supplied icon
+   * and no text.
+   *
+   * @param icon the icon to use.
+   */
+  public JToggleButton(Icon icon)
+  { 
+    this(null, icon, false);
+  }    
+  
+  /**
+   * Constructs a toggle button with the supplied icon and state.
+   *
+   * @param icon the icon to use.
+   * @param selected if true, the toggle button is initially in the
+   *        selected state.  Otherwise, the button is unselected.
+   */
+  public JToggleButton(Icon icon, boolean selected) 
+  {
+    this(null, icon, selected);
+  }
+  
+  /**
+   * Constructs an unselected toggle button using the supplied text
+   * and no icon.
+   *
+   * @param text the text to use.
+   */ 
+  public JToggleButton(String text)
+  {
+    this(text, null, false);
+  }
+      
+  /**
+   * Constructs a toggle button with the supplied text and state.
+   *
+   * @param text the text to use.
+   * @param selected if true, the toggle button is initially in the
+   *        selected state.  Otherwise, the button is unselected.
+   */
+  public JToggleButton(String text, boolean selected)
+  {
+    this(text, null, selected);
+  }
+
+  /**
+   * Constructs an unselected toggle button with the supplied text
+   * and icon.
+   *
+   * @param text the text to use.
+   * @param icon the icon to use.
+   */
+  public JToggleButton(String text, Icon icon)
+  {
+    this(text, icon, false);
+  }
+
+  /**
+   * Constructs a toggle button with the supplied text, icon and state.
+   *
+   * @param text the text to use.
+   * @param icon the icon to use.
+   * @param selected if true, the toggle button is initially in the
+   *        selected state.  Otherwise, the button is unselected.
+   */
+  public JToggleButton (String text, Icon icon, boolean selected) 
+  {
+    super();
+    init(text, icon);
+
+    setModel(new ToggleButtonModel());	
+    model.setSelected(selected);
+    setAlignmentX(LEFT_ALIGNMENT);
+  }
+
+  /**
+   * Gets the AccessibleContext associated with this <code>JToggleButton</code>.
+   * The context is created, if necessary.
+   *
+   * @return the associated context
+   */
+  public AccessibleContext getAccessibleContext()
+  {
+    /* Create the context if this is the first request */
+    if (accessibleContext == null)
+      {
+        /* Create the context */
+	accessibleContext = new AccessibleJToggleButton();
+      }
+    return accessibleContext;
+  }
+  
+  /**
+   * Returns a string that specifies the name of the Look and Feel
+   * class that renders this component.
+   *
+   * @return The Look and Feel UI class in <code>String</code> form.
+   */
+  public String getUIClassID()
+  {
+    return "ToggleButtonUI";
+  }
+  
+  /**
+   * Returns a textual representation of this component for debugging.
+   * Users should not depend on anything as regards the content or formatting
+   * of this string, except for the fact that the returned string may never be
+   * null (only empty).
+   *
+   * @return the component in <code>String</code> form for debugging.
+   */
+  protected  String paramString()
+  {
+    return super.paramString();
+  }
+  
+  /**
+   * This method resets the toggle button's UI delegate to the default UI for
+   * the current look and feel.
+   */
+  public void updateUI()
+  {	
+    setUI((ButtonUI)UIManager.getUI(this));
+  }
+
+}
+
+
+

Added: llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JToolBar.java
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JToolBar.java?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JToolBar.java (added)
+++ llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JToolBar.java Thu Nov  8 16:56:19 2007
@@ -0,0 +1,796 @@
+/* JToolBar.java --
+   Copyright (C) 2002, 2004, 2005, 2006,  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;
+
+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.beans.PropertyChangeListener;
+
+import javax.accessibility.Accessible;
+import javax.accessibility.AccessibleContext;
+import javax.accessibility.AccessibleRole;
+import javax.accessibility.AccessibleStateSet;
+import javax.swing.plaf.ToolBarUI;
+
+/**
+ * JToolBar is a component that provides a toolbar to Swing programs. Users
+ * can add buttons (or actions that will be represented by JButtons) as well
+ * as other components to the JToolBar. JToolBars can be dragged in and out
+ * of their parent components. If the JToolBar is dragged out of the parent,
+ * then it will be displayed in its own RootPaneContainer. For dragging to
+ * work properly, JToolBars need to be placed in a Container that has a
+ * BorderLayout. That parent Container cannot have components in the NORTH,
+ * EAST, SOUTH,  or WEST components (that is not the JToolBar).
+ */
+public class JToolBar extends JComponent implements SwingConstants, Accessible
+{
+  /**
+   * Provides the accessibility features for the <code>JToolBar</code>
+   * component.
+   */
+  protected class AccessibleJToolBar extends AccessibleJComponent
+  {
+    private static final long serialVersionUID = -5516888265903814215L;
+
+    /**
+     * Creates a new <code>AccessibleJToolBar</code> instance.
+     */
+    protected AccessibleJToolBar()
+    {
+      // Nothing to do here.
+    }
+
+    /**
+     * Returns a set containing the current state of the {@link JToolBar} 
+     * component.  The current implementation simply calls the superclass.
+     *
+     * @return The accessible state set.
+     */
+    public AccessibleStateSet getAccessibleStateSet()
+    {
+      // running tests against the reference implementation, I was unable
+      // to find any state information that is set specifically by the
+      // tool bar...
+      return super.getAccessibleStateSet();
+    }
+
+    /**
+     * Returns the accessible role for the <code>JToolBar</code> component.
+     *
+     * @return {@link AccessibleRole#TOOL_BAR}.
+     */
+    public AccessibleRole getAccessibleRole()
+    {
+      return AccessibleRole.TOOL_BAR;
+    }
+  }
+
+  /**
+   * This is the private JToolBar layout manager.
+   */
+  private class DefaultToolBarLayout implements LayoutManager
+  {
+    /**
+     * This method is called when a new component is added to the container.
+     *
+     * @param name The name of the component added.
+     * @param comp The component that was added.
+     */
+    public void addLayoutComponent(String name, Component comp)
+    {
+      // Do nothing.
+    }
+
+    /**
+     * This method is called to lay out the given container  to position and
+     * size the child components.
+     *
+     * @param c The container to lay out.
+     *
+     * @throws Error DOCUMENT ME!
+     */
+    public void layoutContainer(Container c)
+    {
+      if (! (c instanceof JToolBar))
+	throw new Error("DefaultToolBarLayout can only be used on JToolBars.");
+      Insets insets = getInsets();
+      Insets margin = getMargin();
+      int middle;
+      if (margin != null)
+        {
+	  insets.left += margin.left;
+	  insets.top += margin.top;
+	  insets.bottom += margin.bottom;
+	  insets.right += margin.right;
+        }
+      Component[] components = c.getComponents();
+      Dimension tdims = c.getSize();
+      int start = 0;
+      Dimension pref;
+
+      if (getOrientation() == SwingUtilities.HORIZONTAL)
+        {
+	  start += insets.left;
+	  for (int i = 0; i < components.length; i++)
+	    {
+	      if (components[i] != null && components[i].isVisible())
+	        {
+		  pref = components[i].getPreferredSize();
+		  if (pref != null)
+		    {
+		      middle = (tdims.height - pref.height) / 2;
+		      components[i].setBounds(start, middle, pref.width,
+		                              pref.height);
+		      start += pref.width;
+		    }
+	        }
+	    }
+        }
+      else
+        {
+	  start += insets.top;
+	  for (int i = 0; i < components.length; i++)
+	    {
+	      if (components[i] != null && components[i].isVisible())
+	        {
+		  pref = components[i].getPreferredSize();
+		  if (pref != null)
+		    {
+		      middle = (tdims.width - pref.width) / 2;
+		      components[i].setBounds(middle, start, pref.width,
+		                              pref.height);
+		      start += pref.height;
+		    }
+	        }
+	    }
+        }
+    }
+
+    /**
+     * This method returns the minimum size of the given container given the
+     * child components.
+     *
+     * @param parent The container to measure.
+     *
+     * @return The minimum size of the given container.
+     */
+    public Dimension minimumLayoutSize(Container parent)
+    {
+      return preferredLayoutSize(parent);
+    }
+
+    /**
+     * This method returns the preferred size of the given container given the
+     * child components.
+     *
+     * @param parent The container to measure.
+     *
+     * @return The preferred size of the given container.
+     */
+    public Dimension preferredLayoutSize(Container parent)
+    {
+      int orientation = getOrientation();
+      Component[] components = getComponents();
+
+      int limit = 0;
+      int total = 0;
+      Dimension dims;
+
+      int w = 0;
+      int h = 0;
+
+      if (orientation == SwingConstants.HORIZONTAL)
+        {
+	  for (int i = 0; i < components.length; i++)
+	    {
+	      dims = components[i].getPreferredSize();
+	      if (dims != null)
+	        {
+		  if (dims.height > limit)
+		    limit = dims.height;
+		  total += dims.width;
+	        }
+	    }
+	  w = total;
+	  h = limit;
+        }
+      else
+        {
+	  for (int i = 0; i < components.length; i++)
+	    {
+	      dims = components[i].getPreferredSize();
+	      if (dims != null)
+	        {
+		  if (dims.width > limit)
+		    limit = dims.width;
+		  total += dims.height;
+	        }
+	    }
+	  w = limit;
+	  h = total;
+        }
+
+      Insets insets = getInsets();
+      w += insets.left + insets.right;
+      h += insets.top + insets.bottom;
+
+      Insets margin = getMargin();
+      if (margin != null)
+        {
+	  w += margin.left + margin.right;
+	  h += margin.top + margin.bottom;
+        }
+
+      return new Dimension(w, h);
+    }
+
+    /**
+     * This method is called when the given component  is removed from the
+     * container.
+     *
+     * @param comp The component removed.
+     */
+    public void removeLayoutComponent(Component comp)
+    {
+      // Do nothing.
+    }
+  }
+
+  /**
+   * This is an extension of JSeparator used in toolbars. Unlike JSeparator,
+   * nothing is painted for this Separator, it is only blank space that
+   * separates components.
+   */
+  public static class Separator extends JSeparator
+  {
+    /** DOCUMENT ME! */
+    private static final long serialVersionUID = -1656745644823105219L;
+
+    /**
+     * Creates a new Separator object.
+     */
+    public Separator()
+    {
+      super();
+    } // Separator()
+
+    /**
+     * Creates a new Separator object with the given size.
+     *
+     * @param size The size of the separator.
+     */
+    public Separator(Dimension size)
+    {
+      setPreferredSize(size);
+    } // Separator()
+
+    /**
+     * This method returns the String ID of the UI class of  Separator.
+     *
+     * @return The UI class' String ID.
+     */
+    public String getUIClassID()
+    {
+      return "ToolBarSeparatorUI";
+    } // getUIClassID()
+
+    /**
+     * This method returns the preferred size of the Separator.
+     *
+     * @return The preferred size of the Separator.
+     */
+    public Dimension getPreferredSize()
+    {
+      return super.getPreferredSize();
+    } // getPreferredSize()
+
+    /**
+     * This method returns the maximum size of the Separator.
+     *
+     * @return The maximum size of the Separator.
+     */
+    public Dimension getMaximumSize()
+    {
+      return super.getPreferredSize();
+    } // getMaximumSize()
+
+    /**
+     * This method returns the minimum size of the Separator.
+     *
+     * @return The minimum size of the Separator.
+     */
+    public Dimension getMinimumSize()
+    {
+      return super.getPreferredSize();
+    } // getMinimumSize()
+
+    /**
+     * This method returns the size of the Separator.
+     *
+     * @return The size of the Separator.
+     */
+    public Dimension getSeparatorSize()
+    {
+      return super.getPreferredSize();
+    } // getSeparatorSize()
+
+    /**
+     * This method sets the size of the Separator.
+     *
+     * @param size The new size of the Separator.
+     */
+    public void setSeparatorSize(Dimension size)
+    {
+      setPreferredSize(size);
+    } // setSeparatorSize()
+  } // Separator
+
+  /** DOCUMENT ME! */
+  private static final long serialVersionUID = -1269915519555129643L;
+
+  /** Whether the JToolBar paints its border. */
+  private transient boolean paintBorder = true;
+
+  /** The extra insets around the JToolBar. */
+  private transient Insets margin;
+
+  /** Whether the JToolBar can float (and be dragged around). */
+  private transient boolean floatable = true;
+
+  /** Whether the buttons will have rollover borders. */
+  private transient boolean rollover;
+
+  /** The orientation of the JToolBar. */
+  private int orientation = HORIZONTAL;
+
+  /**
+   * This method creates a new JToolBar object with horizontal orientation
+   * and no name.
+   */
+  public JToolBar()
+  {
+    this(null, HORIZONTAL);
+  } // JToolBar()
+
+  /**
+   * This method creates a new JToolBar with the given orientation and  no
+   * name.
+   *
+   * @param orientation JToolBar orientation (HORIZONTAL or VERTICAL)
+   */
+  public JToolBar(int orientation)
+  {
+    this(null, orientation);
+  } // JToolBar()
+
+  /**
+   * This method creates a new JToolBar object with the given name and
+   * horizontal orientation.
+   *
+   * @param name Name assigned to undocked tool bar.
+   */
+  public JToolBar(String name)
+  {
+    this(name, HORIZONTAL);
+  } // JToolBar()
+
+  /**
+   * This method creates a new JToolBar object with the given name and
+   * orientation.
+   *
+   * @param name Name assigned to undocked tool bar.
+   * @param orientation JToolBar orientation (HORIZONTAL or VERTICAL)
+   */
+  public JToolBar(String name, int orientation)
+  {
+    setName(name);
+    setOrientation(orientation);
+    setLayout(new DefaultToolBarLayout());
+    revalidate();
+    setOpaque(true);
+    updateUI();
+  }
+
+  /**
+   * This method adds a new JButton that performs the given Action to the
+   * JToolBar.
+   *
+   * @param action The Action to add to the JToolBar.
+   *
+   * @return The JButton that wraps the Action.
+   */
+  public JButton add(Action action)
+  {
+    JButton b = createActionComponent(action);
+    add(b);
+    return b;
+  } // add()
+
+  /**
+   * This method paints the border if the borderPainted property is true.
+   *
+   * @param graphics The graphics object to paint with.
+   */
+  protected void paintBorder(Graphics graphics)
+  {
+    if (paintBorder && isFloatable())
+      super.paintBorder(graphics);
+  } // paintBorder()
+
+  /**
+   * This method returns the UI class used to paint this JToolBar.
+   *
+   * @return The UI class for this JToolBar.
+   */
+  public ToolBarUI getUI()
+  {
+    return (ToolBarUI) ui;
+  } // getUI()
+
+  /**
+   * This method sets the UI used with the JToolBar.
+   *
+   * @param ui The UI used with the JToolBar.
+   */
+  public void setUI(ToolBarUI ui)
+  {
+    super.setUI(ui);
+  } // setUI()
+
+  /**
+   * This method resets the UI used to the Look and Feel defaults.
+   */
+  public void updateUI()
+  {
+    setUI((ToolBarUI) UIManager.getUI(this));
+  }
+
+  /**
+   * This method returns the String identifier for the UI class to the used
+   * with the JToolBar.
+   *
+   * @return The String identifier for the UI class.
+   */
+  public String getUIClassID()
+  {
+    return "ToolBarUI";
+  } // getUIClassID()
+
+  /**
+   * This method sets the rollover property for the JToolBar. In rollover
+   * mode, JButtons inside the JToolBar will only display their borders when
+   * the mouse is moving over them.
+   *
+   * @param b The new rollover property.
+   */
+  public void setRollover(boolean b)
+  {
+    if (b != rollover)
+      {
+	rollover = b;
+	firePropertyChange("rollover", ! rollover, rollover);
+	revalidate();
+	repaint();
+      }
+  }
+
+  /**
+   * This method returns the rollover property.
+   *
+   * @return The rollover property.
+   */
+  public boolean isRollover()
+  {
+    return rollover;
+  }
+
+  /**
+   * This method returns the index of the given component.
+   *
+   * @param component The component to find.
+   *
+   * @return The index of the given component.
+   */
+  public int getComponentIndex(Component component)
+  {
+    Component[] components = getComponents();
+    if (components == null)
+      return -1;
+
+    for (int i = 0; i < components.length; i++)
+      if (components[i] == component)
+	return i;
+
+    return -1;
+  } // getComponentIndex()
+
+  /**
+   * This method returns the component at the given index.
+   *
+   * @param index The index of the component.
+   *
+   * @return The component at the given index.
+   */
+  public Component getComponentAtIndex(int index)
+  {
+    return getComponent(index);
+  } // getComponentAtIndex()
+
+  /**
+   * This method returns the margin property.
+   *
+   * @return The margin property.
+   */
+  public Insets getMargin()
+  {
+    return margin;
+  } // getMargin()
+
+  /**
+   * This method sets the margin property. The margin property determines the
+   * extra space between the children components of the JToolBar and the
+   * border.
+   *
+   * @param margin The margin property.
+   */
+  public void setMargin(Insets margin)
+  {
+    if ((this.margin != null && margin == null)
+        || (this.margin == null && margin != null)
+        || (margin != null && this.margin != null
+        && (margin.left != this.margin.left
+        || margin.right != this.margin.right || margin.top != this.margin.top
+        || margin.bottom != this.margin.bottom)))
+      {
+	Insets oldMargin = this.margin;
+	this.margin = margin;
+	firePropertyChange("margin", oldMargin, this.margin);
+	revalidate();
+	repaint();
+      }
+  } // setMargin()
+
+  /**
+   * This method returns the borderPainted property.
+   *
+   * @return The borderPainted property.
+   */
+  public boolean isBorderPainted()
+  {
+    return paintBorder;
+  } // isBorderPainted()
+
+  /**
+   * This method sets the borderPainted property. If set to false, the border
+   * will not be painted.
+   *
+   * @param painted Whether the border will be painted.
+   */
+  public void setBorderPainted(boolean painted)
+  {
+    if (painted != paintBorder)
+      {
+	paintBorder = painted;
+	firePropertyChange("borderPainted", ! paintBorder,
+	                   paintBorder);
+	repaint();
+      }
+  } // setBorderPainted()
+
+  /**
+   * This method returns the floatable property.
+   *
+   * @return The floatable property.
+   */
+  public boolean isFloatable()
+  {
+    return floatable;
+  } // isFloatable()
+
+  /**
+   * This method sets the floatable property. If set to false, the JToolBar
+   * cannot be dragged.
+   *
+   * @param floatable Whether the JToolBar can be dragged.
+   */
+  public void setFloatable(boolean floatable)
+  {
+    if (floatable != this.floatable)
+      {
+	this.floatable = floatable;
+	firePropertyChange("floatable", ! floatable, floatable);
+      }
+  } // setFloatable()
+
+  /**
+   * This method returns the orientation of the JToolBar.
+   *
+   * @return The orientation of the JToolBar.
+   */
+  public int getOrientation()
+  {
+    return orientation;
+  } // getOrientation()
+
+  /**
+   * This method sets the layout manager to be used with the JToolBar.
+   *
+   * @param mgr The Layout Manager used with the JToolBar.
+   */
+  public void setLayout(LayoutManager mgr)
+  {
+    super.setLayout(mgr);
+    revalidate();
+    repaint();
+  } // setLayout()
+
+  /**
+   * This method sets the orientation property for JToolBar.
+   *
+   * @param orientation The new orientation for JToolBar.
+   *
+   * @throws IllegalArgumentException If the orientation is not HORIZONTAL or
+   *         VERTICAL.
+   */
+  public void setOrientation(int orientation)
+  {
+    if (orientation != HORIZONTAL && orientation != VERTICAL)
+      throw new IllegalArgumentException(orientation
+                                         + " is not a legal orientation");
+    if (orientation != this.orientation)
+      {
+	int oldOrientation = this.orientation;
+	this.orientation = orientation;
+	firePropertyChange("orientation", oldOrientation, this.orientation);
+	revalidate();
+	repaint();
+      }
+  } // setOrientation()
+
+  /**
+   * This method adds a Separator of default size to the JToolBar.
+   */
+  public void addSeparator()
+  {
+    add(new Separator());
+  } // addSeparator()
+
+  /**
+   * This method adds a Separator with the given size to the JToolBar.
+   *
+   * @param size The size of the Separator.
+   */
+  public void addSeparator(Dimension size)
+  {
+    add(new Separator(size));
+  } // addSeparator()
+
+  /**
+   * This method is used to create JButtons which can be added to the JToolBar
+   * for the given action.
+   *
+   * @param action The action to create a JButton for.
+   *
+   * @return The JButton created from the action.
+   */
+  protected JButton createActionComponent(Action action)
+  {
+    return new JButton(action);
+  } // createActionComponent()
+
+  /**
+   * This method creates a pre-configured PropertyChangeListener which updates
+   * the control as changes are made to the Action. However, this is no
+   * longer the recommended way of adding Actions to Containers. As such,
+   * this method returns null.
+   *
+   * @param button The JButton to configure a PropertyChangeListener for.
+   *
+   * @return null.
+   */
+  protected PropertyChangeListener createActionChangeListener(JButton button)
+  {
+    // XXX: As specified, this returns null. But seems kind of strange, usually deprecated methods don't just return null, verify!
+    return null;
+  } // createActionChangeListener()
+
+  /**
+   * This method overrides Container's addImpl method. If a JButton is added,
+   * it is disabled.
+   *
+   * @param component The Component to add.
+   * @param constraints The Constraints placed on the component.
+   * @param index The index to place the Component at.
+   */
+  protected void addImpl(Component component, Object constraints, int index)
+  {
+    // XXX: Sun says disable button but test cases show otherwise.
+    super.addImpl(component, constraints, index);
+
+    // if we added a Swing Button then adjust this a little
+    if (component instanceof AbstractButton)
+      {
+        AbstractButton b = (AbstractButton) component;
+        b.setRolloverEnabled(rollover);
+      }
+
+  } // addImpl()
+
+  /**
+   * Returns a string describing the attributes for the <code>JToolBar</code>
+   * component, for use in debugging.  The return value is guaranteed to be 
+   * non-<code>null</code>, but the format of the string may vary between
+   * implementations.
+   *
+   * @return A string describing the attributes of the <code>JToolBar</code>.
+   */
+  protected String paramString()
+  {
+    StringBuffer sb = new StringBuffer(super.paramString());
+    sb.append(",floatable=").append(floatable);
+    sb.append(",margin=");
+    if (margin != null)
+      sb.append(margin);
+    sb.append(",orientation=");
+    if (orientation == HORIZONTAL)
+      sb.append("HORIZONTAL");
+    else
+      sb.append(VERTICAL);
+    sb.append(",paintBorder=").append(paintBorder);
+    return sb.toString();
+  }
+
+  /**
+   * Returns the object that provides accessibility features for this
+   * <code>JToolBar</code> component.
+   *
+   * @return The accessible context (an instance of {@link AccessibleJToolBar}).
+   */
+  public AccessibleContext getAccessibleContext()
+  {
+    if (accessibleContext == null)
+      accessibleContext = new AccessibleJToolBar();
+
+    return accessibleContext;
+  }
+}

Added: llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JToolTip.java
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JToolTip.java?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JToolTip.java (added)
+++ llvm-gcc-4.2/trunk/libjava/classpath/javax/swing/JToolTip.java Thu Nov  8 16:56:19 2007
@@ -0,0 +1,228 @@
+/* JToolTip.java --
+   Copyright (C) 2002, 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., 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;
+
+import java.awt.AWTEvent;
+import java.beans.PropertyChangeEvent;
+
+import javax.accessibility.Accessible;
+import javax.accessibility.AccessibleContext;
+import javax.accessibility.AccessibleRole;
+import javax.swing.plaf.ToolTipUI;
+
+/**
+ * This class is used to display ToolTips. ToolTips are small floating windows
+ * that display text when the mouse comes to rest over a Component. ToolTips
+ * are set for JComponents using JComponent.setToolTipText(String).
+ */
+public class JToolTip extends JComponent implements Accessible
+{
+
+  private static final long serialVersionUID = -1138929898906751643L;
+
+  /**
+   * Provides the accessibility features for the <code>JToolTip</code>
+   * component.
+   */
+  protected class AccessibleJToolTip extends AccessibleJComponent
+  {
+    private static final long serialVersionUID = -6222548177795408476L;
+
+    /**
+     * Creates a new AccessibleJToolTip object.
+     */
+    protected AccessibleJToolTip()
+    {
+      // Nothing to do here.
+    }
+
+    /**
+     * Returns a description for the accessible component.
+     *
+     * @return A description for the accessible component.
+     */
+    public String getAccessibleDescription()
+    {
+      String result = super.getAccessibleDescription();
+      if (result == null)
+        result = text;
+      return result;
+    }
+
+    /**
+     * Returns the accessible role for the <code>JToolTip</code> component.
+     *
+     * @return {@link AccessibleRole#TOOL_TIP}.
+     */
+    public AccessibleRole getAccessibleRole()
+    {
+      return AccessibleRole.TOOL_TIP;
+    }
+  }
+
+  /** The text to display in the JToolTip. */
+  String text;
+
+  /** The component that the tool tip is associated with. */
+  JComponent component;
+
+  /**
+   * Creates a new <code>JToolTip</code> instance.
+   */
+  public JToolTip()
+  {
+    disableEvents(AWTEvent.MOUSE_EVENT_MASK);
+    updateUI();
+  }
+
+  /**
+   * Returns the text displayed by the tool tip.
+   *
+   * @return The text (possibly <code>null</code>).
+   * 
+   * @see #setTipText(String)
+   */
+  public String getTipText()
+  {
+    return text;
+  }
+
+  /**
+   * Returns the object that provides accessibility features for this
+   * <code>JToolTip</code> component.
+   *
+   * @return The accessible context (an instance of {@link AccessibleJToolTip}).
+   */
+  public AccessibleContext getAccessibleContext()
+  {
+    if (accessibleContext == null)
+      accessibleContext = new AccessibleJToolTip();
+    return accessibleContext;
+  }
+
+  /**
+   * Returns the component that the tool tip is associated with.
+   *
+   * @return The component (possibly <code>null</code>).
+   * 
+   * @see #setComponent(JComponent)
+   */
+  public JComponent getComponent()
+  {
+    return component;
+  }
+
+  /**
+   * Returns the current UI delegate for this component.
+   *
+   * @return The UI delegate.
+   */
+  public ToolTipUI getUI()
+  {
+    return (ToolTipUI) ui;
+  }
+
+  /**
+   * Returns the string suffix used to identify the UI class, in this case
+   * <code>"ToolTipUI"</code>.
+   *
+   * @return <code>"ToolTipUI"</code>.
+   */
+  public String getUIClassID()
+  {
+    return "ToolTipUI";
+  }
+
+  /**
+   * Returns a string describing the attributes for the <code>JToolTip</code>
+   * component, for use in debugging.  The return value is guaranteed to be 
+   * non-<code>null</code>, but the format of the string may vary between
+   * implementations.
+   *
+   * @return A string describing the attributes of the <code>JToolTip</code>.
+   */
+  protected String paramString()
+  {
+    StringBuffer sb = new StringBuffer(super.paramString());
+    sb.append(",tiptext=");
+    if (text != null);
+      sb.append(text);
+    return sb.toString();
+  }
+
+  /**
+   * Sets the component that the tool tip is associated with and sends a 
+   * {@link PropertyChangeEvent} (with the property name 'component') to all 
+   * registered listeners.
+   *
+   * @param c  the component (<code>null</code> permitted).
+   * 
+   * @see #getComponent()
+   */
+  public void setComponent(JComponent c)
+  {
+    JComponent oldValue = component;
+    component = c;
+    firePropertyChange("component", oldValue, c);
+  }
+
+  /**
+   * Sets the text to be displayed by the tool tip and sends a 
+   * {@link PropertyChangeEvent} (with the property name 'tiptext') to all 
+   * registered listeners.
+   *
+   * @param tipText the text (<code>null</code> permitted).
+   * 
+   * @see #getTipText()
+   */
+  public void setTipText(String tipText)
+  {
+    String oldValue = text;
+    text = tipText;
+    firePropertyChange("tiptext", oldValue, tipText);
+  }
+
+  /**
+   * This method resets the UI used to the Look and Feel default.
+   */
+  public void updateUI()
+  {
+    setUI((ToolTipUI) UIManager.getUI(this));
+  }
+}



