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