libjava/java/awt/List.java

   1 /* List.java -- A listbox widget
   2    Copyright (C) 1999, 2002 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 import javax.accessibility.Accessible;
  49
  50 /**
  51   * Class that implements a listbox widget
  52   *
  53   * @author Aaron M. Renn (arenn@urbanophile.com)
  54   */
  55 public class List extends Component
  56   implements ItemSelectable, Accessible
  57 {
  58
  59 /*
  60  * Static Variables
  61  */
  62
  63 // Serialization constant
  64 private static final long serialVersionUID = -3304312411574666869L;
  65
  66 /*************************************************************************/
  67
  68 /*
  69  * Instance Variables
  70  */
  71
  72 // FIXME: Need read/writeObject
  73
  74 /**
  75   * @serial The items in the list.
  76   */
  77 private Vector items = new Vector();
  78
  79 /**
  80   * @serial Indicates whether or not multiple items can be selected
  81   * simultaneously.
  82   */
  83 private boolean multipleMode;
  84
  85 /**
  86   * @serial The number of rows in the list.  This is set on creation
  87   * only and cannot be modified.
  88   */
  89 private int rows;
  90
  91 /**
  92   * @serial An array of the item indices that are selected.
  93   */
  94 private int[] selected;
  95
  96 /**
  97   * @serial An index value used by <code>makeVisible()</code> and
  98   * <code>getVisibleIndex</code>.
  99   */
 100 private int visibleIndex;
 101
 102 // The list of ItemListeners for this object.
 103 private ItemListener item_listeners;
 104
 105 // The list of ActionListeners for this object.
 106 private ActionListener action_listeners;
 107
 108 /*************************************************************************/
 109
 110 /*
 111  * Constructors
 112  */
 113
 114 /**
 115   * Initializes a new instance of <code>List</code> with no visible lines
 116   * and multi-select disabled.
 117   *
 118   * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true.
 119   */
 120 public
 121 List()
 122 {
 123   this(4, false);
 124 }
 125
 126 /*************************************************************************/
 127
 128 /**
 129   * Initializes a new instance of <code>List</code> with the specified
 130   * number of visible lines and multi-select disabled.
 131   *
 132   * @param lines The number of visible lines in the list.
 133   *
 134   * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true.
 135   */
 136 public
 137 List(int rows)
 138 {
 139   this(rows, false);
 140 }
 141
 142 /*************************************************************************/
 143
 144 /**
 145   * Initializes a new instance of <code>List</code> with the specified
 146   * number of lines and the specified multi-select setting.
 147   *
 148   * @param lines The number of visible lines in the list.
 149   * @param multipleMode <code>true</code> if multiple lines can be selected
 150   * simultaneously, <code>false</code> otherwise.
 151   *
 152   * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true.
 153   */
 154 public
 155 List(int rows, boolean multipleMode)
 156 {
 157   this.rows = rows;
 158   this.multipleMode = multipleMode;
 159
 160   if (GraphicsEnvironment.isHeadless())
 161     throw new HeadlessException ();
 162 }
 163
 164 /*************************************************************************/
 165
 166 /*
 167  * Instance Variables
 168  */
 169
 170 /**
 171   * Returns the number of items in this list.
 172   *
 173   * @return The number of items in this list.
 174   */
 175 public int
 176 getItemCount()
 177 {
 178   return(items.size());
 179 }
 180
 181 /*************************************************************************/
 182
 183 /**
 184   * Returns the number of items in this list.
 185   *
 186   * @return The number of items in this list.
 187   *
 188   * @deprecated This method is deprecated in favor of
 189   * <code>getItemCount()</code>
 190   */
 191 public int
 192 countItems()
 193 {
 194   return(getItemCount());
 195 }
 196
 197 /*************************************************************************/
 198
 199 /**
 200   * Returns the complete list of items.
 201   *
 202   * @return The complete list of items in the list.
 203   */
 204 public synchronized String[]
 205 getItems()
 206 {
 207   String[] l_items = new String[getItemCount()];
 208
 209   items.copyInto(l_items);
 210   return(l_items);
 211 }
 212
 213 /*************************************************************************/
 214
 215 /**
 216   * Returns the item at the specified index.
 217   *
 218   * @param index The index of the item to retrieve.
 219   *
 220   * @exception IndexOutOfBoundsException If the index value is not valid.
 221   */
 222 public String
 223 getItem(int index)
 224 {
 225   return((String)items.elementAt(index));
 226 }
 227
 228 /*************************************************************************/
 229
 230 /**
 231   * Returns the number of visible rows in the list.
 232   *
 233   * @return The number of visible rows in the list.
 234   */
 235 public int
 236 getRows()
 237 {
 238   return(rows);
 239 }
 240
 241 /*************************************************************************/
 242
 243 /**
 244   * Tests whether or not multi-select mode is enabled.
 245   *
 246   * @return <code>true</code> if multi-select mode is enabled,
 247   * <code>false</code> otherwise.
 248   */
 249 public boolean
 250 isMultipleMode()
 251 {
 252   return(multipleMode);
 253 }
 254
 255 /*************************************************************************/
 256
 257 /**
 258   * Tests whether or not multi-select mode is enabled.
 259   *
 260   * @return <code>true</code> if multi-select mode is enabled,
 261   * <code>false</code> otherwise.
 262   *
 263   * @deprecated This method is deprecated in favor of
 264   * <code>isMultipleMode()</code>.
 265   */
 266 public boolean
 267 allowsMultipleSelections()
 268 {
 269   return(multipleMode);
 270 }
 271
 272 /*************************************************************************/
 273
 274 /**
 275   * This method enables or disables multiple selection mode for this
 276   * list.
 277   *
 278   * @param multipleMode <code>true</code> to enable multiple mode,
 279   * <code>false</code> otherwise.
 280   */
 281 public void
 282 setMultipleMode(boolean multipleMode)
 283 {
 284   this.multipleMode = multipleMode;
 285   if (peer != null)
 286     {
 287       ListPeer l = (ListPeer) peer;
 288       l.setMultipleMode (multipleMode);
 289     }
 290 }
 291
 292 /*************************************************************************/
 293
 294 /**
 295   * This method enables or disables multiple selection mode for this
 296   * list.
 297   *
 298   * @param multipleMode <code>true</code> to enable multiple mode,
 299   * <code>false</code> otherwise.
 300   *
 301   * @deprecated
 302   */
 303 public void
 304 setMultipleSelections(boolean multipleMode)
 305 {
 306   setMultipleMode(multipleMode);
 307 }
 308
 309 /*************************************************************************/
 310
 311 /**
 312   * Returns the minimum size of this component.
 313   *
 314   * @return The minimum size of this component.
 315   */
 316 public Dimension
 317 getMinimumSize()
 318 {
 319   return(getMinimumSize(rows));
 320 }
 321
 322 /*************************************************************************/
 323
 324 /**
 325   * Returns the minimum size of this component.
 326   *
 327   * @return The minimum size of this component.
 328   *
 329   * @deprecated This method is deprecated in favor of
 330   * <code>getMinimumSize</code>.
 331   */
 332 public Dimension
 333 minimumSize()
 334 {
 335   return(getMinimumSize(rows));
 336 }
 337
 338 /*************************************************************************/
 339
 340 /**
 341   * Returns the minimum size of this component assuming it had the specified
 342   * number of rows.
 343   *
 344   * @param rows The number of rows to size for.
 345   *
 346   * @return The minimum size of this component.
 347   */
 348 public Dimension
 349 getMinimumSize(int rows)
 350 {
 351   ListPeer lp = (ListPeer)getPeer();
 352   if (lp != null)
 353     return(lp.minimumSize(rows));
 354   else
 355     return(new Dimension(0,0));
 356 }
 357
 358 /*************************************************************************/
 359
 360 /**
 361   * Returns the minimum size of this component assuming it had the specified
 362   * number of rows.
 363   *
 364   * @param rows The number of rows to size for.
 365   *
 366   * @return The minimum size of this component.
 367   *
 368   * @deprecated This method is deprecated in favor of
 369   * <code>getMinimumSize(int)</code>>
 370   */
 371 public Dimension
 372 minimumSize(int rows)
 373 {
 374   return(getMinimumSize(rows));
 375 }
 376
 377 /*************************************************************************/
 378
 379 /**
 380   * Returns the preferred size of this component.
 381   *
 382   * @return The preferred size of this component.
 383   */
 384 public Dimension
 385 getPreferredSize()
 386 {
 387   return(getPreferredSize(rows));
 388 }
 389
 390 /*************************************************************************/
 391
 392 /**
 393   * Returns the preferred size of this component.
 394   *
 395   * @return The preferred size of this component.
 396   *
 397   * @deprecated This method is deprecated in favor of
 398   * <code>getPreferredSize</code>.
 399   */
 400 public Dimension
 401 preferredSize()
 402 {
 403   return(getPreferredSize(rows));
 404 }
 405
 406 /*************************************************************************/
 407
 408 /**
 409   * Returns the preferred size of this component assuming it had the specified
 410   * number of rows.
 411   *
 412   * @param rows The number of rows to size for.
 413   *
 414   * @return The preferred size of this component.
 415   */
 416 public Dimension
 417 getPreferredSize(int rows)
 418 {
 419   ListPeer lp = (ListPeer)getPeer();
 420   if (lp != null)
 421     return(lp.preferredSize(rows));
 422   else
 423     return(new Dimension(0,0));
 424 }
 425
 426 /*************************************************************************/
 427
 428 /**
 429   * Returns the preferred size of this component assuming it had the specified
 430   * number of rows.
 431   *
 432   * @param rows The number of rows to size for.
 433   *
 434   * @return The preferred size of this component.
 435   *
 436   * @deprecated This method is deprecated in favor of
 437   * <code>getPreferredSize(int)</code>>
 438   */
 439 public Dimension
 440 preferredSize(int rows)
 441 {
 442   return(getPreferredSize(rows));
 443 }
 444
 445 /*************************************************************************/
 446
 447 /**
 448   * This method adds the specified item to the end of the list.
 449   *
 450   * @param item The item to add to the list.
 451   */
 452 public void
 453 add(String item)
 454 {
 455   add(item, -1);
 456 }
 457
 458 /*************************************************************************/
 459
 460 /**
 461   * This method adds the specified item to the end of the list.
 462   *
 463   * @param item The item to add to the list.
 464   *
 465   * @deprecated Use add() instead.
 466   */
 467 public void
 468 addItem(String item)
 469 {
 470   addItem(item, -1);
 471 }
 472
 473 /*************************************************************************/
 474
 475 /**
 476   * Adds the specified item to the specified location in the list.
 477   * If the desired index is -1 or greater than the number of rows
 478   * in the list, then the item is added to the end.
 479   *
 480   * @param item The item to add to the list.
 481   * @param index The location in the list to add the item, or -1 to add
 482   * to the end.
 483   */
 484 public void
 485 add(String item, int index)
 486 {
 487   if ((index == -1) || (index >= items.size()))
 488     items.addElement(item);
 489   else
 490     items.insertElementAt(item, index);
 491
 492   if (peer != null)
 493     {
 494       ListPeer l = (ListPeer) peer;
 495       l.add (item, index);
 496     }
 497 }
 498
 499 /*************************************************************************/
 500
 501 /**
 502   * Adds the specified item to the specified location in the list.
 503   * If the desired index is -1 or greater than the number of rows
 504   * in the list, then the item is added to the end.
 505   *
 506   * @param item The item to add to the list.
 507   * @param index The location in the list to add the item, or -1 to add
 508   * to the end.
 509   *
 510   * @deprecated Use add() instead.
 511   */
 512 public void
 513 addItem(String item, int index)
 514 {
 515   add(item, index);
 516 }
 517
 518 /*************************************************************************/
 519
 520 /**
 521   * Deletes the item at the specified index.
 522   *
 523   * @param index The index of the item to delete.
 524   *
 525   * @exception IllegalArgumentException If the index is not valid
 526   *
 527   * @deprecated
 528   */
 529 public void
 530 delItem(int index) throws IllegalArgumentException
 531 {
 532   remove(index);
 533 }
 534
 535 /*************************************************************************/
 536
 537 /**
 538   * Deletes the item at the specified index.
 539   *
 540   * @param index The index of the item to delete.
 541   *
 542   * @exception IllegalArgumentException If the index is not valid
 543   */
 544 public void
 545 remove(int index) throws IllegalArgumentException
 546 {
 547   items.removeElementAt (index);
 548   if (peer != null)
 549     {
 550       ListPeer l = (ListPeer) peer;
 551       l.delItems (index, index);
 552     }
 553 }
 554
 555 /*************************************************************************/
 556
 557 /**
 558   * Deletes all items in the specified index range.
 559   *
 560   * @param start The beginning index of the range to delete.
 561   * @param end The ending index of the range to delete.
 562   *
 563   * @exception IllegalArgumentException If the indexes are not valid
 564   *
 565   * @deprecated This method is deprecated for some unknown reason.
 566   */
 567 public synchronized void
 568 delItems(int start, int end) throws IllegalArgumentException
 569 {
 570   if ((start < 0) || (start >= items.size()))
 571     throw new IllegalArgumentException("Bad list start index value: " + start);
 572
 573   if ((start < 0) || (start >= items.size()))
 574     throw new IllegalArgumentException("Bad list start index value: " + start);
 575
 576   if (start > end)
 577     throw new IllegalArgumentException("Start is greater than end!");
 578
 579   // We must run the loop in reverse direction.
 580   for (int i = end; i >= start; --i)
 581     items.removeElementAt (i);
 582   if (peer != null)
 583     {
 584       ListPeer l = (ListPeer) peer;
 585       l.delItems (start, end);
 586     }
 587 }
 588
 589 /*************************************************************************/
 590
 591 /**
 592   * Deletes the first occurrence of the specified item from the list.
 593   *
 594   * @param item The item to delete.
 595   *
 596   * @exception IllegalArgumentException If the specified item does not exist.
 597   */
 598 public synchronized void
 599 remove(String item) throws IllegalArgumentException
 600 {
 601   int index = items.indexOf(item);
 602   if (index == -1)
 603     throw new IllegalArgumentException("List element to delete not found");
 604
 605   remove(index);
 606 }
 607
 608 /*************************************************************************/
 609
 610 /**
 611   * Deletes all of the items from the list.
 612   */
 613 public synchronized void
 614 removeAll()
 615 {
 616   items.clear();
 617   if (peer != null)
 618     {
 619       ListPeer l = (ListPeer) peer;
 620       l.removeAll ();
 621     }
 622 }
 623
 624 /*************************************************************************/
 625
 626 /**
 627   * Deletes all of the items from the list.
 628   *
 629   * @deprecated This method is deprecated in favor of <code>removeAll()</code>.
 630   */
 631 public void
 632 clear()
 633 {
 634   removeAll();
 635 }
 636
 637 /*************************************************************************/
 638
 639 /**
 640   * Replaces the item at the specified index with the specified item.
 641   *
 642   * @param item The new item value.
 643   * @param index The index of the item to replace.
 644   *
 645   * @exception IllegalArgumentException If the index is not valid.
 646   */
 647 public synchronized void
 648 replaceItem(String item, int index) throws IllegalArgumentException
 649 {
 650   if ((index < 0) || (index >= items.size()))
 651     throw new IllegalArgumentException("Bad list index: " + index);
 652
 653   items.insertElementAt(item, index + 1);
 654   items.removeElementAt (index);
 655
 656   if (peer != null)
 657     {
 658       ListPeer l = (ListPeer) peer;
 659
 660       /* We add first and then remove so that the selected
 661          item remains the same */
 662       l.add (item, index + 1);
 663       l.delItems (index, index);
 664     }
 665 }
 666
 667 /*************************************************************************/
 668
 669 /**
 670   * Returns the index of the currently selected item.  -1 will be returned
 671   * if there are no selected rows or if there are multiple selected rows.
 672   *
 673   * @return The index of the selected row.
 674   */
 675 public synchronized int
 676 getSelectedIndex()
 677 {
 678   if (peer != null)
 679     {
 680       ListPeer l = (ListPeer) peer;
 681       selected = l.getSelectedIndexes ();
 682     }
 683
 684   if (selected == null || selected.length != 1)
 685     return -1;
 686   return selected[0];
 687 }
 688
 689 /*************************************************************************/
 690
 691 /**
 692   * Returns an array containing the indexes of the rows that are
 693   * currently selected.
 694   *
 695   * @return A list of indexes of selected rows.
 696   */
 697 public synchronized int[]
 698 getSelectedIndexes()
 699 {
 700   if (peer != null)
 701     {
 702       ListPeer l = (ListPeer) peer;
 703       selected = l.getSelectedIndexes ();
 704     }
 705   return selected;
 706 }
 707
 708 /*************************************************************************/
 709
 710 /**
 711   * Returns the item that is currently selected, or <code>null</code> if there
 712   * is no item selected.  FIXME: What happens if multiple items selected?
 713   *
 714   * @return The selected item, or <code>null</code> if there is no
 715   * selected item.
 716   */
 717 public synchronized String
 718 getSelectedItem()
 719 {
 720   int index = getSelectedIndex();
 721   if (index == -1)
 722     return(null);
 723
 724   return((String)items.elementAt(index));
 725 }
 726
 727 /*************************************************************************/
 728
 729 /**
 730   * Returns the list of items that are currently selected in this list.
 731   *
 732   * @return The list of currently selected items.
 733   */
 734 public synchronized String[]
 735 getSelectedItems()
 736 {
 737   int[] indexes = getSelectedIndexes();
 738   if (indexes == null)
 739     return(new String[0]);
 740
 741   String[] retvals = new String[indexes.length];
 742   if (retvals.length > 0)
 743     for (int i = 0 ; i < retvals.length; i++)
 744        retvals[i] = (String)items.elementAt(indexes[i]);
 745
 746   return(retvals);
 747 }
 748
 749 /*************************************************************************/
 750
 751 /**
 752   * Returns the list of items that are currently selected in this list as
 753   * an array of type <code>Object[]</code> instead of <code>String[]</code>.
 754   *
 755   * @return The list of currently selected items.
 756   */
 757 public synchronized Object[]
 758 getSelectedObjects()
 759 {
 760   int[] indexes = getSelectedIndexes();
 761   if (indexes == null)
 762     return(new Object[0]);
 763
 764   Object[] retvals = new Object[indexes.length];
 765   if (retvals.length > 0)
 766     for (int i = 0 ; i < retvals.length; i++)
 767        retvals[i] = items.elementAt(indexes[i]);
 768
 769   return(retvals);
 770 }
 771
 772 /*************************************************************************/
 773
 774 /**
 775   * Tests whether or not the specified index is selected.
 776   *
 777   * @param index The index to test.
 778   *
 779   * @return <code>true</code> if the index is selected, <code>false</code>
 780   * otherwise.
 781   */
 782 public boolean
 783 isIndexSelected(int index)
 784 {
 785   int[] indexes = getSelectedIndexes();
 786
 787   for (int i = 0; i < indexes.length; i++)
 788     if (indexes[i] == index)
 789       return(true);
 790
 791   return(false);
 792 }
 793
 794 /*************************************************************************/
 795
 796 /**
 797   * Tests whether or not the specified index is selected.
 798   *
 799   * @param index The index to test.
 800   *
 801   * @return <code>true</code> if the index is selected, <code>false</code>
 802   * otherwise.
 803   *
 804   * @deprecated This method is deprecated in favor of
 805   * <code>isIndexSelected(int)</code>.
 806   */
 807 public boolean
 808 isSelected(int index)
 809 {
 810   return(isIndexSelected(index));
 811 }
 812
 813 /*************************************************************************/
 814
 815 /**
 816   * This method ensures that the item at the specified index is visible.
 817   *
 818   * @exception IllegalArgumentException If the specified index is out of
 819   * range.
 820   */
 821 public synchronized void
 822 makeVisible(int index) throws IllegalArgumentException
 823 {
 824   if ((index < 0) || (index >= items.size()))
 825     throw new IllegalArgumentException("Bad list index: " + index);
 826
 827   visibleIndex = index;
 828   if (peer != null)
 829     {
 830       ListPeer l = (ListPeer) peer;
 831       l.makeVisible (index);
 832     }
 833 }
 834
 835 /*************************************************************************/
 836
 837 /**
 838   * Returns the index of the last item that was made visible via the
 839   * <code>makeVisible()</code> method.
 840   *
 841   * @return The index of the last item made visible via the
 842   * <code>makeVisible()</code> method.
 843   */
 844 public int
 845 getVisibleIndex()
 846 {
 847   return(visibleIndex);
 848 }
 849
 850 /*************************************************************************/
 851
 852 /**
 853   * Makes the item at the specified index selected.
 854   *
 855   * @param index The index of the item to select.
 856   */
 857 public synchronized void
 858 select(int index)
 859 {
 860   ListPeer lp = (ListPeer)getPeer();
 861   if (lp != null)
 862     lp.select(index);
 863 }
 864
 865 /*************************************************************************/
 866
 867 /**
 868   * Makes the item at the specified index not selected.
 869   *
 870   * @param index The index of the item to unselect.
 871   */
 872 public synchronized void
 873 deselect(int index)
 874 {
 875   ListPeer lp = (ListPeer)getPeer();
 876   if (lp != null)
 877     lp.deselect(index);
 878 }
 879
 880 /*************************************************************************/
 881
 882 /**
 883   * Notifies this object to create its native peer.
 884   */
 885 public void
 886 addNotify()
 887 {
 888   if (peer == null)
 889     peer = getToolkit ().createList (this);
 890   super.addNotify ();
 891 }
 892
 893 /*************************************************************************/
 894
 895 /**
 896   * Notifies this object to destroy its native peer.
 897   */
 898 public void
 899 removeNotify()
 900 {
 901   super.removeNotify();
 902 }
 903
 904 /*************************************************************************/
 905
 906 /**
 907   * Adds the specified <code>ActionListener</code> to the list of
 908   * registered listeners for this object.
 909   *
 910   * @param listener The listener to add.
 911   */
 912 public synchronized void
 913 addActionListener(ActionListener listener)
 914 {
 915   action_listeners = AWTEventMulticaster.add(action_listeners, listener);
 916 }
 917
 918 /*************************************************************************/
 919
 920 /**
 921   * Removes the specified <code>ActionListener</code> from the list of
 922   * registers listeners for this object.
 923   *
 924   * @param listener The listener to remove.
 925   */
 926 public synchronized void
 927 removeActionListener(ActionListener listener)
 928 {
 929   action_listeners = AWTEventMulticaster.remove(action_listeners, listener);
 930 }
 931
 932 /*************************************************************************/
 933
 934 /**
 935   * Adds the specified <code>ItemListener</code> to the list of
 936   * registered listeners for this object.
 937   *
 938   * @param listener The listener to add.
 939   */
 940 public synchronized void
 941 addItemListener(ItemListener listener)
 942 {
 943   item_listeners = AWTEventMulticaster.add(item_listeners, listener);
 944 }
 945
 946 /*************************************************************************/
 947
 948 /**
 949   * Removes the specified <code>ItemListener</code> from the list of
 950   * registers listeners for this object.
 951   *
 952   * @param listener The listener to remove.
 953   */
 954 public synchronized void
 955 removeItemListener(ItemListener listener)
 956 {
 957   item_listeners = AWTEventMulticaster.remove(item_listeners, listener);
 958 }
 959
 960 /*************************************************************************/
 961
 962 /**
 963   * Processes the specified event for this object.  If the event is an
 964   * instance of <code>ActionEvent</code> then the
 965   * <code>processActionEvent()</code> method is called.  Similarly, if the
 966   * even is an instance of <code>ItemEvent</code> then the
 967   * <code>processItemEvent()</code> method is called.  Otherwise the
 968   * superclass method is called to process this event.
 969   *
 970   * @param event The event to process.
 971   */
 972 protected void
 973 processEvent(AWTEvent event)
 974 {
 975   if (event instanceof ActionEvent)
 976     processActionEvent((ActionEvent)event);
 977   else if (event instanceof ItemEvent)
 978     processItemEvent((ItemEvent)event);
 979   else
 980     super.processEvent(event);
 981 }
 982
 983 /*************************************************************************/
 984
 985 /**
 986   * This method processes the specified event by dispatching it to any
 987   * registered listeners.  Note that this method will only get called if
 988   * action events are enabled.  This will happen automatically if any
 989   * listeners are added, or it can be done "manually" by calling
 990   * the <code>enableEvents()</code> method.
 991   *
 992   * @param event The event to process.
 993   */
 994 protected void
 995 processActionEvent(ActionEvent event)
 996 {
 997   if (action_listeners != null)
 998     action_listeners.actionPerformed(event);
 999 }
1000
1001 /*************************************************************************/
1002
1003 /**
1004   * This method processes the specified event by dispatching it to any
1005   * registered listeners.  Note that this method will only get called if
1006   * item events are enabled.  This will happen automatically if any
1007   * listeners are added, or it can be done "manually" by calling
1008   * the <code>enableEvents()</code> method.
1009   *
1010   * @param event The event to process.
1011   */
1012 protected void
1013 processItemEvent(ItemEvent event)
1014 {
1015   if (item_listeners != null)
1016     item_listeners.itemStateChanged(event);
1017 }
1018
1019 void
1020 dispatchEventImpl(AWTEvent e)
1021 {
1022   if (e.id <= ItemEvent.ITEM_LAST
1023       && e.id >= ItemEvent.ITEM_FIRST
1024       && (item_listeners != null
1025           || (eventMask & AWTEvent.ITEM_EVENT_MASK) != 0))
1026     processEvent(e);
1027   else if (e.id <= ActionEvent.ACTION_LAST
1028            && e.id >= ActionEvent.ACTION_FIRST
1029            && (action_listeners != null
1030                || (eventMask & AWTEvent.ACTION_EVENT_MASK) != 0))
1031     processEvent(e);
1032   else
1033     super.dispatchEventImpl(e);
1034 }
1035
1036 /*************************************************************************/
1037
1038 /**
1039   * Returns a debugging string for this object.
1040   *
1041   * @return A debugging string for this object.
1042   */
1043 protected String
1044 paramString()
1045 {
1046   return "multiple=" + multipleMode + ",rows=" + rows + super.paramString();
1047 }
1048
1049   /**
1050    * Returns an array of all the objects currently registered as FooListeners
1051    * upon this <code>List</code>. FooListeners are registered using the
1052    * addFooListener method.
1053    *
1054    * @exception ClassCastException If listenerType doesn't specify a class or
1055    * interface that implements java.util.EventListener.
1056    */
1057   public EventListener[] getListeners (Class listenerType)
1058   {
1059     if (listenerType == ActionListener.class)
1060       return AWTEventMulticaster.getListeners (action_listeners, listenerType);
1061
1062     if (listenerType == ItemListener.class)
1063       return AWTEventMulticaster.getListeners (item_listeners, listenerType);
1064
1065     return super.getListeners (listenerType);
1066   }
1067
1068   /**
1069    * Returns all action listeners registered to this object.
1070    */
1071   public ActionListener[] getActionListeners ()
1072   {
1073     return (ActionListener[]) getListeners (ActionListener.class);
1074   }
1075
1076   /**
1077    * Returns all action listeners registered to this object.
1078    */
1079   public ItemListener[] getItemListeners ()
1080   {
1081     return (ItemListener[]) getListeners (ItemListener.class);
1082   }
1083 } // class List