libjava/java/awt/List.java

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