mirror of git://gcc.gnu.org/git/gcc.git
1223 lines
30 KiB
Java
1223 lines
30 KiB
Java
/* 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
|