| /* List.java -- A listbox widget |
| Copyright (C) 1999, 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., 59 Temple Place, Suite 330, Boston, MA |
| 02111-1307 USA. |
| |
| Linking this library statically or dynamically with other modules is |
| making a combined work based on this library. Thus, the terms and |
| conditions of the GNU General Public License cover the whole |
| combination. |
| |
| As a special exception, the copyright holders of this library give you |
| permission to link this library with independent modules to produce an |
| executable, regardless of the license terms of these independent |
| modules, and to copy and distribute the resulting executable under |
| terms of your choice, provided that you also meet, for each linked |
| independent module, the terms and conditions of the license of that |
| module. An independent module is a module which is not derived from |
| or based on this library. If you modify this library, you may extend |
| this exception to your version of the library, but you are not |
| obligated to do so. If you do not wish to do so, delete this |
| exception statement from your version. */ |
| |
| |
| package 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 |
| { |
| |
| /* |
| * Static Variables |
| */ |
| |
| // Serialization constant |
| private static final long serialVersionUID = -3304312411574666869L; |
| |
| /*************************************************************************/ |
| |
| /* |
| * Instance Variables |
| */ |
| |
| // 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; |
| |
| // The list of ItemListeners for this object. |
| private ItemListener item_listeners; |
| |
| // The list of ActionListeners for this object. |
| private ActionListener action_listeners; |
| |
| |
| /*************************************************************************/ |
| |
| /* |
| * Constructors |
| */ |
| |
| /** |
| * Initializes a new instance of <code>List</code> with no visible lines |
| * and multi-select disabled. |
| * |
| * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true. |
| */ |
| 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) |
| { |
| this.rows = rows; |
| this.multipleMode = multipleMode; |
| |
| if (GraphicsEnvironment.isHeadless()) |
| throw new HeadlessException (); |
| } |
| |
| /*************************************************************************/ |
| |
| /* |
| * Instance Variables |
| */ |
| |
| /** |
| * Returns the number of items in this list. |
| * |
| * @return The number of items in this list. |
| */ |
| 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. |
| */ |
| 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. |
| */ |
| 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. |
| */ |
| 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. |
| */ |
| 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. |
| */ |
| 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. |
| */ |
| 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. |
| */ |
| 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 new Dimension (0, 0); |
| } |
| |
| /*************************************************************************/ |
| |
| /** |
| * This method adds the specified item to the end of the list. |
| * |
| * @param item The item to add to the list. |
| */ |
| 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. |
| */ |
| 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 ((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 |
| { |
| items.removeElementAt (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 |
| */ |
| 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 |
| { |
| if ((start < 0) || (start >= items.size())) |
| throw new IllegalArgumentException("Bad list start index value: " + start); |
| |
| if ((start < 0) || (start >= items.size())) |
| throw new IllegalArgumentException("Bad list start index value: " + start); |
| |
| if (start > end) |
| throw new IllegalArgumentException("Start is greater than end!"); |
| |
| // 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. |
| */ |
| 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. |
| */ |
| 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 (); |
| } |
| |
| /*************************************************************************/ |
| |
| /** |
| * 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 IllegalArgumentException If the index is not valid. |
| */ |
| public synchronized void |
| replaceItem(String item, int index) throws IllegalArgumentException |
| { |
| if ((index < 0) || (index >= items.size())) |
| throw new IllegalArgumentException("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. |
| */ |
| 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. |
| * |
| * @exception IllegalArgumentException If the specified index is out of |
| * range. |
| */ |
| public synchronized void |
| makeVisible(int index) throws IllegalArgumentException |
| { |
| if ((index < 0) || (index >= items.size())) |
| throw new IllegalArgumentException("Bad list index: " + index); |
| |
| 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); |
| } |
| |
| /*************************************************************************/ |
| |
| /** |
| * Makes the item at the specified index not selected. |
| * |
| * @param index The index of the item to unselect. |
| */ |
| public synchronized void |
| deselect(int index) |
| { |
| ListPeer lp = (ListPeer)getPeer(); |
| if (lp != null) |
| lp.deselect(index); |
| } |
| |
| /*************************************************************************/ |
| |
| /** |
| * 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. |
| */ |
| 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. |
| */ |
| 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. |
| */ |
| 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. |
| */ |
| 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. |
| */ |
| 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. |
| */ |
| 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. |
| */ |
| 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. |
| */ |
| public EventListener[] getListeners (Class 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. |
| */ |
| public ActionListener[] getActionListeners () |
| { |
| return (ActionListener[]) getListeners (ActionListener.class); |
| } |
| |
| /** |
| * Returns all action listeners registered to this object. |
| */ |
| public ItemListener[] getItemListeners () |
| { |
| return (ItemListener[]) getListeners (ItemListener.class); |
| } |
| |
| // Accessibility internal class |
| protected class AccessibleAWTList extends AccessibleAWTComponent |
| implements AccessibleSelection, ItemListener, ActionListener |
| { |
| protected class AccessibleAWTListChild extends AccessibleAWTComponent |
| implements Accessible |
| { |
| private int index; |
| private List parent; |
| |
| public AccessibleAWTListChild(List parent, int indexInParent) |
| { |
| this.parent = parent; |
| index = indexInParent; |
| if (parent == null) |
| index = -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(index)) |
| states.add(AccessibleState.SELECTED); |
| return states; |
| } |
| |
| public int getAccessibleIndexInParent() |
| { |
| return index; |
| } |
| |
| } |
| |
| 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; |
| } |
| } // class List |