001: /*
002: * Copyright 1995-2006 Sun Microsystems, Inc. All Rights Reserved.
003: * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
004: *
005: * This code is free software; you can redistribute it and/or modify it
006: * under the terms of the GNU General Public License version 2 only, as
007: * published by the Free Software Foundation. Sun designates this
008: * particular file as subject to the "Classpath" exception as provided
009: * by Sun in the LICENSE file that accompanied this code.
010: *
011: * This code is distributed in the hope that it will be useful, but WITHOUT
012: * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
013: * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
014: * version 2 for more details (a copy is included in the LICENSE file that
015: * accompanied this code).
016: *
017: * You should have received a copy of the GNU General Public License version
018: * 2 along with this work; if not, write to the Free Software Foundation,
019: * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
020: *
021: * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
022: * CA 95054 USA or visit www.sun.com if you need additional information or
023: * have any questions.
024: */
025: package java.awt;
026:
027: import java.util.*;
028: import java.awt.peer.ChoicePeer;
029: import java.awt.event.*;
030: import java.util.EventListener;
031: import java.io.ObjectOutputStream;
032: import java.io.ObjectInputStream;
033: import java.io.IOException;
034:
035: import javax.accessibility.*;
036:
037: /**
038: * The <code>Choice</code> class presents a pop-up menu of choices.
039: * The current choice is displayed as the title of the menu.
040: * <p>
041: * The following code example produces a pop-up menu:
042: * <p>
043: * <hr><blockquote><pre>
044: * Choice ColorChooser = new Choice();
045: * ColorChooser.add("Green");
046: * ColorChooser.add("Red");
047: * ColorChooser.add("Blue");
048: * </pre></blockquote><hr>
049: * <p>
050: * After this choice menu has been added to a panel,
051: * it appears as follows in its normal state:
052: * <p>
053: * <img src="doc-files/Choice-1.gif" alt="The following text describes the graphic"
054: * ALIGN=center HSPACE=10 VSPACE=7>
055: * <p>
056: * In the picture, <code>"Green"</code> is the current choice.
057: * Pushing the mouse button down on the object causes a menu to
058: * appear with the current choice highlighted.
059: * <p>
060: * Some native platforms do not support arbitrary resizing of
061: * <code>Choice</code> components and the behavior of
062: * <code>setSize()/getSize()</code> is bound by
063: * such limitations.
064: * Native GUI <code>Choice</code> components' size are often bound by such
065: * attributes as font size and length of items contained within
066: * the <code>Choice</code>.
067: * <p>
068: * @version 1.100 05/05/07
069: * @author Sami Shaio
070: * @author Arthur van Hoff
071: * @since JDK1.0
072: */
073: public class Choice extends Component implements ItemSelectable,
074: Accessible {
075: /**
076: * The items for the <code>Choice</code>.
077: * This can be a <code>null</code> value.
078: * @serial
079: * @see #add(String)
080: * @see #addItem(String)
081: * @see #getItem(int)
082: * @see #getItemCount()
083: * @see #insert(String, int)
084: * @see #remove(String)
085: */
086: Vector pItems;
087:
088: /**
089: * The index of the current choice for this <code>Choice</code>
090: * or -1 if nothing is selected.
091: * @serial
092: * @see #getSelectedItem()
093: * @see #select(int)
094: */
095: int selectedIndex = -1;
096:
097: transient ItemListener itemListener;
098:
099: private static final String base = "choice";
100: private static int nameCounter = 0;
101:
102: /*
103: * JDK 1.1 serialVersionUID
104: */
105: private static final long serialVersionUID = -4075310674757313071L;
106:
107: /**
108: * Creates a new choice menu. The menu initially has no items in it.
109: * <p>
110: * By default, the first item added to the choice menu becomes the
111: * selected item, until a different selection is made by the user
112: * by calling one of the <code>select</code> methods.
113: * @exception HeadlessException if GraphicsEnvironment.isHeadless()
114: * returns true
115: * @see java.awt.GraphicsEnvironment#isHeadless
116: * @see #select(int)
117: * @see #select(java.lang.String)
118: */
119: public Choice() throws HeadlessException {
120: GraphicsEnvironment.checkHeadless();
121: pItems = new Vector();
122: }
123:
124: /**
125: * Constructs a name for this component. Called by
126: * <code>getName</code> when the name is <code>null</code>.
127: */
128: String constructComponentName() {
129: synchronized (Choice.class) {
130: return base + nameCounter++;
131: }
132: }
133:
134: /**
135: * Creates the <code>Choice</code>'s peer. This peer allows us
136: * to change the look
137: * of the <code>Choice</code> without changing its functionality.
138: * @see java.awt.Toolkit#createChoice(java.awt.Choice)
139: * @see java.awt.Component#getToolkit()
140: */
141: public void addNotify() {
142: synchronized (getTreeLock()) {
143: if (peer == null)
144: peer = getToolkit().createChoice(this );
145: super .addNotify();
146: }
147: }
148:
149: /**
150: * Returns the number of items in this <code>Choice</code> menu.
151: * @return the number of items in this <code>Choice</code> menu
152: * @see #getItem
153: * @since JDK1.1
154: */
155: public int getItemCount() {
156: return countItems();
157: }
158:
159: /**
160: * @deprecated As of JDK version 1.1,
161: * replaced by <code>getItemCount()</code>.
162: */
163: @Deprecated
164: public int countItems() {
165: return pItems.size();
166: }
167:
168: /**
169: * Gets the string at the specified index in this
170: * <code>Choice</code> menu.
171: * @param index the index at which to begin
172: * @see #getItemCount
173: */
174: public String getItem(int index) {
175: return getItemImpl(index);
176: }
177:
178: /*
179: * This is called by the native code, so client code can't
180: * be called on the toolkit thread.
181: */
182: final String getItemImpl(int index) {
183: return (String) pItems.elementAt(index);
184: }
185:
186: /**
187: * Adds an item to this <code>Choice</code> menu.
188: * @param item the item to be added
189: * @exception NullPointerException if the item's value is
190: * <code>null</code>
191: * @since JDK1.1
192: */
193: public void add(String item) {
194: addItem(item);
195: }
196:
197: /**
198: * Obsolete as of Java 2 platform v1.1. Please use the
199: * <code>add</code> method instead.
200: * <p>
201: * Adds an item to this <code>Choice</code> menu.
202: * @param item the item to be added
203: * @exception NullPointerException if the item's value is equal to
204: * <code>null</code>
205: */
206: public void addItem(String item) {
207: synchronized (this ) {
208: insertNoInvalidate(item, pItems.size());
209: }
210:
211: // This could change the preferred size of the Component.
212: if (valid) {
213: invalidate();
214: }
215: }
216:
217: /**
218: * Inserts an item to this <code>Choice</code>,
219: * but does not invalidate the <code>Choice</code>.
220: * Client methods must provide their own synchronization before
221: * invoking this method.
222: * @param item the item to be added
223: * @param index the new item position
224: * @exception NullPointerException if the item's value is equal to
225: * <code>null</code>
226: */
227: private void insertNoInvalidate(String item, int index) {
228: if (item == null) {
229: throw new NullPointerException(
230: "cannot add null item to Choice");
231: }
232: pItems.insertElementAt(item, index);
233: ChoicePeer peer = (ChoicePeer) this .peer;
234: if (peer != null) {
235: peer.addItem(item, index);
236: }
237: // no selection or selection shifted up
238: if (selectedIndex < 0 || selectedIndex >= index) {
239: select(0);
240: }
241: }
242:
243: /**
244: * Inserts the item into this choice at the specified position.
245: * Existing items at an index greater than or equal to
246: * <code>index</code> are shifted up by one to accommodate
247: * the new item. If <code>index</code> is greater than or
248: * equal to the number of items in this choice,
249: * <code>item</code> is added to the end of this choice.
250: * <p>
251: * If the item is the first one being added to the choice,
252: * then the item becomes selected. Otherwise, if the
253: * selected item was one of the items shifted, the first
254: * item in the choice becomes the selected item. If the
255: * selected item was no among those shifted, it remains
256: * the selected item.
257: * @param item the non-<code>null</code> item to be inserted
258: * @param index the position at which the item should be inserted
259: * @exception IllegalArgumentException if index is less than 0
260: */
261: public void insert(String item, int index) {
262: synchronized (this ) {
263: if (index < 0) {
264: throw new IllegalArgumentException(
265: "index less than zero.");
266: }
267: /* if the index greater than item count, add item to the end */
268: index = Math.min(index, pItems.size());
269:
270: insertNoInvalidate(item, index);
271: }
272:
273: // This could change the preferred size of the Component.
274: if (valid) {
275: invalidate();
276: }
277: }
278:
279: /**
280: * Removes the first occurrence of <code>item</code>
281: * from the <code>Choice</code> menu. If the item
282: * being removed is the currently selected item,
283: * then the first item in the choice becomes the
284: * selected item. Otherwise, the currently selected
285: * item remains selected (and the selected index is
286: * updated accordingly).
287: * @param item the item to remove from this <code>Choice</code> menu
288: * @exception IllegalArgumentException if the item doesn't
289: * exist in the choice menu
290: * @since JDK1.1
291: */
292: public void remove(String item) {
293: synchronized (this ) {
294: int index = pItems.indexOf(item);
295: if (index < 0) {
296: throw new IllegalArgumentException("item " + item
297: + " not found in choice");
298: } else {
299: removeNoInvalidate(index);
300: }
301: }
302:
303: // This could change the preferred size of the Component.
304: if (valid) {
305: invalidate();
306: }
307: }
308:
309: /**
310: * Removes an item from the choice menu
311: * at the specified position. If the item
312: * being removed is the currently selected item,
313: * then the first item in the choice becomes the
314: * selected item. Otherwise, the currently selected
315: * item remains selected (and the selected index is
316: * updated accordingly).
317: * @param position the position of the item
318: * @throws IndexOutOfBoundsException if the specified
319: * position is out of bounds
320: * @since JDK1.1
321: */
322: public void remove(int position) {
323: synchronized (this ) {
324: removeNoInvalidate(position);
325: }
326:
327: // This could change the preferred size of the Component.
328: if (valid) {
329: invalidate();
330: }
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: * Removes all items from the choice menu.
358: * @see #remove
359: * @since JDK1.1
360: */
361: public void removeAll() {
362: synchronized (this ) {
363: if (peer != null) {
364: ((ChoicePeer) peer).removeAll();
365: }
366: pItems.removeAllElements();
367: selectedIndex = -1;
368: }
369:
370: // This could change the preferred size of the Component.
371: if (valid) {
372: invalidate();
373: }
374: }
375:
376: /**
377: * Gets a representation of the current choice as a string.
378: * @return a string representation of the currently
379: * selected item in this choice menu
380: * @see #getSelectedIndex
381: */
382: public synchronized String getSelectedItem() {
383: return (selectedIndex >= 0) ? getItem(selectedIndex) : null;
384: }
385:
386: /**
387: * Returns an array (length 1) containing the currently selected
388: * item. If this choice has no items, returns <code>null</code>.
389: * @see ItemSelectable
390: */
391: public synchronized Object[] getSelectedObjects() {
392: if (selectedIndex >= 0) {
393: Object[] items = new Object[1];
394: items[0] = getItem(selectedIndex);
395: return items;
396: }
397: return null;
398: }
399:
400: /**
401: * Returns the index of the currently selected item.
402: * If nothing is selected, returns -1.
403: *
404: * @return the index of the currently selected item, or -1 if nothing
405: * is currently selected
406: * @see #getSelectedItem
407: */
408: public int getSelectedIndex() {
409: return selectedIndex;
410: }
411:
412: /**
413: * Sets the selected item in this <code>Choice</code> menu to be the
414: * item at the specified position.
415: *
416: * <p>Note that this method should be primarily used to
417: * initially select an item in this component.
418: * Programmatically calling this method will <i>not</i> trigger
419: * an <code>ItemEvent</code>. The only way to trigger an
420: * <code>ItemEvent</code> is by user interaction.
421: *
422: * @param pos the positon of the selected item
423: * @exception IllegalArgumentException if the specified
424: * position is greater than the
425: * number of items or less than zero
426: * @see #getSelectedItem
427: * @see #getSelectedIndex
428: */
429: public synchronized void select(int pos) {
430: if ((pos >= pItems.size()) || (pos < 0)) {
431: throw new IllegalArgumentException(
432: "illegal Choice item position: " + pos);
433: }
434: if (pItems.size() > 0) {
435: selectedIndex = pos;
436: ChoicePeer peer = (ChoicePeer) this .peer;
437: if (peer != null) {
438: peer.select(pos);
439: }
440: }
441: }
442:
443: /**
444: * Sets the selected item in this <code>Choice</code> menu
445: * to be the item whose name is equal to the specified string.
446: * If more than one item matches (is equal to) the specified string,
447: * the one with the smallest index is selected.
448: *
449: * <p>Note that this method should be primarily used to
450: * initially select an item in this component.
451: * Programmatically calling this method will <i>not</i> trigger
452: * an <code>ItemEvent</code>. The only way to trigger an
453: * <code>ItemEvent</code> is by user interaction.
454: *
455: * @param str the specified string
456: * @see #getSelectedItem
457: * @see #getSelectedIndex
458: */
459: public synchronized void select(String str) {
460: int index = pItems.indexOf(str);
461: if (index >= 0) {
462: select(index);
463: }
464: }
465:
466: /**
467: * Adds the specified item listener to receive item events from
468: * this <code>Choice</code> menu. Item events are sent in response
469: * to user input, but not in response to calls to <code>select</code>.
470: * If l is <code>null</code>, no exception is thrown and no action
471: * is performed.
472: * <p>Refer to <a href="doc-files/AWTThreadIssues.html#ListenersThreads"
473: * >AWT Threading Issues</a> for details on AWT's threading model.
474: * @param l the item listener
475: * @see #removeItemListener
476: * @see #getItemListeners
477: * @see #select
478: * @see java.awt.event.ItemEvent
479: * @see java.awt.event.ItemListener
480: * @since JDK1.1
481: */
482: public synchronized void addItemListener(ItemListener l) {
483: if (l == null) {
484: return;
485: }
486: itemListener = AWTEventMulticaster.add(itemListener, l);
487: newEventsOnly = true;
488: }
489:
490: /**
491: * Removes the specified item listener so that it no longer receives
492: * item events from this <code>Choice</code> menu.
493: * If l is <code>null</code>, no exception is thrown and no
494: * action is performed.
495: * <p>Refer to <a href="doc-files/AWTThreadIssues.html#ListenersThreads"
496: * >AWT Threading Issues</a> for details on AWT's threading model.
497: * @param l the item listener
498: * @see #addItemListener
499: * @see #getItemListeners
500: * @see java.awt.event.ItemEvent
501: * @see java.awt.event.ItemListener
502: * @since JDK1.1
503: */
504: public synchronized void removeItemListener(ItemListener l) {
505: if (l == null) {
506: return;
507: }
508: itemListener = AWTEventMulticaster.remove(itemListener, l);
509: }
510:
511: /**
512: * Returns an array of all the item listeners
513: * registered on this choice.
514: *
515: * @return all of this choice's <code>ItemListener</code>s
516: * or an empty array if no item
517: * listeners are currently registered
518: *
519: * @see #addItemListener
520: * @see #removeItemListener
521: * @see java.awt.event.ItemEvent
522: * @see java.awt.event.ItemListener
523: * @since 1.4
524: */
525: public synchronized ItemListener[] getItemListeners() {
526: return (ItemListener[]) (getListeners(ItemListener.class));
527: }
528:
529: /**
530: * Returns an array of all the objects currently registered
531: * as <code><em>Foo</em>Listener</code>s
532: * upon this <code>Choice</code>.
533: * <code><em>Foo</em>Listener</code>s are registered using the
534: * <code>add<em>Foo</em>Listener</code> method.
535: *
536: * <p>
537: * You can specify the <code>listenerType</code> argument
538: * with a class literal, such as
539: * <code><em>Foo</em>Listener.class</code>.
540: * For example, you can query a
541: * <code>Choice</code> <code>c</code>
542: * for its item listeners with the following code:
543: *
544: * <pre>ItemListener[] ils = (ItemListener[])(c.getListeners(ItemListener.class));</pre>
545: *
546: * If no such listeners exist, this method returns an empty array.
547: *
548: * @param listenerType the type of listeners requested; this parameter
549: * should specify an interface that descends from
550: * <code>java.util.EventListener</code>
551: * @return an array of all objects registered as
552: * <code><em>Foo</em>Listener</code>s on this choice,
553: * or an empty array if no such
554: * listeners have been added
555: * @exception ClassCastException if <code>listenerType</code>
556: * doesn't specify a class or interface that implements
557: * <code>java.util.EventListener</code>
558: *
559: * @see #getItemListeners
560: * @since 1.3
561: */
562: public <T extends EventListener> T[] getListeners(
563: 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: /* Serialization support.
652: */
653:
654: /*
655: * Choice Serial Data Version.
656: * @serial
657: */
658: private int choiceSerializedDataVersion = 1;
659:
660: /**
661: * Writes default serializable fields to stream. Writes
662: * a list of serializable <code>ItemListeners</code>
663: * as optional data. The non-serializable
664: * <code>ItemListeners</code> are detected and
665: * no attempt is made to serialize them.
666: *
667: * @param s the <code>ObjectOutputStream</code> to write
668: * @serialData <code>null</code> terminated sequence of 0
669: * or more pairs; the pair consists of a <code>String</code>
670: * and an <code>Object</code>; the <code>String</code> indicates
671: * the type of object and is one of the following:
672: * <code>itemListenerK</code> indicating an
673: * <code>ItemListener</code> object
674: *
675: * @see AWTEventMulticaster#save(ObjectOutputStream, String, EventListener)
676: * @see java.awt.Component#itemListenerK
677: * @see #readObject(ObjectInputStream)
678: */
679: private void writeObject(ObjectOutputStream s)
680: throws java.io.IOException {
681: s.defaultWriteObject();
682:
683: AWTEventMulticaster.save(s, itemListenerK, itemListener);
684: s.writeObject(null);
685: }
686:
687: /**
688: * Reads the <code>ObjectInputStream</code> and if it
689: * isn't <code>null</code> adds a listener to receive
690: * item events fired by the <code>Choice</code> item.
691: * Unrecognized keys or values will be ignored.
692: *
693: * @param s the <code>ObjectInputStream</code> to read
694: * @exception HeadlessException if
695: * <code>GraphicsEnvironment.isHeadless</code> returns
696: * <code>true</code>
697: * @serial
698: * @see #removeItemListener(ItemListener)
699: * @see #addItemListener(ItemListener)
700: * @see java.awt.GraphicsEnvironment#isHeadless
701: * @see #writeObject(ObjectOutputStream)
702: */
703: private void readObject(ObjectInputStream s)
704: throws ClassNotFoundException, IOException,
705: HeadlessException {
706: GraphicsEnvironment.checkHeadless();
707: s.defaultReadObject();
708:
709: Object keyOrNull;
710: while (null != (keyOrNull = s.readObject())) {
711: String key = ((String) keyOrNull).intern();
712:
713: if (itemListenerK == key)
714: addItemListener((ItemListener) (s.readObject()));
715:
716: else
717: // skip value for unrecognized key
718: s.readObject();
719: }
720: }
721:
722: /////////////////
723: // Accessibility support
724: ////////////////
725:
726: /**
727: * Gets the <code>AccessibleContext</code> associated with this
728: * <code>Choice</code>. For <code>Choice</code> components,
729: * the <code>AccessibleContext</code> takes the form of an
730: * <code>AccessibleAWTChoice</code>. A new <code>AccessibleAWTChoice</code>
731: * instance is created if necessary.
732: *
733: * @return an <code>AccessibleAWTChoice</code> that serves as the
734: * <code>AccessibleContext</code> of this <code>Choice</code>
735: * @since 1.3
736: */
737: public AccessibleContext getAccessibleContext() {
738: if (accessibleContext == null) {
739: accessibleContext = new AccessibleAWTChoice();
740: }
741: return accessibleContext;
742: }
743:
744: /**
745: * This class implements accessibility support for the
746: * <code>Choice</code> class. It provides an implementation of the
747: * Java Accessibility API appropriate to choice user-interface elements.
748: * @since 1.3
749: */
750: protected class AccessibleAWTChoice extends AccessibleAWTComponent
751: implements AccessibleAction {
752: /*
753: * JDK 1.3 serialVersionUID
754: */
755: private static final long serialVersionUID = 7175603582428509322L;
756:
757: public AccessibleAWTChoice() {
758: super ();
759: }
760:
761: /**
762: * Get the AccessibleAction associated with this object. In the
763: * implementation of the Java Accessibility API for this class,
764: * return this object, which is responsible for implementing the
765: * AccessibleAction interface on behalf of itself.
766: *
767: * @return this object
768: * @see AccessibleAction
769: */
770: public AccessibleAction getAccessibleAction() {
771: return this ;
772: }
773:
774: /**
775: * Get the role of this object.
776: *
777: * @return an instance of AccessibleRole describing the role of the
778: * object
779: * @see AccessibleRole
780: */
781: public AccessibleRole getAccessibleRole() {
782: return AccessibleRole.COMBO_BOX;
783: }
784:
785: /**
786: * Returns the number of accessible actions available in this object
787: * If there are more than one, the first one is considered the "default"
788: * action of the object.
789: *
790: * @return the zero-based number of Actions in this object
791: */
792: public int getAccessibleActionCount() {
793: return 0; // To be fully implemented in a future release
794: }
795:
796: /**
797: * Returns a description of the specified action of the object.
798: *
799: * @param i zero-based index of the actions
800: * @return a String description of the action
801: * @see #getAccessibleActionCount
802: */
803: public String getAccessibleActionDescription(int i) {
804: return null; // To be fully implemented in a future release
805: }
806:
807: /**
808: * Perform the specified Action on the object
809: *
810: * @param i zero-based index of actions
811: * @return true if the action was performed; otherwise false.
812: * @see #getAccessibleActionCount
813: */
814: public boolean doAccessibleAction(int i) {
815: return false; // To be fully implemented in a future release
816: }
817:
818: } // inner class AccessibleAWTChoice
819:
820: }
|
