001 /* List.java -- A listbox widget
002 Copyright (C) 1999, 2002, 2004, 2006, Free Software Foundation, Inc.
003
004 This file is part of GNU Classpath.
005
006 GNU Classpath is free software; you can redistribute it and/or modify
007 it under the terms of the GNU General Public License as published by
008 the Free Software Foundation; either version 2, or (at your option)
009 any later version.
010
011 GNU Classpath is distributed in the hope that it will be useful, but
012 WITHOUT ANY WARRANTY; without even the implied warranty of
013 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
014 General Public License for more details.
015
016 You should have received a copy of the GNU General Public License
017 along with GNU Classpath; see the file COPYING. If not, write to the
018 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
019 02110-1301 USA.
020
021 Linking this library statically or dynamically with other modules is
022 making a combined work based on this library. Thus, the terms and
023 conditions of the GNU General Public License cover the whole
024 combination.
025
026 As a special exception, the copyright holders of this library give you
027 permission to link this library with independent modules to produce an
028 executable, regardless of the license terms of these independent
029 modules, and to copy and distribute the resulting executable under
030 terms of your choice, provided that you also meet, for each linked
031 independent module, the terms and conditions of the license of that
032 module. An independent module is a module which is not derived from
033 or based on this library. If you modify this library, you may extend
034 this exception to your version of the library, but you are not
035 obligated to do so. If you do not wish to do so, delete this
036 exception statement from your version. */
037
038
039 package java.awt;
040
041 import java.awt.event.ActionEvent;
042 import java.awt.event.ActionListener;
043 import java.awt.event.ItemEvent;
044 import java.awt.event.ItemListener;
045 import java.awt.peer.ListPeer;
046 import java.util.EventListener;
047 import java.util.Vector;
048
049 import javax.accessibility.Accessible;
050 import javax.accessibility.AccessibleContext;
051 import javax.accessibility.AccessibleRole;
052 import javax.accessibility.AccessibleSelection;
053 import javax.accessibility.AccessibleState;
054 import javax.accessibility.AccessibleStateSet;
055
056 /**
057 * Class that implements a listbox widget
058 *
059 * @author Aaron M. Renn (arenn@urbanophile.com)
060 */
061 public class List extends Component
062 implements ItemSelectable, Accessible
063 {
064
065 /**
066 * The number used to generate the name returned by getName.
067 */
068 private static transient long next_list_number;
069
070 // Serialization constant
071 private static final long serialVersionUID = -3304312411574666869L;
072
073 // FIXME: Need read/writeObject
074
075 /**
076 * @serial The items in the list.
077 */
078 private Vector items = new Vector();
079
080 /**
081 * @serial Indicates whether or not multiple items can be selected
082 * simultaneously.
083 */
084 private boolean multipleMode;
085
086 /**
087 * @serial The number of rows in the list. This is set on creation
088 * only and cannot be modified.
089 */
090 private int rows;
091
092 /**
093 * @serial An array of the item indices that are selected.
094 */
095 private int[] selected;
096
097 /**
098 * @serial An index value used by <code>makeVisible()</code> and
099 * <code>getVisibleIndex</code>.
100 */
101 private int visibleIndex = -1;
102
103 // The list of ItemListeners for this object.
104 private ItemListener item_listeners;
105
106 // The list of ActionListeners for this object.
107 private ActionListener action_listeners;
108
109 /**
110 * Initializes a new instance of <code>List</code> with no visible lines
111 * and multi-select disabled.
112 *
113 * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true.
114 * @since 1.1
115 */
116 public List()
117 {
118 this(4, false);
119 }
120
121 /**
122 * Initializes a new instance of <code>List</code> with the specified
123 * number of visible lines and multi-select disabled.
124 *
125 * @param rows The number of visible rows in the list.
126 *
127 * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true.
128 */
129 public List(int rows)
130 {
131 this(rows, false);
132 }
133
134 /**
135 * Initializes a new instance of <code>List</code> with the specified
136 * number of lines and the specified multi-select setting.
137 *
138 * @param rows The number of visible rows in the list.
139 * @param multipleMode <code>true</code> if multiple lines can be selected
140 * simultaneously, <code>false</code> otherwise.
141 *
142 * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true.
143 */
144 public List(int rows, boolean multipleMode)
145 {
146 if (rows == 0)
147 this.rows = 4;
148 else
149 this.rows = rows;
150
151 this.multipleMode = multipleMode;
152 selected = new int[0];
153
154 if (GraphicsEnvironment.isHeadless())
155 throw new HeadlessException();
156
157 }
158
159 /**
160 * Returns the number of items in this list.
161 *
162 * @return The number of items in this list.
163 *
164 * @since 1.1
165 */
166 public int getItemCount()
167 {
168 return countItems();
169 }
170
171 /**
172 * Returns the number of items in this list.
173 *
174 * @return The number of items in this list.
175 *
176 * @deprecated This method is deprecated in favor of
177 * <code>getItemCount()</code>
178 */
179 public int countItems()
180 {
181 return items.size();
182 }
183
184 /**
185 * Returns the complete list of items.
186 *
187 * @return The complete list of items in the list.
188 *
189 * @since 1.1
190 */
191 public synchronized String[] getItems()
192 {
193 String[] l_items = new String[getItemCount()];
194
195 items.copyInto(l_items);
196 return(l_items);
197 }
198
199 /**
200 * Returns the item at the specified index.
201 *
202 * @param index The index of the item to retrieve.
203 *
204 * @exception IndexOutOfBoundsException If the index value is not valid.
205 */
206 public String getItem(int index)
207 {
208 return((String) items.elementAt(index));
209 }
210
211 /**
212 * Returns the number of visible rows in the list.
213 *
214 * @return The number of visible rows in the list.
215 */
216 public int getRows()
217 {
218 return(rows);
219 }
220
221 /**
222 * Tests whether or not multi-select mode is enabled.
223 *
224 * @return <code>true</code> if multi-select mode is enabled,
225 * <code>false</code> otherwise.
226 *
227 * @since 1.1
228 */
229 public boolean isMultipleMode()
230 {
231 return allowsMultipleSelections ();
232 }
233
234 /**
235 * Tests whether or not multi-select mode is enabled.
236 *
237 * @return <code>true</code> if multi-select mode is enabled,
238 * <code>false</code> otherwise.
239 *
240 * @deprecated This method is deprecated in favor of
241 * <code>isMultipleMode()</code>.
242 */
243 public boolean allowsMultipleSelections()
244 {
245 return multipleMode;
246 }
247
248 /**
249 * This method enables or disables multiple selection mode for this
250 * list.
251 *
252 * @param multipleMode <code>true</code> to enable multiple mode,
253 * <code>false</code> otherwise.
254 *
255 * @since 1.1
256 */
257 public void setMultipleMode(boolean multipleMode)
258 {
259 setMultipleSelections (multipleMode);
260 }
261
262 /**
263 * This method enables or disables multiple selection mode for this
264 * list.
265 *
266 * @param multipleMode <code>true</code> to enable multiple mode,
267 * <code>false</code> otherwise.
268 *
269 * @deprecated
270 */
271 public void setMultipleSelections(boolean multipleMode)
272 {
273 this.multipleMode = multipleMode;
274
275 ListPeer peer = (ListPeer) getPeer();
276 if (peer != null)
277 peer.setMultipleMode(multipleMode);
278
279 }
280
281 /**
282 * Returns the minimum size of this component.
283 *
284 * @return The minimum size of this component.
285 *
286 * @since 1.1
287 */
288 public Dimension getMinimumSize()
289 {
290 return getMinimumSize(getRows());
291 }
292
293 /**
294 * Returns the minimum size of this component.
295 *
296 * @return The minimum size of this component.
297 *
298 * @deprecated This method is deprecated in favor of
299 * <code>getMinimumSize</code>.
300 */
301 public Dimension minimumSize()
302 {
303 return minimumSize(getRows());
304 }
305
306 /**
307 * Returns the minimum size of this component assuming it had the specified
308 * number of rows.
309 *
310 * @param rows The number of rows to size for.
311 *
312 * @return The minimum size of this component.
313 *
314 * @since 1.1
315 */
316 public Dimension getMinimumSize(int rows)
317 {
318 return minimumSize(rows);
319 }
320
321 /**
322 * Returns the minimum size of this component assuming it had the specified
323 * number of rows.
324 *
325 * @param rows The number of rows to size for.
326 *
327 * @return The minimum size of this component.
328 *
329 * @deprecated This method is deprecated in favor of
330 * <code>getMinimumSize(int)</code>>
331 */
332 public Dimension minimumSize(int rows)
333 {
334 ListPeer peer = (ListPeer) getPeer();
335 if (peer != null)
336 return peer.minimumSize(rows);
337 else
338 return new Dimension(0, 0);
339 }
340
341 /**
342 * Returns the preferred size of this component.
343 *
344 * @return The preferred size of this component.
345 *
346 * @since 1.1
347 */
348 public Dimension getPreferredSize()
349 {
350 return getPreferredSize(getRows());
351 }
352
353 /**
354 * Returns the preferred size of this component.
355 *
356 * @return The preferred size of this component.
357 *
358 * @deprecated This method is deprecated in favor of
359 * <code>getPreferredSize</code>.
360 */
361 public Dimension preferredSize()
362 {
363 return preferredSize(getRows());
364 }
365
366 /**
367 * Returns the preferred size of this component assuming it had the specified
368 * number of rows.
369 *
370 * @param rows The number of rows to size for.
371 *
372 * @return The preferred size of this component.
373 *
374 * @since 1.1
375 */
376 public Dimension getPreferredSize(int rows)
377 {
378 return preferredSize(rows);
379 }
380
381 /**
382 * Returns the preferred size of this component assuming it had the specified
383 * number of rows.
384 *
385 * @param rows The number of rows to size for.
386 *
387 * @return The preferred size of this component.
388 *
389 * @deprecated This method is deprecated in favor of
390 * <code>getPreferredSize(int)</code>>
391 */
392 public Dimension preferredSize(int rows)
393 {
394 ListPeer peer = (ListPeer)getPeer();
395 if (peer != null)
396 return peer.preferredSize(rows);
397 else
398 return getSize();
399 }
400
401 /**
402 * This method adds the specified item to the end of the list.
403 *
404 * @param item The item to add to the list.
405 *
406 * @since 1.1
407 */
408 public void add(String item)
409 {
410 add (item, -1);
411 }
412
413 /**
414 * This method adds the specified item to the end of the list.
415 *
416 * @param item The item to add to the list.
417 *
418 * @deprecated Use add() instead.
419 */
420 public void addItem(String item)
421 {
422 addItem(item, -1);
423 }
424
425 /**
426 * Adds the specified item to the specified location in the list.
427 * If the desired index is -1 or greater than the number of rows
428 * in the list, then the item is added to the end.
429 *
430 * @param item The item to add to the list.
431 * @param index The location in the list to add the item, or -1 to add
432 * to the end.
433 *
434 * @since 1.1
435 */
436 public void add(String item, int index)
437 {
438 addItem(item, index);
439 }
440
441 /**
442 * Adds the specified item to the specified location in the list.
443 * If the desired index is -1 or greater than the number of rows
444 * in the list, then the item is added to the end.
445 *
446 * @param item The item to add to the list.
447 * @param index The location in the list to add the item, or -1 to add
448 * to the end.
449 *
450 * @deprecated Use add() instead.
451 */
452 public void addItem(String item, int index)
453 {
454 if (item == null)
455 item = "";
456
457 if (index < -1)
458 index = -1;
459
460 if ((index == -1) || (index >= items.size ()))
461 items.addElement (item);
462 else
463 items.insertElementAt(item, index);
464
465 ListPeer peer = (ListPeer) getPeer();
466 if (peer != null)
467 peer.add (item, index);
468 }
469
470 /**
471 * Deletes the item at the specified index.
472 *
473 * @param index The index of the item to delete.
474 *
475 * @exception IllegalArgumentException If the index is not valid
476 *
477 * @deprecated
478 */
479 public void delItem(int index) throws IllegalArgumentException
480 {
481 boolean selected = false;
482 if (isSelected(index))
483 {
484 selected = true;
485 deselect(index);
486 }
487
488 items.removeElementAt (index);
489
490 if (selected)
491 select(index);
492
493 ListPeer peer = (ListPeer) getPeer();
494 if (peer != null)
495 peer.delItems (index, index);
496 }
497
498 /**
499 * Deletes the item at the specified index.
500 *
501 * @param index The index of the item to delete.
502 *
503 * @exception IllegalArgumentException If the index is not valid
504 *
505 * @since 1.1
506 */
507 public void remove(int index) throws IllegalArgumentException
508 {
509 delItem(index);
510 }
511
512 /**
513 * Deletes all items in the specified index range.
514 *
515 * @param start The beginning index of the range to delete.
516 * @param end The ending index of the range to delete.
517 *
518 * @exception IllegalArgumentException If the indexes are not valid
519 *
520 * @deprecated This method is deprecated for some unknown reason.
521 */
522 public synchronized void delItems(int start, int end)
523 throws IllegalArgumentException
524 {
525 // We must run the loop in reverse direction.
526 for (int i = end; i >= start; --i)
527 items.removeElementAt (i);
528 if (peer != null)
529 {
530 ListPeer l = (ListPeer) peer;
531 l.delItems (start, end);
532 }
533 }
534
535 /**
536 * Deletes the first occurrence of the specified item from the list.
537 *
538 * @param item The item to delete.
539 *
540 * @exception IllegalArgumentException If the specified item does not exist.
541 *
542 * @since 1.1
543 */
544 public synchronized void remove(String item) throws IllegalArgumentException
545 {
546 int index = items.indexOf(item);
547 if (index == -1)
548 throw new IllegalArgumentException("List element to delete not found");
549
550 remove(index);
551 }
552
553 /**
554 * Deletes all of the items from the list.
555 *
556 * @since 1.1
557 */
558 public synchronized void removeAll()
559 {
560 clear();
561 }
562
563 /**
564 * Deletes all of the items from the list.
565 *
566 * @deprecated This method is deprecated in favor of <code>removeAll()</code>.
567 */
568 public void clear()
569 {
570 items.clear();
571
572 ListPeer peer = (ListPeer) getPeer();
573 if (peer != null)
574 peer.removeAll();
575
576 selected = new int[0];
577 }
578
579 /**
580 * Replaces the item at the specified index with the specified item.
581 *
582 * @param item The new item value.
583 * @param index The index of the item to replace.
584 *
585 * @exception ArrayIndexOutOfBoundsException If the index is not valid.
586 */
587 public synchronized void replaceItem(String item, int index)
588 throws ArrayIndexOutOfBoundsException
589 {
590 if ((index < 0) || (index >= items.size()))
591 throw new ArrayIndexOutOfBoundsException("Bad list index: " + index);
592
593 items.insertElementAt(item, index + 1);
594 items.removeElementAt (index);
595
596 if (peer != null)
597 {
598 ListPeer l = (ListPeer) peer;
599
600 /* We add first and then remove so that the selected
601 item remains the same */
602 l.add (item, index + 1);
603 l.delItems (index, index);
604 }
605 }
606
607 /**
608 * Returns the index of the currently selected item. -1 will be returned
609 * if there are no selected rows or if there are multiple selected rows.
610 *
611 * @return The index of the selected row.
612 */
613 public synchronized int getSelectedIndex()
614 {
615 if (peer != null)
616 {
617 ListPeer l = (ListPeer) peer;
618 selected = l.getSelectedIndexes ();
619 }
620
621 if (selected == null || selected.length != 1)
622 return -1;
623
624 return selected[0];
625 }
626
627 /**
628 * Returns an array containing the indexes of the rows that are
629 * currently selected.
630 *
631 * @return A list of indexes of selected rows.
632 */
633 public synchronized int[] getSelectedIndexes()
634 {
635 if (peer != null)
636 {
637 ListPeer l = (ListPeer) peer;
638 selected = l.getSelectedIndexes();
639 }
640
641 return selected;
642 }
643
644 /**
645 * Returns the item that is currently selected, or <code>null</code> if there
646 * is no item selected. FIXME: What happens if multiple items selected?
647 *
648 * @return The selected item, or <code>null</code> if there is no
649 * selected item.
650 */
651 public synchronized String getSelectedItem()
652 {
653 int index = getSelectedIndex();
654 if (index == -1)
655 return(null);
656
657 return((String) items.elementAt(index));
658 }
659
660 /**
661 * Returns the list of items that are currently selected in this list.
662 *
663 * @return The list of currently selected items.
664 */
665 public synchronized String[] getSelectedItems()
666 {
667 int[] indexes = getSelectedIndexes();
668 if (indexes == null)
669 return(new String[0]);
670
671 String[] retvals = new String[indexes.length];
672 if (retvals.length > 0)
673 for (int i = 0 ; i < retvals.length; i++)
674 retvals[i] = (String)items.elementAt(indexes[i]);
675
676 return(retvals);
677 }
678
679 /**
680 * Returns the list of items that are currently selected in this list as
681 * an array of type <code>Object[]</code> instead of <code>String[]</code>.
682 *
683 * @return The list of currently selected items.
684 */
685 public synchronized Object[] getSelectedObjects()
686 {
687 int[] indexes = getSelectedIndexes();
688 if (indexes == null)
689 return(new Object[0]);
690
691 Object[] retvals = new Object[indexes.length];
692 if (retvals.length > 0)
693 for (int i = 0 ; i < retvals.length; i++)
694 retvals[i] = items.elementAt(indexes[i]);
695
696 return(retvals);
697 }
698
699 /**
700 * Tests whether or not the specified index is selected.
701 *
702 * @param index The index to test.
703 *
704 * @return <code>true</code> if the index is selected, <code>false</code>
705 * otherwise.
706 *
707 * @since 1.1
708 */
709 public boolean isIndexSelected(int index)
710 {
711 return isSelected(index);
712 }
713
714 /**
715 * Tests whether or not the specified index is selected.
716 *
717 * @param index The index to test.
718 *
719 * @return <code>true</code> if the index is selected, <code>false</code>
720 * otherwise.
721 *
722 * @deprecated This method is deprecated in favor of
723 * <code>isIndexSelected(int)</code>.
724 */
725 public boolean isSelected(int index)
726 {
727 int[] indexes = getSelectedIndexes();
728
729 for (int i = 0; i < indexes.length; i++)
730 if (indexes[i] == index)
731 return true;
732
733 return false;
734 }
735
736 /**
737 * This method ensures that the item at the specified index is visible.
738 *
739 * @param index The index of the item to be made visible.
740 */
741 public synchronized void makeVisible(int index)
742 throws IllegalArgumentException
743 {
744 visibleIndex = index;
745 if (peer != null)
746 {
747 ListPeer l = (ListPeer) peer;
748 l.makeVisible (index);
749 }
750 }
751
752 /**
753 * Returns the index of the last item that was made visible via the
754 * <code>makeVisible()</code> method.
755 *
756 * @return The index of the last item made visible via the
757 * <code>makeVisible()</code> method.
758 */
759 public int getVisibleIndex()
760 {
761 return visibleIndex;
762 }
763
764 /**
765 * Makes the item at the specified index selected.
766 *
767 * @param index The index of the item to select.
768 */
769 public synchronized void select(int index)
770 {
771 ListPeer lp = (ListPeer) getPeer();
772 if (lp != null)
773 lp.select(index);
774
775 if (selected != null)
776 {
777 boolean found = false;
778 for (int i = 0; i < selected.length; i++)
779 {
780 if (selected[i] == index)
781 found = true;
782 }
783 if (! found)
784 {
785 if (! isMultipleMode())
786 {
787 selected = new int[] { index };
788 return;
789 }
790 int[] temp = new int[selected.length + 1];
791 System.arraycopy(selected, 0, temp, 0, selected.length);
792 temp[selected.length] = index;
793 selected = temp;
794 }
795 }
796 else
797 {
798 selected = new int[1];
799 selected[0] = index;
800 }
801 }
802
803 /**
804 * Makes the item at the specified index not selected.
805 *
806 * @param index The index of the item to unselect.
807 */
808 public synchronized void deselect(int index)
809 {
810 if (isSelected(index))
811 {
812 ListPeer lp = (ListPeer)getPeer();
813 if (lp != null)
814 lp.deselect(index);
815
816 int[] temp = new int[selected.length - 1];
817 for (int i = 0; i < temp.length; i++)
818 {
819 if (selected[i] != index)
820 temp[i] = selected[i];
821 else
822 {
823 System.arraycopy(selected, i + 1, temp, i,
824 selected.length - i - 1);
825 break;
826 }
827 }
828 selected = temp;
829 }
830 }
831
832 /**
833 * Notifies this object to create its native peer.
834 */
835 public void addNotify()
836 {
837 if (peer == null)
838 peer = getToolkit ().createList(this);
839 super.addNotify ();
840 }
841
842 /**
843 * Notifies this object to destroy its native peer.
844 */
845 public void removeNotify()
846 {
847 super.removeNotify();
848 }
849
850 /**
851 * Adds the specified <code>ActionListener</code> to the list of
852 * registered listeners for this object.
853 *
854 * @param listener The listener to add.
855 *
856 * @since 1.1
857 */
858 public synchronized void addActionListener(ActionListener listener)
859 {
860 action_listeners = AWTEventMulticaster.add(action_listeners, listener);
861 }
862
863 /**
864 * Removes the specified <code>ActionListener</code> from the list of
865 * registers listeners for this object.
866 *
867 * @param listener The listener to remove.
868 *
869 * @since 1.1
870 */
871 public synchronized void removeActionListener(ActionListener listener)
872 {
873 action_listeners = AWTEventMulticaster.remove(action_listeners, listener);
874 }
875
876 /**
877 * Adds the specified <code>ItemListener</code> to the list of
878 * registered listeners for this object.
879 *
880 * @param listener The listener to add.
881 *
882 * @since 1.1
883 */
884 public synchronized void addItemListener(ItemListener listener)
885 {
886 item_listeners = AWTEventMulticaster.add(item_listeners, listener);
887 }
888
889 /**
890 * Removes the specified <code>ItemListener</code> from the list of
891 * registers listeners for this object.
892 *
893 * @param listener The listener to remove.
894 *
895 * @since 1.1
896 */
897 public synchronized void removeItemListener(ItemListener listener)
898 {
899 item_listeners = AWTEventMulticaster.remove(item_listeners, listener);
900 }
901
902 /**
903 * Processes the specified event for this object. If the event is an
904 * instance of <code>ActionEvent</code> then the
905 * <code>processActionEvent()</code> method is called. Similarly, if the
906 * even is an instance of <code>ItemEvent</code> then the
907 * <code>processItemEvent()</code> method is called. Otherwise the
908 * superclass method is called to process this event.
909 *
910 * @param event The event to process.
911 *
912 * @since 1.1
913 */
914 protected void processEvent(AWTEvent event)
915 {
916 if (event instanceof ActionEvent)
917 processActionEvent((ActionEvent)event);
918 else if (event instanceof ItemEvent)
919 processItemEvent((ItemEvent)event);
920 else
921 super.processEvent(event);
922 }
923
924 /**
925 * This method processes the specified event by dispatching it to any
926 * registered listeners. Note that this method will only get called if
927 * action events are enabled. This will happen automatically if any
928 * listeners are added, or it can be done "manually" by calling
929 * the <code>enableEvents()</code> method.
930 *
931 * @param event The event to process.
932 *
933 * @since 1.1
934 */
935 protected void processActionEvent(ActionEvent event)
936 {
937 if (action_listeners != null)
938 action_listeners.actionPerformed(event);
939 }
940
941 /**
942 * This method processes the specified event by dispatching it to any
943 * registered listeners. Note that this method will only get called if
944 * item events are enabled. This will happen automatically if any
945 * listeners are added, or it can be done "manually" by calling
946 * the <code>enableEvents()</code> method.
947 *
948 * @param event The event to process.
949 *
950 * @since 1.1
951 */
952 protected void processItemEvent(ItemEvent event)
953 {
954 if (item_listeners != null)
955 item_listeners.itemStateChanged(event);
956 }
957
958 void dispatchEventImpl(AWTEvent e)
959 {
960 if (e.id <= ItemEvent.ITEM_LAST
961 && e.id >= ItemEvent.ITEM_FIRST
962 && (item_listeners != null
963 || (eventMask & AWTEvent.ITEM_EVENT_MASK) != 0))
964 processEvent(e);
965 else if (e.id <= ActionEvent.ACTION_LAST
966 && e.id >= ActionEvent.ACTION_FIRST
967 && (action_listeners != null
968 || (eventMask & AWTEvent.ACTION_EVENT_MASK) != 0))
969 processEvent(e);
970 else
971 super.dispatchEventImpl(e);
972 }
973
974 /**
975 * Returns a debugging string for this object.
976 *
977 * @return A debugging string for this object.
978 */
979 protected String paramString()
980 {
981 return "multiple=" + multipleMode + ",rows=" + rows + super.paramString();
982 }
983
984 /**
985 * Returns an array of all the objects currently registered as FooListeners
986 * upon this <code>List</code>. FooListeners are registered using the
987 * addFooListener method.
988 *
989 * @exception ClassCastException If listenerType doesn't specify a class or
990 * interface that implements java.util.EventListener.
991 *
992 * @since 1.3
993 */
994 public <T extends EventListener> T[] getListeners (Class<T> listenerType)
995 {
996 if (listenerType == ActionListener.class)
997 return AWTEventMulticaster.getListeners (action_listeners, listenerType);
998
999 if (listenerType == ItemListener.class)
1000 return AWTEventMulticaster.getListeners (item_listeners, listenerType);
1001
1002 return super.getListeners (listenerType);
1003 }
1004
1005 /**
1006 * Returns all action listeners registered to this object.
1007 *
1008 * @since 1.4
1009 */
1010 public ActionListener[] getActionListeners ()
1011 {
1012 return (ActionListener[]) getListeners (ActionListener.class);
1013 }
1014
1015 /**
1016 * Returns all action listeners registered to this object.
1017 *
1018 * @since 1.4
1019 */
1020 public ItemListener[] getItemListeners ()
1021 {
1022 return (ItemListener[]) getListeners (ItemListener.class);
1023 }
1024
1025 // Accessibility internal class
1026 protected class AccessibleAWTList extends AccessibleAWTComponent
1027 implements AccessibleSelection, ItemListener, ActionListener
1028 {
1029 private static final long serialVersionUID = 7924617370136012829L;
1030
1031 protected class AccessibleAWTListChild extends AccessibleAWTComponent
1032 implements Accessible
1033 {
1034 private static final long serialVersionUID = 4412022926028300317L;
1035
1036 // Field names are fixed by serialization spec.
1037 private List parent;
1038 private int indexInParent;
1039
1040 public AccessibleAWTListChild(List parent, int indexInParent)
1041 {
1042 this.parent = parent;
1043 this.indexInParent = indexInParent;
1044 if (parent == null)
1045 this.indexInParent = -1;
1046 }
1047
1048 /* (non-Javadoc)
1049 * @see javax.accessibility.Accessible#getAccessibleContext()
1050 */
1051 public AccessibleContext getAccessibleContext()
1052 {
1053 return this;
1054 }
1055
1056 public AccessibleRole getAccessibleRole()
1057 {
1058 return AccessibleRole.LIST_ITEM;
1059 }
1060
1061 public AccessibleStateSet getAccessibleStateSet()
1062 {
1063 AccessibleStateSet states = super.getAccessibleStateSet();
1064 if (parent.isIndexSelected(indexInParent))
1065 states.add(AccessibleState.SELECTED);
1066 return states;
1067 }
1068
1069 public int getAccessibleIndexInParent()
1070 {
1071 return indexInParent;
1072 }
1073
1074 }
1075
1076 public AccessibleAWTList()
1077 {
1078 addItemListener(this);
1079 addActionListener(this);
1080 }
1081
1082 public AccessibleRole getAccessibleRole()
1083 {
1084 return AccessibleRole.LIST;
1085 }
1086
1087 public AccessibleStateSet getAccessibleStateSet()
1088 {
1089 AccessibleStateSet states = super.getAccessibleStateSet();
1090 states.add(AccessibleState.SELECTABLE);
1091 if (isMultipleMode())
1092 states.add(AccessibleState.MULTISELECTABLE);
1093 return states;
1094 }
1095
1096 public int getAccessibleChildrenCount()
1097 {
1098 return getItemCount();
1099 }
1100
1101 public Accessible getAccessibleChild(int i)
1102 {
1103 if (i >= getItemCount())
1104 return null;
1105 return new AccessibleAWTListChild(List.this, i);
1106 }
1107
1108 /* (non-Javadoc)
1109 * @see javax.accessibility.AccessibleSelection#getAccessibleSelectionCount()
1110 */
1111 public int getAccessibleSelectionCount()
1112 {
1113 return getSelectedIndexes().length;
1114 }
1115
1116 /* (non-Javadoc)
1117 * @see javax.accessibility.AccessibleSelection#getAccessibleSelection()
1118 */
1119 public AccessibleSelection getAccessibleSelection()
1120 {
1121 return this;
1122 }
1123
1124 /* (non-Javadoc)
1125 * @see javax.accessibility.AccessibleSelection#getAccessibleSelection(int)
1126 */
1127 public Accessible getAccessibleSelection(int i)
1128 {
1129 int[] items = getSelectedIndexes();
1130 if (i >= items.length)
1131 return null;
1132 return new AccessibleAWTListChild(List.this, items[i]);
1133 }
1134
1135 /* (non-Javadoc)
1136 * @see javax.accessibility.AccessibleSelection#isAccessibleChildSelected(int)
1137 */
1138 public boolean isAccessibleChildSelected(int i)
1139 {
1140 return isIndexSelected(i);
1141 }
1142
1143 /* (non-Javadoc)
1144 * @see javax.accessibility.AccessibleSelection#addAccessibleSelection(int)
1145 */
1146 public void addAccessibleSelection(int i)
1147 {
1148 select(i);
1149 }
1150
1151 /* (non-Javadoc)
1152 * @see javax.accessibility.AccessibleSelection#removeAccessibleSelection(int)
1153 */
1154 public void removeAccessibleSelection(int i)
1155 {
1156 deselect(i);
1157 }
1158
1159 /* (non-Javadoc)
1160 * @see javax.accessibility.AccessibleSelection#clearAccessibleSelection()
1161 */
1162 public void clearAccessibleSelection()
1163 {
1164 for (int i = 0; i < getItemCount(); i++)
1165 deselect(i);
1166 }
1167
1168 /* (non-Javadoc)
1169 * @see javax.accessibility.AccessibleSelection#selectAllAccessibleSelection()
1170 */
1171 public void selectAllAccessibleSelection()
1172 {
1173 if (isMultipleMode())
1174 for (int i = 0; i < getItemCount(); i++)
1175 select(i);
1176 }
1177
1178 /* (non-Javadoc)
1179 * @see java.awt.event.ItemListener#itemStateChanged(java.awt.event.ItemEvent)
1180 */
1181 public void itemStateChanged(ItemEvent event)
1182 {
1183 }
1184
1185 /* (non-Javadoc)
1186 * @see java.awt.event.ActionListener#actionPerformed(java.awt.event.ActionEvent)
1187 */
1188 public void actionPerformed(ActionEvent event)
1189 {
1190 }
1191
1192 }
1193
1194 /**
1195 * Gets the AccessibleContext associated with this <code>List</code>.
1196 * The context is created, if necessary.
1197 *
1198 * @return the associated context
1199 */
1200 public AccessibleContext getAccessibleContext()
1201 {
1202 /* Create the context if this is the first request */
1203 if (accessibleContext == null)
1204 accessibleContext = new AccessibleAWTList();
1205 return accessibleContext;
1206 }
1207
1208 /**
1209 * Generate a unique name for this <code>List</code>.
1210 *
1211 * @return A unique name for this <code>List</code>.
1212 */
1213 String generateName()
1214 {
1215 return "list" + getUniqueLong();
1216 }
1217
1218 private static synchronized long getUniqueLong()
1219 {
1220 return next_list_number++;
1221 }
1222 } // class List