1 /*
   2  * Copyright (c) 1995, 2008, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 package java.awt;
  26 
  27 import java.util.*;
  28 import java.awt.peer.ChoicePeer;
  29 import java.awt.event.*;
  30 import java.util.EventListener;
  31 import java.io.ObjectOutputStream;
  32 import java.io.ObjectInputStream;
  33 import java.io.IOException;
  34 
  35 import javax.accessibility.*;
  36 
  37 import javax.tools.annotation.GenerateNativeHeader;
  38 
  39 /**
  40  * The <code>Choice</code> class presents a pop-up menu of choices.
  41  * The current choice is displayed as the title of the menu.
  42  * <p>
  43  * The following code example produces a pop-up menu:
  44  * <p>
  45  * <hr><blockquote><pre>
  46  * Choice ColorChooser = new Choice();
  47  * ColorChooser.add("Green");
  48  * ColorChooser.add("Red");
  49  * ColorChooser.add("Blue");
  50  * </pre></blockquote><hr>
  51  * <p>
  52  * After this choice menu has been added to a panel,
  53  * it appears as follows in its normal state:
  54  * <p>
  55  * <img src="doc-files/Choice-1.gif" alt="The following text describes the graphic"
  56  * ALIGN=center HSPACE=10 VSPACE=7>
  57  * <p>
  58  * In the picture, <code>"Green"</code> is the current choice.
  59  * Pushing the mouse button down on the object causes a menu to
  60  * appear with the current choice highlighted.
  61  * <p>
  62  * Some native platforms do not support arbitrary resizing of
  63  * <code>Choice</code> components and the behavior of
  64  * <code>setSize()/getSize()</code> is bound by
  65  * such limitations.
  66  * Native GUI <code>Choice</code> components' size are often bound by such
  67  * attributes as font size and length of items contained within
  68  * the <code>Choice</code>.
  69  * <p>
  70  * @author      Sami Shaio
  71  * @author      Arthur van Hoff
  72  * @since       JDK1.0
  73  */
  74 /* No native methods here, but the constants are needed in the supporting JNI code */
  75 @GenerateNativeHeader
  76 public class Choice extends Component implements ItemSelectable, Accessible {
  77     /**
  78      * The items for the <code>Choice</code>.
  79      * This can be a <code>null</code> value.
  80      * @serial
  81      * @see #add(String)
  82      * @see #addItem(String)
  83      * @see #getItem(int)
  84      * @see #getItemCount()
  85      * @see #insert(String, int)
  86      * @see #remove(String)
  87      */
  88     Vector pItems;
  89 
  90     /**
  91      * The index of the current choice for this <code>Choice</code>
  92      * or -1 if nothing is selected.
  93      * @serial
  94      * @see #getSelectedItem()
  95      * @see #select(int)
  96      */
  97     int selectedIndex = -1;
  98 
  99     transient ItemListener itemListener;
 100 
 101     private static final String base = "choice";
 102     private static int nameCounter = 0;
 103 
 104     /*
 105      * JDK 1.1 serialVersionUID
 106      */
 107     private static final long serialVersionUID = -4075310674757313071L;
 108 
 109     static {
 110         /* ensure that the necessary native libraries are loaded */
 111         Toolkit.loadLibraries();
 112         /* initialize JNI field and method ids */
 113         if (!GraphicsEnvironment.isHeadless()) {
 114             initIDs();
 115         }
 116     }
 117     
 118     /**
 119      * Creates a new choice menu. The menu initially has no items in it.
 120      * <p>
 121      * By default, the first item added to the choice menu becomes the
 122      * selected item, until a different selection is made by the user
 123      * by calling one of the <code>select</code> methods.
 124      * @exception HeadlessException if GraphicsEnvironment.isHeadless()
 125      * returns true
 126      * @see       java.awt.GraphicsEnvironment#isHeadless
 127      * @see       #select(int)
 128      * @see       #select(java.lang.String)
 129      */
 130     public Choice() throws HeadlessException {
 131         GraphicsEnvironment.checkHeadless();
 132         pItems = new Vector();
 133     }
 134 
 135     /**
 136      * Constructs a name for this component.  Called by
 137      * <code>getName</code> when the name is <code>null</code>.
 138      */
 139     String constructComponentName() {
 140         synchronized (Choice.class) {
 141             return base + nameCounter++;
 142         }
 143     }
 144 
 145     /**
 146      * Creates the <code>Choice</code>'s peer.  This peer allows us
 147      * to change the look
 148      * of the <code>Choice</code> without changing its functionality.
 149      * @see     java.awt.Toolkit#createChoice(java.awt.Choice)
 150      * @see     java.awt.Component#getToolkit()
 151      */
 152     public void addNotify() {
 153         synchronized (getTreeLock()) {
 154             if (peer == null)
 155                 peer = getToolkit().createChoice(this);
 156             super.addNotify();
 157         }
 158     }
 159 
 160     /**
 161      * Returns the number of items in this <code>Choice</code> menu.
 162      * @return the number of items in this <code>Choice</code> menu
 163      * @see     #getItem
 164      * @since   JDK1.1
 165      */
 166     public int getItemCount() {
 167         return countItems();
 168     }
 169 
 170     /**
 171      * @deprecated As of JDK version 1.1,
 172      * replaced by <code>getItemCount()</code>.
 173      */
 174     @Deprecated
 175     public int countItems() {
 176         return pItems.size();
 177     }
 178 
 179     /**
 180      * Gets the string at the specified index in this
 181      * <code>Choice</code> menu.
 182      * @param      index the index at which to begin
 183      * @see        #getItemCount
 184      */
 185     public String getItem(int index) {
 186         return getItemImpl(index);
 187     }
 188 
 189     /*
 190      * This is called by the native code, so client code can't
 191      * be called on the toolkit thread.
 192      */
 193     final String getItemImpl(int index) {
 194         return (String)pItems.elementAt(index);
 195     }
 196 
 197     /**
 198      * Adds an item to this <code>Choice</code> menu.
 199      * @param      item    the item to be added
 200      * @exception  NullPointerException   if the item's value is
 201      *                  <code>null</code>
 202      * @since      JDK1.1
 203      */
 204     public void add(String item) {
 205         addItem(item);
 206     }
 207 
 208     /**
 209      * Obsolete as of Java 2 platform v1.1.  Please use the
 210      * <code>add</code> method instead.
 211      * <p>
 212      * Adds an item to this <code>Choice</code> menu.
 213      * @param item the item to be added
 214      * @exception NullPointerException if the item's value is equal to
 215      *          <code>null</code>
 216      */
 217     public void addItem(String item) {
 218         synchronized (this) {
 219             insertNoInvalidate(item, pItems.size());
 220         }
 221 
 222         // This could change the preferred size of the Component.
 223         invalidateIfValid();
 224     }
 225 
 226     /**
 227      * Inserts an item to this <code>Choice</code>,
 228      * but does not invalidate the <code>Choice</code>.
 229      * Client methods must provide their own synchronization before
 230      * invoking this method.
 231      * @param item the item to be added
 232      * @param index the new item position
 233      * @exception NullPointerException if the item's value is equal to
 234      *          <code>null</code>
 235      */
 236     private void insertNoInvalidate(String item, int index) {
 237         if (item == null) {
 238             throw new
 239                 NullPointerException("cannot add null item to Choice");
 240         }
 241         pItems.insertElementAt(item, index);
 242         ChoicePeer peer = (ChoicePeer)this.peer;
 243         if (peer != null) {
 244             peer.add(item, index);
 245         }
 246         // no selection or selection shifted up
 247         if (selectedIndex < 0 || selectedIndex >= index) {
 248             select(0);
 249         }
 250     }
 251 
 252 
 253     /**
 254      * Inserts the item into this choice at the specified position.
 255      * Existing items at an index greater than or equal to
 256      * <code>index</code> are shifted up by one to accommodate
 257      * the new item.  If <code>index</code> is greater than or
 258      * equal to the number of items in this choice,
 259      * <code>item</code> is added to the end of this choice.
 260      * <p>
 261      * If the item is the first one being added to the choice,
 262      * then the item becomes selected.  Otherwise, if the
 263      * selected item was one of the items shifted, the first
 264      * item in the choice becomes the selected item.  If the
 265      * selected item was no among those shifted, it remains
 266      * the selected item.
 267      * @param item the non-<code>null</code> item to be inserted
 268      * @param index the position at which the item should be inserted
 269      * @exception IllegalArgumentException if index is less than 0
 270      */
 271     public void insert(String item, int index) {
 272         synchronized (this) {
 273             if (index < 0) {
 274                 throw new IllegalArgumentException("index less than zero.");
 275             }
 276             /* if the index greater than item count, add item to the end */
 277             index = Math.min(index, pItems.size());
 278 
 279             insertNoInvalidate(item, index);
 280         }
 281 
 282         // This could change the preferred size of the Component.
 283         invalidateIfValid();
 284     }
 285 
 286     /**
 287      * Removes the first occurrence of <code>item</code>
 288      * from the <code>Choice</code> menu.  If the item
 289      * being removed is the currently selected item,
 290      * then the first item in the choice becomes the
 291      * selected item.  Otherwise, the currently selected
 292      * item remains selected (and the selected index is
 293      * updated accordingly).
 294      * @param      item  the item to remove from this <code>Choice</code> menu
 295      * @exception  IllegalArgumentException  if the item doesn't
 296      *                     exist in the choice menu
 297      * @since      JDK1.1
 298      */
 299     public void remove(String item) {
 300         synchronized (this) {
 301             int index = pItems.indexOf(item);
 302             if (index < 0) {
 303                 throw new IllegalArgumentException("item " + item +
 304                                                    " not found in choice");
 305             } else {
 306                 removeNoInvalidate(index);
 307             }
 308         }
 309 
 310         // This could change the preferred size of the Component.
 311         invalidateIfValid();
 312     }
 313 
 314     /**
 315      * Removes an item from the choice menu
 316      * at the specified position.  If the item
 317      * being removed is the currently selected item,
 318      * then the first item in the choice becomes the
 319      * selected item.  Otherwise, the currently selected
 320      * item remains selected (and the selected index is
 321      * updated accordingly).
 322      * @param      position the position of the item
 323      * @throws IndexOutOfBoundsException if the specified
 324      *          position is out of bounds
 325      * @since      JDK1.1
 326      */
 327     public void remove(int position) {
 328         synchronized (this) {
 329             removeNoInvalidate(position);
 330         }
 331 
 332         // This could change the preferred size of the Component.
 333         invalidateIfValid();
 334     }
 335 
 336     /**
 337      * Removes an item from the <code>Choice</code> at the
 338      * specified position, but does not invalidate the <code>Choice</code>.
 339      * Client methods must provide their
 340      * own synchronization before invoking this method.
 341      * @param      position   the position of the item
 342      */
 343     private void removeNoInvalidate(int position) {
 344         pItems.removeElementAt(position);
 345         ChoicePeer peer = (ChoicePeer)this.peer;
 346         if (peer != null) {
 347             peer.remove(position);
 348         }
 349         /* Adjust selectedIndex if selected item was removed. */
 350         if (pItems.size() == 0) {
 351             selectedIndex = -1;
 352         } else if (selectedIndex == position) {
 353             select(0);
 354         } else if (selectedIndex > position) {
 355             select(selectedIndex-1);
 356         }
 357     }
 358 
 359 
 360     /**
 361      * Removes all items from the choice menu.
 362      * @see       #remove
 363      * @since     JDK1.1
 364      */
 365     public void removeAll() {
 366         synchronized (this) {
 367             if (peer != null) {
 368                 ((ChoicePeer)peer).removeAll();
 369             }
 370             pItems.removeAllElements();
 371             selectedIndex = -1;
 372         }
 373 
 374         // This could change the preferred size of the Component.
 375         invalidateIfValid();
 376     }
 377 
 378     /**
 379      * Gets a representation of the current choice as a string.
 380      * @return    a string representation of the currently
 381      *                     selected item in this choice menu
 382      * @see       #getSelectedIndex
 383      */
 384     public synchronized String getSelectedItem() {
 385         return (selectedIndex >= 0) ? getItem(selectedIndex) : null;
 386     }
 387 
 388     /**
 389      * Returns an array (length 1) containing the currently selected
 390      * item.  If this choice has no items, returns <code>null</code>.
 391      * @see ItemSelectable
 392      */
 393     public synchronized Object[] getSelectedObjects() {
 394         if (selectedIndex >= 0) {
 395             Object[] items = new Object[1];
 396             items[0] = getItem(selectedIndex);
 397             return items;
 398         }
 399         return null;
 400     }
 401 
 402     /**
 403      * Returns the index of the currently selected item.
 404      * If nothing is selected, returns -1.
 405      *
 406      * @return the index of the currently selected item, or -1 if nothing
 407      *  is currently selected
 408      * @see #getSelectedItem
 409      */
 410     public int getSelectedIndex() {
 411         return selectedIndex;
 412     }
 413 
 414     /**
 415      * Sets the selected item in this <code>Choice</code> menu to be the
 416      * item at the specified position.
 417      *
 418      * <p>Note that this method should be primarily used to
 419      * initially select an item in this component.
 420      * Programmatically calling this method will <i>not</i> trigger
 421      * an <code>ItemEvent</code>.  The only way to trigger an
 422      * <code>ItemEvent</code> is by user interaction.
 423      *
 424      * @param      pos      the positon of the selected item
 425      * @exception  IllegalArgumentException if the specified
 426      *                            position is greater than the
 427      *                            number of items or less than zero
 428      * @see        #getSelectedItem
 429      * @see        #getSelectedIndex
 430      */
 431     public synchronized void select(int pos) {
 432         if ((pos >= pItems.size()) || (pos < 0)) {
 433             throw new IllegalArgumentException("illegal Choice item position: " + pos);
 434         }
 435         if (pItems.size() > 0) {
 436             selectedIndex = pos;
 437             ChoicePeer peer = (ChoicePeer)this.peer;
 438             if (peer != null) {
 439                 peer.select(pos);
 440             }
 441         }
 442     }
 443 
 444     /**
 445      * Sets the selected item in this <code>Choice</code> menu
 446      * to be the item whose name is equal to the specified string.
 447      * If more than one item matches (is equal to) the specified string,
 448      * the one with the smallest index is selected.
 449      *
 450      * <p>Note that this method should be primarily used to
 451      * initially select an item in this component.
 452      * Programmatically calling this method will <i>not</i> trigger
 453      * an <code>ItemEvent</code>.  The only way to trigger an
 454      * <code>ItemEvent</code> is by user interaction.
 455      *
 456      * @param       str     the specified string
 457      * @see         #getSelectedItem
 458      * @see         #getSelectedIndex
 459      */
 460     public synchronized void select(String str) {
 461         int index = pItems.indexOf(str);
 462         if (index >= 0) {
 463             select(index);
 464         }
 465     }
 466 
 467     /**
 468      * Adds the specified item listener to receive item events from
 469      * this <code>Choice</code> menu.  Item events are sent in response
 470      * to user input, but not in response to calls to <code>select</code>.
 471      * If l is <code>null</code>, no exception is thrown and no action
 472      * is performed.
 473      * <p>Refer to <a href="doc-files/AWTThreadIssues.html#ListenersThreads"
 474      * >AWT Threading Issues</a> for details on AWT's threading model.
 475      * @param         l    the item listener
 476      * @see           #removeItemListener
 477      * @see           #getItemListeners
 478      * @see           #select
 479      * @see           java.awt.event.ItemEvent
 480      * @see           java.awt.event.ItemListener
 481      * @since         JDK1.1
 482      */
 483     public synchronized void addItemListener(ItemListener l) {
 484         if (l == null) {
 485            return;
 486         }
 487         itemListener = AWTEventMulticaster.add(itemListener, l);
 488         newEventsOnly = true;
 489     }
 490 
 491     /**
 492      * Removes the specified item listener so that it no longer receives
 493      * item events from this <code>Choice</code> menu.
 494      * If l is <code>null</code>, no exception is thrown and no
 495      * action is performed.
 496      * <p>Refer to <a href="doc-files/AWTThreadIssues.html#ListenersThreads"
 497      * >AWT Threading Issues</a> for details on AWT's threading model.
 498      * @param         l    the item listener
 499      * @see           #addItemListener
 500      * @see           #getItemListeners
 501      * @see           java.awt.event.ItemEvent
 502      * @see           java.awt.event.ItemListener
 503      * @since         JDK1.1
 504      */
 505     public synchronized void removeItemListener(ItemListener l) {
 506         if (l == null) {
 507             return;
 508         }
 509         itemListener = AWTEventMulticaster.remove(itemListener, l);
 510     }
 511 
 512     /**
 513      * Returns an array of all the item listeners
 514      * registered on this choice.
 515      *
 516      * @return all of this choice's <code>ItemListener</code>s
 517      *         or an empty array if no item
 518      *         listeners are currently registered
 519      *
 520      * @see           #addItemListener
 521      * @see           #removeItemListener
 522      * @see           java.awt.event.ItemEvent
 523      * @see           java.awt.event.ItemListener
 524      * @since 1.4
 525      */
 526     public synchronized ItemListener[] getItemListeners() {
 527         return (ItemListener[])(getListeners(ItemListener.class));
 528     }
 529 
 530     /**
 531      * Returns an array of all the objects currently registered
 532      * as <code><em>Foo</em>Listener</code>s
 533      * upon this <code>Choice</code>.
 534      * <code><em>Foo</em>Listener</code>s are registered using the
 535      * <code>add<em>Foo</em>Listener</code> method.
 536      *
 537      * <p>
 538      * You can specify the <code>listenerType</code> argument
 539      * with a class literal, such as
 540      * <code><em>Foo</em>Listener.class</code>.
 541      * For example, you can query a
 542      * <code>Choice</code> <code>c</code>
 543      * for its item listeners with the following code:
 544      *
 545      * <pre>ItemListener[] ils = (ItemListener[])(c.getListeners(ItemListener.class));</pre>
 546      *
 547      * If no such listeners exist, this method returns an empty array.
 548      *
 549      * @param listenerType the type of listeners requested; this parameter
 550      *          should specify an interface that descends from
 551      *          <code>java.util.EventListener</code>
 552      * @return an array of all objects registered as
 553      *          <code><em>Foo</em>Listener</code>s on this choice,
 554      *          or an empty array if no such
 555      *          listeners have been added
 556      * @exception ClassCastException if <code>listenerType</code>
 557      *          doesn't specify a class or interface that implements
 558      *          <code>java.util.EventListener</code>
 559      *
 560      * @see #getItemListeners
 561      * @since 1.3
 562      */
 563     public <T extends EventListener> T[] getListeners(Class<T> listenerType) {
 564         EventListener l = null;
 565         if  (listenerType == ItemListener.class) {
 566             l = itemListener;
 567         } else {
 568             return super.getListeners(listenerType);
 569         }
 570         return AWTEventMulticaster.getListeners(l, listenerType);
 571     }
 572 
 573     // REMIND: remove when filtering is done at lower level
 574     boolean eventEnabled(AWTEvent e) {
 575         if (e.id == ItemEvent.ITEM_STATE_CHANGED) {
 576             if ((eventMask & AWTEvent.ITEM_EVENT_MASK) != 0 ||
 577                 itemListener != null) {
 578                 return true;
 579             }
 580             return false;
 581         }
 582         return super.eventEnabled(e);
 583     }
 584 
 585     /**
 586      * Processes events on this choice. If the event is an
 587      * instance of <code>ItemEvent</code>, it invokes the
 588      * <code>processItemEvent</code> method. Otherwise, it calls its
 589      * superclass's <code>processEvent</code> method.
 590      * <p>Note that if the event parameter is <code>null</code>
 591      * the behavior is unspecified and may result in an
 592      * exception.
 593      *
 594      * @param      e the event
 595      * @see        java.awt.event.ItemEvent
 596      * @see        #processItemEvent
 597      * @since      JDK1.1
 598      */
 599     protected void processEvent(AWTEvent e) {
 600         if (e instanceof ItemEvent) {
 601             processItemEvent((ItemEvent)e);
 602             return;
 603         }
 604         super.processEvent(e);
 605     }
 606 
 607     /**
 608      * Processes item events occurring on this <code>Choice</code>
 609      * menu by dispatching them to any registered
 610      * <code>ItemListener</code> objects.
 611      * <p>
 612      * This method is not called unless item events are
 613      * enabled for this component. Item events are enabled
 614      * when one of the following occurs:
 615      * <p><ul>
 616      * <li>An <code>ItemListener</code> object is registered
 617      * via <code>addItemListener</code>.
 618      * <li>Item events are enabled via <code>enableEvents</code>.
 619      * </ul>
 620      * <p>Note that if the event parameter is <code>null</code>
 621      * the behavior is unspecified and may result in an
 622      * exception.
 623      *
 624      * @param       e the item event
 625      * @see         java.awt.event.ItemEvent
 626      * @see         java.awt.event.ItemListener
 627      * @see         #addItemListener(ItemListener)
 628      * @see         java.awt.Component#enableEvents
 629      * @since       JDK1.1
 630      */
 631     protected void processItemEvent(ItemEvent e) {
 632         ItemListener listener = itemListener;
 633         if (listener != null) {
 634             listener.itemStateChanged(e);
 635         }
 636     }
 637 
 638     /**
 639      * Returns a string representing the state of this <code>Choice</code>
 640      * menu. This method is intended to be used only for debugging purposes,
 641      * and the content and format of the returned string may vary between
 642      * implementations. The returned string may be empty but may not be
 643      * <code>null</code>.
 644      *
 645      * @return    the parameter string of this <code>Choice</code> menu
 646      */
 647     protected String paramString() {
 648         return super.paramString() + ",current=" + getSelectedItem();
 649     }
 650 
 651 
 652     /* Serialization support.
 653      */
 654 
 655     /*
 656      * Choice Serial Data Version.
 657      * @serial
 658      */
 659     private int choiceSerializedDataVersion = 1;
 660 
 661     /**
 662      * Writes default serializable fields to stream.  Writes
 663      * a list of serializable <code>ItemListeners</code>
 664      * as optional data. The non-serializable
 665      * <code>ItemListeners</code> are detected and
 666      * no attempt is made to serialize them.
 667      *
 668      * @param s the <code>ObjectOutputStream</code> to write
 669      * @serialData <code>null</code> terminated sequence of 0
 670      *   or more pairs; the pair consists of a <code>String</code>
 671      *   and an <code>Object</code>; the <code>String</code> indicates
 672      *   the type of object and is one of the following:
 673      *   <code>itemListenerK</code> indicating an
 674      *     <code>ItemListener</code> object
 675      *
 676      * @see AWTEventMulticaster#save(ObjectOutputStream, String, EventListener)
 677      * @see java.awt.Component#itemListenerK
 678      * @see #readObject(ObjectInputStream)
 679      */
 680     private void writeObject(ObjectOutputStream s)
 681       throws java.io.IOException
 682     {
 683       s.defaultWriteObject();
 684 
 685       AWTEventMulticaster.save(s, itemListenerK, itemListener);
 686       s.writeObject(null);
 687     }
 688 
 689     /**
 690      * Reads the <code>ObjectInputStream</code> and if it
 691      * isn't <code>null</code> adds a listener to receive
 692      * item events fired by the <code>Choice</code> item.
 693      * Unrecognized keys or values will be ignored.
 694      *
 695      * @param s the <code>ObjectInputStream</code> to read
 696      * @exception HeadlessException if
 697      *   <code>GraphicsEnvironment.isHeadless</code> returns
 698      *   <code>true</code>
 699      * @serial
 700      * @see #removeItemListener(ItemListener)
 701      * @see #addItemListener(ItemListener)
 702      * @see java.awt.GraphicsEnvironment#isHeadless
 703      * @see #writeObject(ObjectOutputStream)
 704      */
 705     private void readObject(ObjectInputStream s)
 706       throws ClassNotFoundException, IOException, HeadlessException
 707     {
 708       GraphicsEnvironment.checkHeadless();
 709       s.defaultReadObject();
 710 
 711       Object keyOrNull;
 712       while(null != (keyOrNull = s.readObject())) {
 713         String key = ((String)keyOrNull).intern();
 714 
 715         if (itemListenerK == key)
 716           addItemListener((ItemListener)(s.readObject()));
 717 
 718         else // skip value for unrecognized key
 719           s.readObject();
 720       }
 721     }
 722 
 723     /**
 724      * Initialize JNI field and method IDs
 725      */
 726     private static native void initIDs();
 727 
 728 /////////////////
 729 // Accessibility support
 730 ////////////////
 731 
 732 
 733     /**
 734      * Gets the <code>AccessibleContext</code> associated with this
 735      * <code>Choice</code>. For <code>Choice</code> components,
 736      * the <code>AccessibleContext</code> takes the form of an
 737      * <code>AccessibleAWTChoice</code>. A new <code>AccessibleAWTChoice</code>
 738      * instance is created if necessary.
 739      *
 740      * @return an <code>AccessibleAWTChoice</code> that serves as the
 741      *         <code>AccessibleContext</code> of this <code>Choice</code>
 742      * @since 1.3
 743      */
 744     public AccessibleContext getAccessibleContext() {
 745         if (accessibleContext == null) {
 746             accessibleContext = new AccessibleAWTChoice();
 747         }
 748         return accessibleContext;
 749     }
 750 
 751     /**
 752      * This class implements accessibility support for the
 753      * <code>Choice</code> class.  It provides an implementation of the
 754      * Java Accessibility API appropriate to choice user-interface elements.
 755      * @since 1.3
 756      */
 757     protected class AccessibleAWTChoice extends AccessibleAWTComponent
 758         implements AccessibleAction
 759     {
 760         /*
 761          * JDK 1.3 serialVersionUID
 762          */
 763         private static final long serialVersionUID = 7175603582428509322L;
 764 
 765         public AccessibleAWTChoice() {
 766             super();
 767         }
 768 
 769         /**
 770          * Get the AccessibleAction associated with this object.  In the
 771          * implementation of the Java Accessibility API for this class,
 772          * return this object, which is responsible for implementing the
 773          * AccessibleAction interface on behalf of itself.
 774          *
 775          * @return this object
 776          * @see AccessibleAction
 777          */
 778         public AccessibleAction getAccessibleAction() {
 779             return this;
 780         }
 781 
 782         /**
 783          * Get the role of this object.
 784          *
 785          * @return an instance of AccessibleRole describing the role of the
 786          * object
 787          * @see AccessibleRole
 788          */
 789         public AccessibleRole getAccessibleRole() {
 790             return AccessibleRole.COMBO_BOX;
 791         }
 792 
 793         /**
 794          * Returns the number of accessible actions available in this object
 795          * If there are more than one, the first one is considered the "default"
 796          * action of the object.
 797          *
 798          * @return the zero-based number of Actions in this object
 799          */
 800         public int getAccessibleActionCount() {
 801             return 0;  //  To be fully implemented in a future release
 802         }
 803 
 804         /**
 805          * Returns a description of the specified action of the object.
 806          *
 807          * @param i zero-based index of the actions
 808          * @return a String description of the action
 809          * @see #getAccessibleActionCount
 810          */
 811         public String getAccessibleActionDescription(int i) {
 812             return null;  //  To be fully implemented in a future release
 813         }
 814 
 815         /**
 816          * Perform the specified Action on the object
 817          *
 818          * @param i zero-based index of actions
 819          * @return true if the action was performed; otherwise false.
 820          * @see #getAccessibleActionCount
 821          */
 822         public boolean doAccessibleAction(int i) {
 823             return false;  //  To be fully implemented in a future release
 824         }
 825 
 826     } // inner class AccessibleAWTChoice
 827 
 828 }
--- EOF ---