obtained gcc-4.6.4.tar.bz2 from upstream website;upstream

verified gcc-4.6.4.tar.bz2.sig;
imported gcc-4.6.4 source tree from verified upstream tarball.

downloading a git-generated archive based on the 'upstream' tag
should provide you with a source tree that is binary identical
to the one extracted from the above tarball.

if you have obtained the source via the command 'git clone',
however, do note that line-endings of files in your working
directory might differ from line-endings of the respective
files in the upstream repository.

1 files changed, 1222 insertions, 0 deletions

diff --git a/libjava/classpath/java/awt/List.java b/libjava/classpath/java/awt/List.java
new file mode 100644
index 000000000..dc1199bbc
--- /dev/null
+++ b/libjava/classpath/java/awt/List.java
@@ -0,0 +1,1222 @@
+/* List.java -- A listbox widget
+   Copyright (C) 1999, 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 java.awt;
+
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.awt.event.ItemEvent;
+import java.awt.event.ItemListener;
+import java.awt.peer.ListPeer;
+import java.util.EventListener;
+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;
+
+/**
+ * Class that implements a listbox widget
+ *
+ * @author Aaron M. Renn (arenn@urbanophile.com)
+ */
+public class List extends Component
+  implements ItemSelectable, Accessible
+{
+
+  /**
+   * The number used to generate the name returned by getName.
+   */
+  private static transient long next_list_number;
+
+  // Serialization constant
+  private static final long serialVersionUID = -3304312411574666869L;
+
+  // FIXME: Need read/writeObject
+
+  /**
+    * @serial The items in the list.
+    */
+  private Vector items = new Vector();
+
+  /**
+   * @serial Indicates whether or not multiple items can be selected
+   * simultaneously.
+   */
+  private boolean multipleMode;
+
+  /**
+   * @serial The number of rows in the list.  This is set on creation
+   * only and cannot be modified.
+   */
+  private int rows;
+
+  /**
+   * @serial An array of the item indices that are selected.
+   */
+  private int[] selected;
+
+  /**
+   * @serial An index value used by <code>makeVisible()</code> and
+   * <code>getVisibleIndex</code>.
+   */
+  private int visibleIndex = -1;
+
+  // The list of ItemListeners for this object.
+  private ItemListener item_listeners;
+
+  // The list of ActionListeners for this object.
+  private ActionListener action_listeners;
+
+  /**
+   * Initializes a new instance of <code>List</code> with no visible lines
+   * and multi-select disabled.
+   *
+   * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true.
+   * @since 1.1
+   */
+  public List()
+  {
+    this(4, false);
+  }
+
+  /**
+   * Initializes a new instance of <code>List</code> with the specified
+   * number of visible lines and multi-select disabled.
+   *
+   * @param rows The number of visible rows in the list.
+   *
+   * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true.
+   */
+  public List(int rows)
+  {
+    this(rows, false);
+  }
+
+  /**
+   * Initializes a new instance of <code>List</code> with the specified
+   * number of lines and the specified multi-select setting.
+   *
+   * @param rows The number of visible rows in the list.
+   * @param multipleMode <code>true</code> if multiple lines can be selected
+   * simultaneously, <code>false</code> otherwise.
+   *
+   * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true.
+   */
+  public List(int rows, boolean multipleMode)
+  {
+    if (rows == 0)
+      this.rows = 4;
+    else
+      this.rows = rows;
+
+    this.multipleMode = multipleMode;
+    selected = new int[0];
+
+    if (GraphicsEnvironment.isHeadless())
+      throw new HeadlessException();
+
+  }
+
+  /**
+   * Returns the number of items in this list.
+   *
+   * @return The number of items in this list.
+   *
+   * @since 1.1
+   */
+  public int getItemCount()
+  {
+    return countItems();
+  }
+
+  /**
+   * Returns the number of items in this list.
+   *
+   * @return The number of items in this list.
+   *
+   * @deprecated This method is deprecated in favor of
+   * <code>getItemCount()</code>
+   */
+  public int countItems()
+  {
+    return items.size();
+  }
+
+  /**
+   * Returns the complete list of items.
+   *
+   * @return The complete list of items in the list.
+   *
+   * @since 1.1
+   */
+  public synchronized String[] getItems()
+  {
+    String[] l_items = new String[getItemCount()];
+
+    items.copyInto(l_items);
+    return(l_items);
+  }
+
+  /**
+   * Returns the item at the specified index.
+   *
+   * @param index The index of the item to retrieve.
+   *
+   * @exception IndexOutOfBoundsException If the index value is not valid.
+   */
+  public String getItem(int index)
+  {
+    return((String) items.elementAt(index));
+  }
+
+  /**
+   * Returns the number of visible rows in the list.
+   *
+   * @return The number of visible rows in the list.
+   */
+  public int getRows()
+  {
+    return(rows);
+  }
+
+  /**
+   * Tests whether or not multi-select mode is enabled.
+   *
+   * @return <code>true</code> if multi-select mode is enabled,
+   * <code>false</code> otherwise.
+   *
+   * @since 1.1
+   */
+  public boolean isMultipleMode()
+  {
+    return allowsMultipleSelections ();
+  }
+
+  /**
+   * Tests whether or not multi-select mode is enabled.
+   *
+   * @return <code>true</code> if multi-select mode is enabled,
+   * <code>false</code> otherwise.
+   *
+   * @deprecated This method is deprecated in favor of
+   * <code>isMultipleMode()</code>.
+   */
+  public boolean allowsMultipleSelections()
+  {
+    return multipleMode;
+  }
+
+  /**
+   * This method enables or disables multiple selection mode for this
+   * list.
+   *
+   * @param multipleMode <code>true</code> to enable multiple mode,
+   * <code>false</code> otherwise.
+   *
+   * @since 1.1
+   */
+  public void setMultipleMode(boolean multipleMode)
+  {
+    setMultipleSelections (multipleMode);
+  }
+
+  /**
+   * This method enables or disables multiple selection mode for this
+   * list.
+   *
+   * @param multipleMode <code>true</code> to enable multiple mode,
+   * <code>false</code> otherwise.
+   *
+   * @deprecated
+   */
+  public void setMultipleSelections(boolean multipleMode)
+  {
+    this.multipleMode = multipleMode;
+
+    ListPeer peer = (ListPeer) getPeer();
+    if (peer != null)
+      peer.setMultipleMode(multipleMode);
+
+  }
+
+  /**
+   * Returns the minimum size of this component.
+   *
+   * @return The minimum size of this component.
+   *
+   * @since 1.1
+   */
+  public Dimension getMinimumSize()
+  {
+    return getMinimumSize(getRows());
+  }
+
+  /**
+   * Returns the minimum size of this component.
+   *
+   * @return The minimum size of this component.
+   *
+   * @deprecated This method is deprecated in favor of
+   * <code>getMinimumSize</code>.
+   */
+  public Dimension minimumSize()
+  {
+    return minimumSize(getRows());
+  }
+
+  /**
+   * Returns the minimum size of this component assuming it had the specified
+   * number of rows.
+   *
+   * @param rows The number of rows to size for.
+   *
+   * @return The minimum size of this component.
+   *
+   * @since 1.1
+   */
+  public Dimension getMinimumSize(int rows)
+  {
+    return minimumSize(rows);
+  }
+
+  /**
+   * Returns the minimum size of this component assuming it had the specified
+   * number of rows.
+   *
+   * @param rows The number of rows to size for.
+   *
+   * @return The minimum size of this component.
+   *
+   * @deprecated This method is deprecated in favor of
+   * <code>getMinimumSize(int)</code>>
+   */
+  public Dimension minimumSize(int rows)
+  {
+    ListPeer peer = (ListPeer) getPeer();
+    if (peer != null)
+      return peer.minimumSize(rows);
+    else
+      return new Dimension(0, 0);
+  }
+
+  /**
+   * Returns the preferred size of this component.
+   *
+   * @return The preferred size of this component.
+   *
+   * @since 1.1
+   */
+  public Dimension getPreferredSize()
+  {
+    return getPreferredSize(getRows());
+  }
+
+  /**
+   * Returns the preferred size of this component.
+   *
+   * @return The preferred size of this component.
+   *
+   * @deprecated This method is deprecated in favor of
+   * <code>getPreferredSize</code>.
+   */
+  public Dimension preferredSize()
+  {
+    return preferredSize(getRows());
+  }
+
+  /**
+   * Returns the preferred size of this component assuming it had the specified
+   * number of rows.
+   *
+   * @param rows The number of rows to size for.
+   *
+   * @return The preferred size of this component.
+   *
+   * @since 1.1
+   */
+  public Dimension getPreferredSize(int rows)
+  {
+    return preferredSize(rows);
+  }
+
+  /**
+   * Returns the preferred size of this component assuming it had the specified
+   * number of rows.
+   *
+   * @param rows The number of rows to size for.
+   *
+   * @return The preferred size of this component.
+   *
+   * @deprecated This method is deprecated in favor of
+   * <code>getPreferredSize(int)</code>>
+   */
+  public Dimension preferredSize(int rows)
+  {
+    ListPeer peer = (ListPeer)getPeer();
+    if (peer != null)
+      return peer.preferredSize(rows);
+    else
+      return getSize();
+  }
+
+  /**
+   * This method adds the specified item to the end of the list.
+   *
+   * @param item The item to add to the list.
+   *
+   * @since 1.1
+   */
+  public void add(String item)
+  {
+    add (item, -1);
+  }
+
+  /**
+   * This method adds the specified item to the end of the list.
+   *
+   * @param item The item to add to the list.
+   *
+   * @deprecated Use add() instead.
+   */
+  public void addItem(String item)
+  {
+    addItem(item, -1);
+  }
+
+  /**
+   * Adds the specified item to the specified location in the list.
+   * If the desired index is -1 or greater than the number of rows
+   * in the list, then the item is added to the end.
+   *
+   * @param item The item to add to the list.
+   * @param index The location in the list to add the item, or -1 to add
+   * to the end.
+   *
+   * @since 1.1
+   */
+  public void add(String item, int index)
+  {
+    addItem(item, index);
+  }
+
+  /**
+   * Adds the specified item to the specified location in the list.
+   * If the desired index is -1 or greater than the number of rows
+   * in the list, then the item is added to the end.
+   *
+   * @param item The item to add to the list.
+   * @param index The location in the list to add the item, or -1 to add
+   * to the end.
+   *
+   * @deprecated Use add() instead.
+   */
+  public void addItem(String item, int index)
+  {
+    if (item == null)
+      item = "";
+
+    if (index < -1)
+      index = -1;
+
+    if ((index == -1) || (index >= items.size ()))
+      items.addElement (item);
+    else
+      items.insertElementAt(item, index);
+
+    ListPeer peer = (ListPeer) getPeer();
+    if (peer != null)
+      peer.add (item, index);
+  }
+
+  /**
+   * Deletes the item at the specified index.
+   *
+   * @param index The index of the item to delete.
+   *
+   * @exception IllegalArgumentException If the index is not valid
+   *
+   * @deprecated
+   */
+  public void delItem(int index) throws IllegalArgumentException
+  {
+    boolean selected = false;
+    if (isSelected(index))
+      {
+        selected = true;
+        deselect(index);
+      }
+
+    items.removeElementAt (index);
+
+    if (selected)
+      select(index);
+
+    ListPeer peer = (ListPeer) getPeer();
+    if (peer != null)
+      peer.delItems (index, index);
+  }
+
+  /**
+   * Deletes the item at the specified index.
+   *
+   * @param index The index of the item to delete.
+   *
+   * @exception IllegalArgumentException If the index is not valid
+   *
+   * @since 1.1
+   */
+  public void remove(int index) throws IllegalArgumentException
+  {
+    delItem(index);
+  }
+
+  /**
+   * Deletes all items in the specified index range.
+   *
+   * @param start The beginning index of the range to delete.
+   * @param end The ending index of the range to delete.
+   *
+   * @exception IllegalArgumentException If the indexes are not valid
+   *
+   * @deprecated This method is deprecated for some unknown reason.
+   */
+  public synchronized void delItems(int start, int end)
+    throws IllegalArgumentException
+  {
+    // We must run the loop in reverse direction.
+    for (int i = end; i >= start; --i)
+      items.removeElementAt (i);
+    if (peer != null)
+      {
+        ListPeer l = (ListPeer) peer;
+        l.delItems (start, end);
+      }
+  }
+
+  /**
+   * Deletes the first occurrence of the specified item from the list.
+   *
+   * @param item The item to delete.
+   *
+   * @exception IllegalArgumentException If the specified item does not exist.
+   *
+   * @since 1.1
+   */
+  public synchronized void remove(String item) throws IllegalArgumentException
+  {
+    int index = items.indexOf(item);
+    if (index == -1)
+      throw new IllegalArgumentException("List element to delete not found");
+
+    remove(index);
+  }
+
+  /**
+   * Deletes all of the items from the list.
+   *
+   * @since 1.1
+   */
+  public synchronized void removeAll()
+  {
+    clear();
+  }
+
+  /**
+   * Deletes all of the items from the list.
+   *
+   * @deprecated This method is deprecated in favor of <code>removeAll()</code>.
+   */
+  public void clear()
+  {
+    items.clear();
+
+    ListPeer peer = (ListPeer) getPeer();
+    if (peer != null)
+      peer.removeAll();
+
+    selected = new int[0];
+  }
+
+  /**
+   * Replaces the item at the specified index with the specified item.
+   *
+   * @param item The new item value.
+   * @param index The index of the item to replace.
+   *
+   * @exception ArrayIndexOutOfBoundsException If the index is not valid.
+   */
+  public synchronized void replaceItem(String item, int index)
+    throws ArrayIndexOutOfBoundsException
+  {
+    if ((index < 0) || (index >= items.size()))
+      throw new ArrayIndexOutOfBoundsException("Bad list index: " + index);
+
+    items.insertElementAt(item, index + 1);
+    items.removeElementAt (index);
+
+    if (peer != null)
+      {
+        ListPeer l = (ListPeer) peer;
+
+        /* We add first and then remove so that the selected
+           item remains the same */
+        l.add (item, index + 1);
+        l.delItems (index, index);
+      }
+  }
+
+  /**
+   * Returns the index of the currently selected item.  -1 will be returned
+   * if there are no selected rows or if there are multiple selected rows.
+   *
+   * @return The index of the selected row.
+   */
+  public synchronized int getSelectedIndex()
+  {
+    if (peer != null)
+      {
+        ListPeer l = (ListPeer) peer;
+        selected = l.getSelectedIndexes ();
+      }
+
+    if (selected == null || selected.length != 1)
+      return -1;
+
+    return selected[0];
+  }
+
+  /**
+   * Returns an array containing the indexes of the rows that are
+   * currently selected.
+   *
+   * @return A list of indexes of selected rows.
+   */
+  public synchronized int[] getSelectedIndexes()
+  {
+    if (peer != null)
+      {
+        ListPeer l = (ListPeer) peer;
+        selected = l.getSelectedIndexes();
+      }
+
+    return selected;
+  }
+
+  /**
+   * Returns the item that is currently selected, or <code>null</code> if there
+   * is no item selected.  FIXME: What happens if multiple items selected?
+   *
+   * @return The selected item, or <code>null</code> if there is no
+   * selected item.
+   */
+  public synchronized String getSelectedItem()
+  {
+    int index = getSelectedIndex();
+    if (index == -1)
+      return(null);
+
+    return((String) items.elementAt(index));
+  }
+
+  /**
+   * Returns the list of items that are currently selected in this list.
+   *
+   * @return The list of currently selected items.
+   */
+  public synchronized String[] getSelectedItems()
+  {
+    int[] indexes = getSelectedIndexes();
+    if (indexes == null)
+      return(new String[0]);
+
+    String[] retvals = new String[indexes.length];
+    if (retvals.length > 0)
+      for (int i = 0 ; i < retvals.length; i++)
+         retvals[i] = (String)items.elementAt(indexes[i]);
+
+    return(retvals);
+  }
+
+  /**
+   * Returns the list of items that are currently selected in this list as
+   * an array of type <code>Object[]</code> instead of <code>String[]</code>.
+   *
+   * @return The list of currently selected items.
+   */
+  public synchronized Object[] getSelectedObjects()
+  {
+    int[] indexes = getSelectedIndexes();
+    if (indexes == null)
+      return(new Object[0]);
+
+    Object[] retvals = new Object[indexes.length];
+    if (retvals.length > 0)
+      for (int i = 0 ; i < retvals.length; i++)
+         retvals[i] = items.elementAt(indexes[i]);
+
+    return(retvals);
+  }
+
+  /**
+   * Tests whether or not the specified index is selected.
+   *
+   * @param index The index to test.
+   *
+   * @return <code>true</code> if the index is selected, <code>false</code>
+   * otherwise.
+   *
+   * @since 1.1
+   */
+  public boolean isIndexSelected(int index)
+  {
+    return isSelected(index);
+  }
+
+  /**
+   * Tests whether or not the specified index is selected.
+   *
+   * @param index The index to test.
+   *
+   * @return <code>true</code> if the index is selected, <code>false</code>
+   * otherwise.
+   *
+   * @deprecated This method is deprecated in favor of
+   * <code>isIndexSelected(int)</code>.
+   */
+  public boolean isSelected(int index)
+  {
+    int[] indexes = getSelectedIndexes();
+
+    for (int i = 0; i < indexes.length; i++)
+      if (indexes[i] == index)
+        return true;
+
+    return false;
+  }
+
+  /**
+   * This method ensures that the item at the specified index is visible.
+   *
+   * @param index The index of the item to be made visible.
+   */
+  public synchronized void makeVisible(int index)
+    throws IllegalArgumentException
+  {
+    visibleIndex = index;
+    if (peer != null)
+      {
+        ListPeer l = (ListPeer) peer;
+        l.makeVisible (index);
+      }
+  }
+
+  /**
+   * Returns the index of the last item that was made visible via the
+   * <code>makeVisible()</code> method.
+   *
+   * @return The index of the last item made visible via the
+   * <code>makeVisible()</code> method.
+   */
+  public int getVisibleIndex()
+  {
+    return visibleIndex;
+  }
+
+  /**
+   * Makes the item at the specified index selected.
+   *
+   * @param index The index of the item to select.
+   */
+  public synchronized void select(int index)
+  {
+    ListPeer lp = (ListPeer) getPeer();
+    if (lp != null)
+      lp.select(index);
+
+   if (selected != null)
+     {
+       boolean found = false;
+       for (int i = 0; i < selected.length; i++)
+         {
+           if (selected[i] == index)
+           found = true;
+         }
+       if (! found)
+         {
+           if (! isMultipleMode())
+             {
+               selected = new int[] { index };
+               return;
+             }
+           int[] temp = new int[selected.length + 1];
+           System.arraycopy(selected, 0, temp, 0, selected.length);
+           temp[selected.length] = index;
+           selected = temp;
+         }
+     }
+   else
+     {
+       selected = new int[1];
+       selected[0] = index;
+     }
+  }
+
+  /**
+   * Makes the item at the specified index not selected.
+   *
+   * @param index The index of the item to unselect.
+   */
+  public synchronized void deselect(int index)
+  {
+    if (isSelected(index))
+      {
+        ListPeer lp = (ListPeer)getPeer();
+        if (lp != null)
+          lp.deselect(index);
+
+        int[] temp = new int[selected.length - 1];
+        for (int i = 0; i < temp.length; i++)
+          {
+            if (selected[i] != index)
+              temp[i] = selected[i];
+            else
+              {
+                System.arraycopy(selected, i + 1, temp, i,
+                                 selected.length - i - 1);
+                break;
+              }
+          }
+        selected = temp;
+      }
+  }
+
+  /**
+   * Notifies this object to create its native peer.
+   */
+  public void addNotify()
+  {
+    if (peer == null)
+      peer = getToolkit ().createList(this);
+    super.addNotify ();
+  }
+
+  /**
+   * Notifies this object to destroy its native peer.
+   */
+  public void removeNotify()
+  {
+    super.removeNotify();
+  }
+
+  /**
+   * Adds the specified <code>ActionListener</code> to the list of
+   * registered listeners for this object.
+   *
+   * @param listener The listener to add.
+   *
+   * @since 1.1
+   */
+  public synchronized void addActionListener(ActionListener listener)
+  {
+    action_listeners = AWTEventMulticaster.add(action_listeners, listener);
+  }
+
+  /**
+   * Removes the specified <code>ActionListener</code> from the list of
+   * registers listeners for this object.
+   *
+   * @param listener The listener to remove.
+   *
+   * @since 1.1
+   */
+  public synchronized void removeActionListener(ActionListener listener)
+  {
+    action_listeners = AWTEventMulticaster.remove(action_listeners, listener);
+  }
+
+  /**
+   * Adds the specified <code>ItemListener</code> to the list of
+   * registered listeners for this object.
+   *
+   * @param listener The listener to add.
+   *
+   * @since 1.1
+   */
+  public synchronized void addItemListener(ItemListener listener)
+  {
+    item_listeners = AWTEventMulticaster.add(item_listeners, listener);
+  }
+
+  /**
+   * Removes the specified <code>ItemListener</code> from the list of
+   * registers listeners for this object.
+   *
+   * @param listener The listener to remove.
+   *
+   * @since 1.1
+   */
+  public synchronized void removeItemListener(ItemListener listener)
+  {
+    item_listeners = AWTEventMulticaster.remove(item_listeners, listener);
+  }
+
+  /**
+   * Processes the specified event for this object.  If the event is an
+   * instance of <code>ActionEvent</code> then the
+   * <code>processActionEvent()</code> method is called.  Similarly, if the
+   * even is an instance of <code>ItemEvent</code> then the
+   * <code>processItemEvent()</code> method is called.  Otherwise the
+   * superclass method is called to process this event.
+   *
+   * @param event The event to process.
+   *
+   * @since 1.1
+   */
+  protected void processEvent(AWTEvent event)
+  {
+    if (event instanceof ActionEvent)
+      processActionEvent((ActionEvent)event);
+    else if (event instanceof ItemEvent)
+      processItemEvent((ItemEvent)event);
+    else
+      super.processEvent(event);
+  }
+
+  /**
+   * This method processes the specified event by dispatching it to any
+   * registered listeners.  Note that this method will only get called if
+   * action events are enabled.  This will happen automatically if any
+   * listeners are added, or it can be done "manually" by calling
+   * the <code>enableEvents()</code> method.
+   *
+   * @param event The event to process.
+   *
+   * @since 1.1
+   */
+  protected void processActionEvent(ActionEvent event)
+  {
+    if (action_listeners != null)
+      action_listeners.actionPerformed(event);
+  }
+
+  /**
+   * This method processes the specified event by dispatching it to any
+   * registered listeners.  Note that this method will only get called if
+   * item events are enabled.  This will happen automatically if any
+   * listeners are added, or it can be done "manually" by calling
+   * the <code>enableEvents()</code> method.
+   *
+   * @param event The event to process.
+   *
+   * @since 1.1
+   */
+  protected void processItemEvent(ItemEvent event)
+  {
+    if (item_listeners != null)
+      item_listeners.itemStateChanged(event);
+  }
+
+  void dispatchEventImpl(AWTEvent e)
+  {
+    if (e.id <= ItemEvent.ITEM_LAST
+        && e.id >= ItemEvent.ITEM_FIRST
+        && (item_listeners != null
+        || (eventMask & AWTEvent.ITEM_EVENT_MASK) != 0))
+      processEvent(e);
+    else if (e.id <= ActionEvent.ACTION_LAST
+           && e.id >= ActionEvent.ACTION_FIRST
+           && (action_listeners != null
+           || (eventMask & AWTEvent.ACTION_EVENT_MASK) != 0))
+      processEvent(e);
+    else
+      super.dispatchEventImpl(e);
+  }
+
+  /**
+   * Returns a debugging string for this object.
+   *
+   * @return A debugging string for this object.
+   */
+  protected String paramString()
+  {
+    return "multiple=" + multipleMode + ",rows=" + rows + super.paramString();
+  }
+
+  /**
+   * Returns an array of all the objects currently registered as FooListeners
+   * upon this <code>List</code>. FooListeners are registered using the
+   * addFooListener method.
+   *
+   * @exception ClassCastException If listenerType doesn't specify a class or
+   * interface that implements java.util.EventListener.
+   *
+   * @since 1.3
+   */
+  public <T extends EventListener> T[] getListeners (Class<T> listenerType)
+  {
+    if (listenerType == ActionListener.class)
+      return AWTEventMulticaster.getListeners (action_listeners, listenerType);
+
+    if (listenerType == ItemListener.class)
+      return AWTEventMulticaster.getListeners (item_listeners, listenerType);
+
+    return super.getListeners (listenerType);
+  }
+
+  /**
+   * Returns all action listeners registered to this object.
+   *
+   * @since 1.4
+   */
+  public ActionListener[] getActionListeners ()
+  {
+    return (ActionListener[]) getListeners (ActionListener.class);
+  }
+
+  /**
+   * Returns all action listeners registered to this object.
+   *
+   * @since 1.4
+   */
+  public ItemListener[] getItemListeners ()
+  {
+    return (ItemListener[]) getListeners (ItemListener.class);
+  }
+
+  // Accessibility internal class
+  protected class AccessibleAWTList extends AccessibleAWTComponent
+    implements AccessibleSelection, ItemListener, ActionListener
+  {
+    private static final long serialVersionUID = 7924617370136012829L;
+
+    protected class AccessibleAWTListChild extends AccessibleAWTComponent
+      implements Accessible
+    {
+      private static final long serialVersionUID = 4412022926028300317L;
+
+      // Field names are fixed by serialization spec.
+      private List parent;
+      private int indexInParent;
+
+      public AccessibleAWTListChild(List parent, int indexInParent)
+      {
+        this.parent = parent;
+        this.indexInParent = indexInParent;
+        if (parent == null)
+          this.indexInParent = -1;
+      }
+
+      /* (non-Javadoc)
+       * @see javax.accessibility.Accessible#getAccessibleContext()
+       */
+      public AccessibleContext getAccessibleContext()
+      {
+        return this;
+      }
+
+      public AccessibleRole getAccessibleRole()
+      {
+        return AccessibleRole.LIST_ITEM;
+      }
+
+      public AccessibleStateSet getAccessibleStateSet()
+      {
+        AccessibleStateSet states = super.getAccessibleStateSet();
+        if (parent.isIndexSelected(indexInParent))
+          states.add(AccessibleState.SELECTED);
+        return states;
+      }
+
+      public int getAccessibleIndexInParent()
+      {
+        return indexInParent;
+      }
+
+    }
+
+    public AccessibleAWTList()
+    {
+      addItemListener(this);
+      addActionListener(this);
+    }
+
+    public AccessibleRole getAccessibleRole()
+    {
+      return AccessibleRole.LIST;
+    }
+
+    public AccessibleStateSet getAccessibleStateSet()
+    {
+      AccessibleStateSet states = super.getAccessibleStateSet();
+      states.add(AccessibleState.SELECTABLE);
+      if (isMultipleMode())
+        states.add(AccessibleState.MULTISELECTABLE);
+      return states;
+    }
+
+    public int getAccessibleChildrenCount()
+    {
+      return getItemCount();
+    }
+
+    public Accessible getAccessibleChild(int i)
+    {
+      if (i >= getItemCount())
+        return null;
+      return new AccessibleAWTListChild(List.this, i);
+    }
+
+    /* (non-Javadoc)
+     * @see javax.accessibility.AccessibleSelection#getAccessibleSelectionCount()
+     */
+    public int getAccessibleSelectionCount()
+    {
+      return getSelectedIndexes().length;
+    }
+
+    /* (non-Javadoc)
+     * @see javax.accessibility.AccessibleSelection#getAccessibleSelection()
+     */
+    public AccessibleSelection getAccessibleSelection()
+    {
+      return this;
+    }
+
+    /* (non-Javadoc)
+     * @see javax.accessibility.AccessibleSelection#getAccessibleSelection(int)
+     */
+    public Accessible getAccessibleSelection(int i)
+    {
+      int[] items = getSelectedIndexes();
+      if (i >= items.length)
+        return null;
+      return new AccessibleAWTListChild(List.this, items[i]);
+    }
+
+    /* (non-Javadoc)
+     * @see javax.accessibility.AccessibleSelection#isAccessibleChildSelected(int)
+     */
+    public boolean isAccessibleChildSelected(int i)
+    {
+      return isIndexSelected(i);
+    }
+
+    /* (non-Javadoc)
+     * @see javax.accessibility.AccessibleSelection#addAccessibleSelection(int)
+     */
+    public void addAccessibleSelection(int i)
+    {
+      select(i);
+    }
+
+    /* (non-Javadoc)
+     * @see javax.accessibility.AccessibleSelection#removeAccessibleSelection(int)
+     */
+    public void removeAccessibleSelection(int i)
+    {
+      deselect(i);
+    }
+
+    /* (non-Javadoc)
+     * @see javax.accessibility.AccessibleSelection#clearAccessibleSelection()
+     */
+    public void clearAccessibleSelection()
+    {
+      for (int i = 0; i < getItemCount(); i++)
+        deselect(i);
+    }
+
+    /* (non-Javadoc)
+     * @see javax.accessibility.AccessibleSelection#selectAllAccessibleSelection()
+     */
+    public void selectAllAccessibleSelection()
+    {
+      if (isMultipleMode())
+        for (int i = 0; i < getItemCount(); i++)
+          select(i);
+    }
+
+    /* (non-Javadoc)
+     * @see java.awt.event.ItemListener#itemStateChanged(java.awt.event.ItemEvent)
+     */
+    public void itemStateChanged(ItemEvent event)
+    {
+    }
+
+    /* (non-Javadoc)
+     * @see java.awt.event.ActionListener#actionPerformed(java.awt.event.ActionEvent)
+     */
+    public void actionPerformed(ActionEvent event)
+    {
+    }
+
+  }
+
+  /**
+   * Gets the AccessibleContext associated with this <code>List</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)
+      accessibleContext = new AccessibleAWTList();
+    return accessibleContext;
+  }
+
+  /**
+   * Generate a unique name for this <code>List</code>.
+   *
+   * @return A unique name for this <code>List</code>.
+   */
+  String generateName()
+  {
+    return "list" + getUniqueLong();
+  }
+
+  private static synchronized long getUniqueLong()
+  {
+    return next_list_number++;
+  }
+} // class List