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.io.Serializable;
  42 import java.awt.event.ActionEvent;
  43 import java.awt.event.ActionListener;
  44 import java.awt.event.ItemEvent;
  45 import java.awt.event.ItemListener;
  46 import java.awt.peer.ListPeer;
  47 import java.awt.peer.ComponentPeer;
  48 import java.util.EventListener;
  49 import java.util.Vector;
  50 import javax.accessibility.Accessible;
  51
  52 /**
  53   * Class that implements a listbox widget
  54   *
  55   * @author Aaron M. Renn (arenn@urbanophile.com)
  56   */
  57 public class List extends Component
  58   implements ItemSelectable, Accessible
  59 {
  60
  61 /*
  62  * Static Variables
  63  */
  64
  65 // Serialization constant
  66 private static final long serialVersionUID = -3304312411574666869L;
  67
  68 /*************************************************************************/
  69
  70 /*
  71  * Instance Variables
  72  */
  73
  74 // FIXME: Need read/writeObject
  75
  76 /**
  77   * @serial The items in the list.
  78   */
  79 private Vector items = new Vector();
  80
  81 /**
  82   * @serial Indicates whether or not multiple items can be selected
  83   * simultaneously.
  84   */
  85 private boolean multipleMode;
  86
  87 /**
  88   * @serial The number of rows in the list.  This is set on creation
  89   * only and cannot be modified.
  90   */
  91 private int rows;
  92
  93 /**
  94   * @serial An array of the item indices that are selected.
  95   */
  96 private int[] selected;
  97
  98 /**
  99   * @serial An index value used by <code>makeVisible()</code> and
 100   * <code>getVisibleIndex</code>.
 101   */
 102 private int visibleIndex;
 103
 104 // The list of ItemListeners for this object.
 105 private ItemListener item_listeners;
 106
 107 // The list of ActionListeners for this object.
 108 private ActionListener action_listeners;
 109
 110 /*************************************************************************/
 111
 112 /*
 113  * Constructors
 114  */
 115
 116 /**
 117   * Initializes a new instance of <code>List</code> with no visible lines
 118   * and multi-select disabled.
 119   *
 120   * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true.
 121   */
 122 public
 123 List()
 124 {
 125   this(4, false);
 126 }
 127
 128 /*************************************************************************/
 129
 130 /**
 131   * Initializes a new instance of <code>List</code> with the specified
 132   * number of visible lines and multi-select disabled.
 133   *
 134   * @param lines The number of visible lines in the list.
 135   *
 136   * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true.
 137   */
 138 public
 139 List(int rows)
 140 {
 141   this(rows, false);
 142 }
 143
 144 /*************************************************************************/
 145
 146 /**
 147   * Initializes a new instance of <code>List</code> with the specified
 148   * number of lines and the specified multi-select setting.
 149   *
 150   * @param lines The number of visible lines in the list.
 151   * @param multipleMode <code>true</code> if multiple lines can be selected
 152   * simultaneously, <code>false</code> otherwise.
 153   *
 154   * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true.
 155   */
 156 public
 157 List(int rows, boolean multipleMode)
 158 {
 159   this.rows = rows;
 160   this.multipleMode = multipleMode;
 161
 162   if (GraphicsEnvironment.isHeadless())
 163     throw new HeadlessException ();
 164 }
 165
 166 /*************************************************************************/
 167
 168 /*
 169  * Instance Variables
 170  */
 171
 172 /**
 173   * Returns the number of items in this list.
 174   *
 175   * @return The number of items in this list.
 176   */
 177 public int
 178 getItemCount()
 179 {
 180   return(items.size());
 181 }
 182
 183 /*************************************************************************/
 184
 185 /**
 186   * Returns the number of items in this list.
 187   *
 188   * @return The number of items in this list.
 189   *
 190   * @deprecated This method is deprecated in favor of
 191   * <code>getItemCount()</code>
 192   */
 193 public int
 194 countItems()
 195 {
 196   return(getItemCount());
 197 }
 198
 199 /*************************************************************************/
 200
 201 /**
 202   * Returns the complete list of items.
 203   *
 204   * @return The complete list of items in the list.
 205   */
 206 public synchronized String[]
 207 getItems()
 208 {
 209   String[] l_items = new String[getItemCount()];
 210
 211   items.copyInto(l_items);
 212   return(l_items);
 213 }
 214
 215 /*************************************************************************/
 216
 217 /**
 218   * Returns the item at the specified index.
 219   *
 220   * @param index The index of the item to retrieve.
 221   *
 222   * @exception IndexOutOfBoundsException If the index value is not valid.
 223   */
 224 public String
 225 getItem(int index)
 226 {
 227   return((String)items.elementAt(index));
 228 }
 229
 230 /*************************************************************************/
 231
 232 /**
 233   * Returns the number of visible rows in the list.
 234   *
 235   * @return The number of visible rows in the list.
 236   */
 237 public int
 238 getRows()
 239 {
 240   return(rows);
 241 }
 242
 243 /*************************************************************************/
 244
 245 /**
 246   * Tests whether or not multi-select mode is enabled.
 247   *
 248   * @return <code>true</code> if multi-select mode is enabled,
 249   * <code>false</code> otherwise.
 250   */
 251 public boolean
 252 isMultipleMode()
 253 {
 254   return(multipleMode);
 255 }
 256
 257 /*************************************************************************/
 258
 259 /**
 260   * Tests whether or not multi-select mode is enabled.
 261   *
 262   * @return <code>true</code> if multi-select mode is enabled,
 263   * <code>false</code> otherwise.
 264   *
 265   * @deprecated This method is deprecated in favor of
 266   * <code>isMultipleMode()</code>.
 267   */
 268 public boolean
 269 allowsMultipleSelections()
 270 {
 271   return(multipleMode);
 272 }
 273
 274 /*************************************************************************/
 275
 276 /**
 277   * This method enables or disables multiple selection mode for this
 278   * list.
 279   *
 280   * @param multipleMode <code>true</code> to enable multiple mode,
 281   * <code>false</code> otherwise.
 282   */
 283 public void
 284 setMultipleMode(boolean multipleMode)
 285 {
 286   this.multipleMode = multipleMode;
 287   if (peer != null)
 288     {
 289       ListPeer l = (ListPeer) peer;
 290       l.setMultipleMode (multipleMode);
 291     }
 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 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 public void
 528 delItem(int index) throws IllegalArgumentException
 529 {
 530   remove(index);
 531 }
 532
 533 /*************************************************************************/
 534
 535 /**
 536   * Deletes the item at the specified index.
 537   *
 538   * @param index The index of the item to delete.
 539   *
 540   * @exception IllegalArgumentException If the index is not valid
 541   */
 542 public void
 543 remove(int index) throws IllegalArgumentException
 544 {
 545   items.removeElementAt (index);
 546   if (peer != null)
 547     {
 548       ListPeer l = (ListPeer) peer;
 549       l.delItems (index, index);
 550     }
 551 }
 552
 553 /*************************************************************************/
 554
 555 /**
 556   * Deletes all items in the specified index range.
 557   *
 558   * @param start The beginning index of the range to delete.
 559   * @param end The ending index of the range to delete.
 560   *
 561   * @exception IllegalArgumentException If the indexes are not valid
 562   *
 563   * @deprecated This method is deprecated for some unknown reason.
 564   */
 565 public synchronized void
 566 delItems(int start, int end) throws IllegalArgumentException
 567 {
 568   if ((start < 0) || (start >= items.size()))
 569     throw new IllegalArgumentException("Bad list start index value: " + start);
 570
 571   if ((start < 0) || (start >= items.size()))
 572     throw new IllegalArgumentException("Bad list start index value: " + start);
 573
 574   if (start > end)
 575     throw new IllegalArgumentException("Start is greater than end!");
 576
 577   // We must run the loop in reverse direction.
 578   for (int i = end; i >= start; --i)
 579     items.removeElementAt (i);
 580   if (peer != null)
 581     {
 582       ListPeer l = (ListPeer) peer;
 583       l.delItems (start, end);
 584     }
 585 }
 586
 587 /*************************************************************************/
 588
 589 /**
 590   * Deletes the first occurrence of the specified item from the list.
 591   *
 592   * @param item The item to delete.
 593   *
 594   * @exception IllegalArgumentException If the specified item does not exist.
 595   */
 596 public synchronized void
 597 remove(String item) throws IllegalArgumentException
 598 {
 599   int index = items.indexOf(item);
 600   if (index == -1)
 601     throw new IllegalArgumentException("List element to delete not found");
 602
 603   remove(index);
 604 }
 605
 606 /*************************************************************************/
 607
 608 /**
 609   * Deletes all of the items from the list.
 610   */
 611 public synchronized void
 612 removeAll()
 613 {
 614   items.clear();
 615   if (peer != null)
 616     {
 617       ListPeer l = (ListPeer) peer;
 618       l.removeAll ();
 619     }
 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   removeAll();
 633 }
 634
 635 /*************************************************************************/
 636
 637 /**
 638   * Replaces the item at the specified index with the specified item.
 639   *
 640   * @param item The new item value.
 641   * @param index The index of the item to replace.
 642   *
 643   * @exception IllegalArgumentException If the index is not valid.
 644   */
 645 public synchronized void
 646 replaceItem(String item, int index) throws IllegalArgumentException
 647 {
 648   remove(index);
 649   addItem(item, index);
 650 }
 651
 652 /*************************************************************************/
 653
 654 /**
 655   * Returns the index of the currently selected item.  -1 will be returned
 656   * if there are no selected rows or if there are multiple selected rows.
 657   *
 658   * @return The index of the selected row.
 659   */
 660 public synchronized int
 661 getSelectedIndex()
 662 {
 663   if (peer != null)
 664     {
 665       ListPeer l = (ListPeer) peer;
 666       selected = l.getSelectedIndexes ();
 667     }
 668
 669   if (selected == null || selected.length > 1)
 670     return -1;
 671   return selected[0];
 672 }
 673
 674 /*************************************************************************/
 675
 676 /**
 677   * Returns an array containing the indexes of the rows that are
 678   * currently selected.
 679   *
 680   * @return A list of indexes of selected rows.
 681   */
 682 public synchronized int[]
 683 getSelectedIndexes()
 684 {
 685   if (peer != null)
 686     {
 687       ListPeer l = (ListPeer) peer;
 688       selected = l.getSelectedIndexes ();
 689     }
 690   return selected;
 691 }
 692
 693 /*************************************************************************/
 694
 695 /**
 696   * Returns the item that is currently selected, or <code>null</code> if there
 697   * is no item selected.  FIXME: What happens if multiple items selected?
 698   *
 699   * @return The selected item, or <code>null</code> if there is no
 700   * selected item.
 701   */
 702 public synchronized String
 703 getSelectedItem()
 704 {
 705   int index = getSelectedIndex();
 706   if (index == -1)
 707     return(null);
 708
 709   return((String)items.elementAt(index));
 710 }
 711
 712 /*************************************************************************/
 713
 714 /**
 715   * Returns the list of items that are currently selected in this list.
 716   *
 717   * @return The list of currently selected items.
 718   */
 719 public synchronized String[]
 720 getSelectedItems()
 721 {
 722   int[] indexes = getSelectedIndexes();
 723   if (indexes == null)
 724     return(new String[0]);
 725
 726   String[] retvals = new String[indexes.length];
 727   if (retvals.length > 0)
 728     for (int i = 0 ; i < retvals.length; i++)
 729        retvals[i] = (String)items.elementAt(indexes[i]);
 730
 731   return(retvals);
 732 }
 733
 734 /*************************************************************************/
 735
 736 /**
 737   * Returns the list of items that are currently selected in this list as
 738   * an array of type <code>Object[]</code> instead of <code>String[]</code>.
 739   *
 740   * @return The list of currently selected items.
 741   */
 742 public synchronized Object[]
 743 getSelectedObjects()
 744 {
 745   int[] indexes = getSelectedIndexes();
 746   if (indexes == null)
 747     return(new Object[0]);
 748
 749   Object[] retvals = new Object[indexes.length];
 750   if (retvals.length > 0)
 751     for (int i = 0 ; i < retvals.length; i++)
 752        retvals[i] = items.elementAt(indexes[i]);
 753
 754   return(retvals);
 755 }
 756
 757 /*************************************************************************/
 758
 759 /**
 760   * Tests whether or not the specified index is selected.
 761   *
 762   * @param index The index to test.
 763   *
 764   * @return <code>true</code> if the index is selected, <code>false</code>
 765   * otherwise.
 766   */
 767 public boolean
 768 isIndexSelected(int index)
 769 {
 770   int[] indexes = getSelectedIndexes();
 771
 772   for (int i = 0; i < indexes.length; i++)
 773     if (indexes[i] == index)
 774       return(true);
 775
 776   return(false);
 777 }
 778
 779 /*************************************************************************/
 780
 781 /**
 782   * Tests whether or not the specified index is selected.
 783   *
 784   * @param index The index to test.
 785   *
 786   * @return <code>true</code> if the index is selected, <code>false</code>
 787   * otherwise.
 788   *
 789   * @deprecated This method is deprecated in favor of
 790   * <code>isIndexSelected(int)</code>.
 791   */
 792 public boolean
 793 isSelected(int index)
 794 {
 795   return(isIndexSelected(index));
 796 }
 797
 798 /*************************************************************************/
 799
 800 /**
 801   * This method ensures that the item at the specified index is visible.
 802   *
 803   * @exception IllegalArgumentException If the specified index is out of
 804   * range.
 805   */
 806 public synchronized void
 807 makeVisible(int index) throws IllegalArgumentException
 808 {
 809   if ((index < 0) || (index >= items.size()))
 810     throw new IllegalArgumentException("Bad list index: " + index);
 811
 812   visibleIndex = index;
 813   if (peer != null)
 814     {
 815       ListPeer l = (ListPeer) peer;
 816       l.makeVisible (index);
 817     }
 818 }
 819
 820 /*************************************************************************/
 821
 822 /**
 823   * Returns the index of the last item that was made visible via the
 824   * <code>makeVisible()</code> method.
 825   *
 826   * @return The index of the last item made visible via the
 827   * <code>makeVisible()</code> method.
 828   */
 829 public int
 830 getVisibleIndex()
 831 {
 832   return(visibleIndex);
 833 }
 834
 835 /*************************************************************************/
 836
 837 /**
 838   * Makes the item at the specified index selected.
 839   *
 840   * @param index The index of the item to select.
 841   */
 842 public synchronized void
 843 select(int index)
 844 {
 845   ListPeer lp = (ListPeer)getPeer();
 846   if (lp != null)
 847     lp.select(index);
 848 }
 849
 850 /*************************************************************************/
 851
 852 /**
 853   * Makes the item at the specified index not selected.
 854   *
 855   * @param index The index of the item to unselect.
 856   */
 857 public synchronized void
 858 deselect(int index)
 859 {
 860   ListPeer lp = (ListPeer)getPeer();
 861   if (lp != null)
 862     lp.deselect(index);
 863 }
 864
 865 /*************************************************************************/
 866
 867 /**
 868   * Notifies this object to create its native peer.
 869   */
 870 public void
 871 addNotify()
 872 {
 873   if (peer == null)
 874     peer = getToolkit ().createList (this);
 875   super.addNotify ();
 876 }
 877
 878 /*************************************************************************/
 879
 880 /**
 881   * Notifies this object to destroy its native peer.
 882   */
 883 public void
 884 removeNotify()
 885 {
 886   super.removeNotify();
 887 }
 888
 889 /*************************************************************************/
 890
 891 /**
 892   * Adds the specified <code>ActionListener</code> to the list of
 893   * registered listeners for this object.
 894   *
 895   * @param listener The listener to add.
 896   */
 897 public synchronized void
 898 addActionListener(ActionListener listener)
 899 {
 900   action_listeners = AWTEventMulticaster.add(action_listeners, listener);
 901 }
 902
 903 /*************************************************************************/
 904
 905 /**
 906   * Removes the specified <code>ActionListener</code> from the list of
 907   * registers listeners for this object.
 908   *
 909   * @param listener The listener to remove.
 910   */
 911 public synchronized void
 912 removeActionListener(ActionListener listener)
 913 {
 914   action_listeners = AWTEventMulticaster.remove(action_listeners, listener);
 915 }
 916
 917 /*************************************************************************/
 918
 919 /**
 920   * Adds the specified <code>ItemListener</code> to the list of
 921   * registered listeners for this object.
 922   *
 923   * @param listener The listener to add.
 924   */
 925 public synchronized void
 926 addItemListener(ItemListener listener)
 927 {
 928   item_listeners = AWTEventMulticaster.add(item_listeners, listener);
 929 }
 930
 931 /*************************************************************************/
 932
 933 /**
 934   * Removes the specified <code>ItemListener</code> from the list of
 935   * registers listeners for this object.
 936   *
 937   * @param listener The listener to remove.
 938   */
 939 public synchronized void
 940 removeItemListener(ItemListener listener)
 941 {
 942   item_listeners = AWTEventMulticaster.remove(item_listeners, listener);
 943 }
 944
 945 /*************************************************************************/
 946
 947 /**
 948   * Processes the specified event for this object.  If the event is an
 949   * instance of <code>ActionEvent</code> then the
 950   * <code>processActionEvent()</code> method is called.  Similarly, if the
 951   * even is an instance of <code>ItemEvent</code> then the
 952   * <code>processItemEvent()</code> method is called.  Otherwise the
 953   * superclass method is called to process this event.
 954   *
 955   * @param event The event to process.
 956   */
 957 protected void
 958 processEvent(AWTEvent event)
 959 {
 960   if (event instanceof ActionEvent)
 961     processActionEvent((ActionEvent)event);
 962   else if (event instanceof ItemEvent)
 963     processItemEvent((ItemEvent)event);
 964   else
 965     super.processEvent(event);
 966 }
 967
 968 /*************************************************************************/
 969
 970 /**
 971   * This method processes the specified event by dispatching it to any
 972   * registered listeners.  Note that this method will only get called if
 973   * action events are enabled.  This will happen automatically if any
 974   * listeners are added, or it can be done "manually" by calling
 975   * the <code>enableEvents()</code> method.
 976   *
 977   * @param event The event to process.
 978   */
 979 protected void
 980 processActionEvent(ActionEvent event)
 981 {
 982   if (action_listeners != null)
 983     action_listeners.actionPerformed(event);
 984 }
 985
 986 /*************************************************************************/
 987
 988 /**
 989   * This method processes the specified event by dispatching it to any
 990   * registered listeners.  Note that this method will only get called if
 991   * item events are enabled.  This will happen automatically if any
 992   * listeners are added, or it can be done "manually" by calling
 993   * the <code>enableEvents()</code> method.
 994   *
 995   * @param event The event to process.
 996   */
 997 protected void
 998 processItemEvent(ItemEvent event)
 999 {
1000   if (item_listeners != null)
1001     item_listeners.itemStateChanged(event);
1002 }
1003
1004 void
1005 dispatchEventImpl(AWTEvent e)
1006 {
1007   if (e.id <= ItemEvent.ITEM_LAST
1008       && e.id >= ItemEvent.ITEM_FIRST
1009       && (item_listeners != null
1010           || (eventMask & AWTEvent.ITEM_EVENT_MASK) != 0))
1011     processEvent(e);
1012   else if (e.id <= ActionEvent.ACTION_LAST
1013            && e.id >= ActionEvent.ACTION_FIRST
1014            && (action_listeners != null
1015                || (eventMask & AWTEvent.ACTION_EVENT_MASK) != 0))
1016     processEvent(e);
1017   else
1018     super.dispatchEventImpl(e);
1019 }
1020
1021 /*************************************************************************/
1022
1023 /**
1024   * Returns a debugging string for this object.
1025   *
1026   * @return A debugging string for this object.
1027   */
1028 protected String
1029 paramString()
1030 {
1031   return "multiple=" + multipleMode + ",rows=" + rows + super.paramString();
1032 }
1033
1034   /**
1035    * Returns an array of all the objects currently registered as FooListeners
1036    * upon this <code>List</code>. FooListeners are registered using the
1037    * addFooListener method.
1038    *
1039    * @exception ClassCastException If listenerType doesn't specify a class or
1040    * interface that implements java.util.EventListener.
1041    */
1042   public EventListener[] getListeners (Class listenerType)
1043   {
1044     if (listenerType == ActionListener.class)
1045       return AWTEventMulticaster.getListeners (action_listeners, listenerType);
1046
1047     if (listenerType == ItemListener.class)
1048       return AWTEventMulticaster.getListeners (item_listeners, listenerType);
1049
1050     return super.getListeners (listenerType);
1051   }
1052
1053   /**
1054    * Returns all action listeners registered to this object.
1055    */
1056   public ActionListener[] getActionListeners ()
1057   {
1058     return (ActionListener[]) getListeners (ActionListener.class);
1059   }
1060
1061   /**
1062    * Returns all action listeners registered to this object.
1063    */
1064   public ItemListener[] getItemListeners ()
1065   {
1066     return (ItemListener[]) getListeners (ItemListener.class);
1067   }
1068 } // class List