Quelle Choice.java Sprache: JAVA

/*
* Copyright (c) 1995, 2021, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/

package java.awt;

import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;
import java.awt.peer.ChoicePeer;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serial;
import java.util.EventListener;
import java.util.Vector;

import javax.accessibility.Accessible;
import javax.accessibility.AccessibleAction;
import javax.accessibility.AccessibleContext;
import javax.accessibility.AccessibleRole;

/**
* The {@code Choice} class presents a pop-up menu of choices.
* The current choice is displayed as the title of the menu.
* 
* The following code example produces a pop-up menu:
*
* <hr><blockquote><pre>
* Choice ColorChooser = new Choice();
* ColorChooser.add("Green");
* ColorChooser.add("Red");
* ColorChooser.add("Blue");
* </pre></blockquote><hr>
* 
* After this choice menu has been added to a panel,
* it appears as follows in its normal state:
* 
* <img src="doc-files/Choice-1.gif" alt="The following text describes the
* graphic" style="margin: 7px 10px;">
* 
* In the picture, {@code "Green"} is the current choice.
* Pushing the mouse button down on the object causes a menu to
* appear with the current choice highlighted.
* 
* Some native platforms do not support arbitrary resizing of
* {@code Choice} components and the behavior of
* {@code setSize()/getSize()} is bound by
* such limitations.
* Native GUI {@code Choice} components' size are often bound by such
* attributes as font size and length of items contained within
* the {@code Choice}.
*
* @author Sami Shaio
* @author Arthur van Hoff
* @since 1.0
*/
public class Choice extends Component implements ItemSelectable, Accessible {
 /**
 * The items for the {@code Choice}.
 * This can be a {@code null} value.
 * @serial
 * @see #add(String)
 * @see #addItem(String)
 * @see #getItem(int)
 * @see #getItemCount()
 * @see #insert(String, int)
 * @see #remove(String)
 */
 Vector<String> pItems;

 /**
 * The index of the current choice for this {@code Choice}
 * or -1 if nothing is selected.
 * @serial
 * @see #getSelectedItem()
 * @see #select(int)
 */
 int selectedIndex = -1;

 transient ItemListener itemListener;

 private static final String base = "choice";
 private static int nameCounter = 0;

 /**
 * Use serialVersionUID from JDK 1.1 for interoperability.
 */
 @Serial
 private static final long serialVersionUID = -4075310674757313071L;

 static {
 /* ensure that the necessary native libraries are loaded */
 Toolkit.loadLibraries();
 /* initialize JNI field and method ids */
 if (!GraphicsEnvironment.isHeadless()) {
 initIDs();
 }
 }

 /**
 * Creates a new choice menu. The menu initially has no items in it.
 * 
 * By default, the first item added to the choice menu becomes the
 * selected item, until a different selection is made by the user
 * by calling one of the {@code select} methods.
 * @throws HeadlessException if GraphicsEnvironment.isHeadless()
 * returns true
 * @see java.awt.GraphicsEnvironment#isHeadless
 * @see #select(int)
 * @see #select(java.lang.String)
 */
 public Choice() throws HeadlessException {
 GraphicsEnvironment.checkHeadless();
 pItems = new Vector<>();
 }

 /**
 * Constructs a name for this component. Called by
 * {@code getName} when the name is {@code null}.
 */
 String constructComponentName() {
 synchronized (Choice.class) {
 return base + nameCounter++;
 }
 }

 /**
 * Creates the {@code Choice}'s peer. This peer allows us
 * to change the look
 * of the {@code Choice} without changing its functionality.
 * @see java.awt.Component#getToolkit()
 */
 public void addNotify() {
 synchronized (getTreeLock()) {
 if (peer == null)
 peer = getComponentFactory().createChoice(this);
 super.addNotify();
 }
 }

 /**
 * Returns the number of items in this {@code Choice} menu.
 *
 * @return the number of items in this {@code Choice} menu
 * @see #getItem
 * @since 1.1
 */
 public int getItemCount() {
 return countItems();
 }

 /**
 * Returns the number of items in this {@code Choice} menu.
 *
 * @return the number of items in this {@code Choice} menu
 * @deprecated As of JDK version 1.1,
 * replaced by {@code getItemCount()}.
 */
 @Deprecated
 public int countItems() {
 return pItems.size();
 }

 /**
 * Gets the string at the specified index in this
 * {@code Choice} menu.
 *
 * @param index the index at which to begin
 * @return the item at the specified index
 * @see #getItemCount
 */
 public String getItem(int index) {
 return getItemImpl(index);
 }

 /*
 * This is called by the native code, so client code can't
 * be called on the toolkit thread.
 */
 final String getItemImpl(int index) {
 return pItems.elementAt(index);
 }

 /**
 * Adds an item to this {@code Choice} menu.
 * @param item the item to be added
 * @throws NullPointerException if the item's value is
 * {@code null}
 * @since 1.1
 */
 public void add(String item) {
 addItem(item);
 }

 /**
 * Obsolete as of Java 2 platform v1.1. Please use the
 * {@code add} method instead.
 * 
 * Adds an item to this {@code Choice} menu.
 * @param item the item to be added
 * @throws NullPointerException if the item's value is equal to
 * {@code null}
 */
 public void addItem(String item) {
 synchronized (this) {
 insertNoInvalidate(item, pItems.size());
 }

 // This could change the preferred size of the Component.
 invalidateIfValid();
 }

 /**
 * Inserts an item to this {@code Choice},
 * but does not invalidate the {@code Choice}.
 * Client methods must provide their own synchronization before
 * invoking this method.
 * @param item the item to be added
 * @param index the new item position
 * @throws NullPointerException if the item's value is equal to
 * {@code null}
 */
 private void insertNoInvalidate(String item, int index) {
 if (item == null) {
 throw new
 NullPointerException("cannot add null item to Choice");
 }
 pItems.insertElementAt(item, index);
 ChoicePeer peer = (ChoicePeer)this.peer;
 if (peer != null) {
 peer.add(item, index);
 }
 // no selection or selection shifted up
 if (selectedIndex < 0 || selectedIndex >= index) {
 select(0);
 }
 }

 /**
 * Inserts the item into this choice at the specified position.
 * Existing items at an index greater than or equal to
 * {@code index} are shifted up by one to accommodate
 * the new item. If {@code index} is greater than or
 * equal to the number of items in this choice,
 * {@code item} is added to the end of this choice.
 * 
 * If the item is the first one being added to the choice,
 * then the item becomes selected. Otherwise, if the
 * selected item was one of the items shifted, the first
 * item in the choice becomes the selected item. If the
 * selected item was no among those shifted, it remains
 * the selected item.
 * @param item the non-{@code null} item to be inserted
 * @param index the position at which the item should be inserted
 * @throws IllegalArgumentException if index is less than 0
 */
 public void insert(String item, int index) {
 synchronized (this) {
 if (index < 0) {
 throw new IllegalArgumentException("index less than zero.");
 }
 /* if the index greater than item count, add item to the end */
 index = Math.min(index, pItems.size());

 insertNoInvalidate(item, index);
 }

 // This could change the preferred size of the Component.
 invalidateIfValid();
 }

 /**
 * Removes the first occurrence of {@code item}
 * from the {@code Choice} menu. If the item
 * being removed is the currently selected item,
 * then the first item in the choice becomes the
 * selected item. Otherwise, the currently selected
 * item remains selected (and the selected index is
 * updated accordingly).
 * @param item the item to remove from this {@code Choice} menu
 * @throws IllegalArgumentException if the item doesn't
 * exist in the choice menu
 * @since 1.1
 */
 public void remove(String item) {
 synchronized (this) {
 int index = pItems.indexOf(item);
 if (index < 0) {
 throw new IllegalArgumentException("item " + item +
 " not found in choice");
 } else {
 removeNoInvalidate(index);
 }
 }

 // This could change the preferred size of the Component.
 invalidateIfValid();
 }

 /**
 * Removes an item from the choice menu
 * at the specified position. If the item
 * being removed is the currently selected item,
 * then the first item in the choice becomes the
 * selected item. Otherwise, the currently selected
 * item remains selected (and the selected index is
 * updated accordingly).
 * @param position the position of the item
 * @throws IndexOutOfBoundsException if the specified
 * position is out of bounds
 * @since 1.1
 */
 public void remove(int position) {
 synchronized (this) {
 removeNoInvalidate(position);
 }

 // This could change the preferred size of the Component.
 invalidateIfValid();
 }

 /**
 * Removes an item from the {@code Choice} at the
 * specified position, but does not invalidate the {@code Choice}.
 * Client methods must provide their
 * own synchronization before invoking this method.
 * @param position the position of the item
 */
 private void removeNoInvalidate(int position) {
 pItems.removeElementAt(position);
 ChoicePeer peer = (ChoicePeer)this.peer;
 if (peer != null) {
 peer.remove(position);
 }
 /* Adjust selectedIndex if selected item was removed. */
 if (pItems.size() == 0) {
 selectedIndex = -1;
 } else if (selectedIndex == position) {
 select(0);
 } else if (selectedIndex > position) {
 select(selectedIndex-1);
 }
 }

 /**
 * Removes all items from the choice menu.
 * @see #remove
 * @since 1.1
 */
 public void removeAll() {
 synchronized (this) {
 if (peer != null) {
 ((ChoicePeer)peer).removeAll();
 }
 pItems.removeAllElements();
 selectedIndex = -1;
 }

 // This could change the preferred size of the Component.
 invalidateIfValid();
 }

 /**
 * Gets a representation of the current choice as a string.
 * @return a string representation of the currently
 * selected item in this choice menu
 * @see #getSelectedIndex
 */
 public synchronized String getSelectedItem() {
 return (selectedIndex >= 0) ? getItem(selectedIndex) : null;
 }

 /**
 * Returns an array (length 1) containing the currently selected
 * item. If this choice has no items, returns {@code null}.
 * @see ItemSelectable
 */
 public synchronized Object[] getSelectedObjects() {
 if (selectedIndex >= 0) {
 Object[] items = new Object[1];
 items[0] = getItem(selectedIndex);
 return items;
 }
 return null;
 }

 /**
 * Returns the index of the currently selected item.
 * If nothing is selected, returns -1.
 *
 * @return the index of the currently selected item, or -1 if nothing
 * is currently selected
 * @see #getSelectedItem
 */
 public int getSelectedIndex() {
 return selectedIndex;
 }

 /**
 * Sets the selected item in this {@code Choice} menu to be the
 * item at the specified position.
 *
 * Note that this method should be primarily used to
 * initially select an item in this component.
 * Programmatically calling this method will not trigger
 * an {@code ItemEvent}. The only way to trigger an
 * {@code ItemEvent} is by user interaction.
 *
 * @param pos the position of the selected item
 * @throws IllegalArgumentException if the specified
 * position is greater than the
 * number of items or less than zero
 * @see #getSelectedItem
 * @see #getSelectedIndex
 */
 public synchronized void select(int pos) {
 if ((pos >= pItems.size()) || (pos < 0)) {
 throw new IllegalArgumentException("illegal Choice item position: " + pos);
 }
 if (pItems.size() > 0) {
 selectedIndex = pos;
 ChoicePeer peer = (ChoicePeer)this.peer;
 if (peer != null) {
 peer.select(pos);
 }
 }
 }

 /**
 * Sets the selected item in this {@code Choice} menu
 * to be the item whose name is equal to the specified string.
 * If more than one item matches (is equal to) the specified string,
 * the one with the smallest index is selected.
 *
 * Note that this method should be primarily used to
 * initially select an item in this component.
 * Programmatically calling this method will not trigger
 * an {@code ItemEvent}. The only way to trigger an
 * {@code ItemEvent} is by user interaction.
 *
 * @param str the specified string
 * @see #getSelectedItem
 * @see #getSelectedIndex
 */
 public synchronized void select(String str) {
 int index = pItems.indexOf(str);
 if (index >= 0) {
 select(index);
 }
 }

 /**
 * Adds the specified item listener to receive item events from
 * this {@code Choice} menu. Item events are sent in response
 * to user input, but not in response to calls to {@code select}.
 * If l is {@code null}, no exception is thrown and no action
 * is performed.
 * Refer to <a href="doc-files/AWTThreadIssues.html#ListenersThreads"
 * >AWT Threading Issues</a> for details on AWT's threading model.
 * @param l the item listener
 * @see #removeItemListener
 * @see #getItemListeners
 * @see #select
 * @see java.awt.event.ItemEvent
 * @see java.awt.event.ItemListener
 * @since 1.1
 */
 public synchronized void addItemListener(ItemListener l) {
 if (l == null) {
 return;
 }
 itemListener = AWTEventMulticaster.add(itemListener, l);
 newEventsOnly = true;
 }

 /**
 * Removes the specified item listener so that it no longer receives
 * item events from this {@code Choice} menu.
 * If l is {@code null}, no exception is thrown and no
 * action is performed.
 * Refer to <a href="doc-files/AWTThreadIssues.html#ListenersThreads"
 * >AWT Threading Issues</a> for details on AWT's threading model.
 * @param l the item listener
 * @see #addItemListener
 * @see #getItemListeners
 * @see java.awt.event.ItemEvent
 * @see java.awt.event.ItemListener
 * @since 1.1
 */
 public synchronized void removeItemListener(ItemListener l) {
 if (l == null) {
 return;
 }
 itemListener = AWTEventMulticaster.remove(itemListener, l);
 }

 /**
 * Returns an array of all the item listeners
 * registered on this choice.
 *
 * @return all of this choice's {@code ItemListener}s
 * or an empty array if no item
 * listeners are currently registered
 *
 * @see #addItemListener
 * @see #removeItemListener
 * @see java.awt.event.ItemEvent
 * @see java.awt.event.ItemListener
 * @since 1.4
 */
 public synchronized ItemListener[] getItemListeners() {
 return getListeners(ItemListener.class);
 }

 /**
 * Returns an array of all the objects currently registered
 * as <code>FooListener</code>s
 * upon this {@code Choice}.
 * <code>FooListener</code>s are registered using the
 * <code>addFooListener</code> method.
 *
 * 
 * You can specify the {@code listenerType} argument
 * with a class literal, such as
 * <code>FooListener.class</code>.
 * For example, you can query a
 * {@code Choice c}
 * for its item listeners with the following code:
 *
 * <pre>ItemListener[] ils = (ItemListener[])(c.getListeners(ItemListener.class));</pre>
 *
 * If no such listeners exist, this method returns an empty array.
 *
 * @param listenerType the type of listeners requested; this parameter
 * should specify an interface that descends from
 * {@code java.util.EventListener}
 * @return an array of all objects registered as
 * <code>FooListener</code>s on this choice,
 * or an empty array if no such
 * listeners have been added
 * @throws ClassCastException if {@code listenerType}
 * doesn't specify a class or interface that implements
 * {@code java.util.EventListener}
 *
 * @see #getItemListeners
 * @since 1.3
 */
 public <T extends EventListener> T[] getListeners(Class<T> listenerType) {
 EventListener l = null;
 if (listenerType == ItemListener.class) {
 l = itemListener;
 } else {
 return super.getListeners(listenerType);
 }
 return AWTEventMulticaster.getListeners(l, listenerType);
 }

 // REMIND: remove when filtering is done at lower level
 boolean eventEnabled(AWTEvent e) {
 if (e.id == ItemEvent.ITEM_STATE_CHANGED) {
 if ((eventMask & AWTEvent.ITEM_EVENT_MASK) != 0 ||
 itemListener != null) {
 return true;
 }
 return false;
 }
 return super.eventEnabled(e);
 }

 /**
 * Processes events on this choice. If the event is an
 * instance of {@code ItemEvent}, it invokes the
 * {@code processItemEvent} method. Otherwise, it calls its
 * superclass's {@code processEvent} method.
 * Note that if the event parameter is {@code null}
 * the behavior is unspecified and may result in an
 * exception.
 *
 * @param e the event
 * @see java.awt.event.ItemEvent
 * @see #processItemEvent
 * @since 1.1
 */
 protected void processEvent(AWTEvent e) {
 if (e instanceof ItemEvent) {
 processItemEvent((ItemEvent)e);
 return;
 }
 super.processEvent(e);
 }

 /**
 * Processes item events occurring on this {@code Choice}
 * menu by dispatching them to any registered
 * {@code ItemListener} objects.
 * 
 * This method is not called unless item events are
 * enabled for this component. Item events are enabled
 * when one of the following occurs:
 * <ul>
 * <li>An {@code ItemListener} object is registered
 * via {@code addItemListener}.
 * <li>Item events are enabled via {@code enableEvents}.
 * </ul>
 * Note that if the event parameter is {@code null}
 * the behavior is unspecified and may result in an
 * exception.
 *
 * @param e the item event
 * @see java.awt.event.ItemEvent
 * @see java.awt.event.ItemListener
 * @see #addItemListener(ItemListener)
 * @see java.awt.Component#enableEvents
 * @since 1.1
 */
 protected void processItemEvent(ItemEvent e) {
 ItemListener listener = itemListener;
 if (listener != null) {
 listener.itemStateChanged(e);
 }
 }

 /**
 * Returns a string representing the state of this {@code Choice}
 * menu. This method is intended to be used only for debugging purposes,
 * and the content and format of the returned string may vary between
 * implementations. The returned string may be empty but may not be
 * {@code null}.
 *
 * @return the parameter string of this {@code Choice} menu
 */
 protected String paramString() {
 return super.paramString() + ",current=" + getSelectedItem();
 }

 /* Serialization support.
 */

 /**
 * Serialized data version.
 * @serial
 */
 private int choiceSerializedDataVersion = 1;

 /**
 * Writes default serializable fields to stream. Writes
 * a list of serializable {@code ItemListeners}
 * as optional data. The non-serializable
 * {@code ItemListeners} are detected and
 * no attempt is made to serialize them.
 *
 * @param s the {@code ObjectOutputStream} to write
 * @throws IOException if an I/O error occurs
 * @serialData {@code null} terminated sequence of 0
 * or more pairs; the pair consists of a {@code String}
 * and an {@code Object}; the {@code String} indicates
 * the type of object and is one of the following:
 * {@code itemListenerK} indicating an
 * {@code ItemListener} object
 *
 * @see AWTEventMulticaster#save(ObjectOutputStream, String, EventListener)
 * @see java.awt.Component#itemListenerK
 * @see #readObject(ObjectInputStream)
 */
 @Serial
 private void writeObject(ObjectOutputStream s)
 throws java.io.IOException
 {
 s.defaultWriteObject();

 AWTEventMulticaster.save(s, itemListenerK, itemListener);
 s.writeObject(null);
 }

 /**
 * Reads the {@code ObjectInputStream} and if it
 * isn't {@code null} adds a listener to receive
 * item events fired by the {@code Choice} item.
 * Unrecognized keys or values will be ignored.
 *
 * @param s the {@code ObjectInputStream} to read
 * @throws ClassNotFoundException if the class of a serialized object could
 * not be found
 * @throws IOException if an I/O error occurs
 * @throws HeadlessException if {@code GraphicsEnvironment.isHeadless()}
 * returns {@code true}
 *
 * @see #removeItemListener(ItemListener)
 * @see #addItemListener(ItemListener)
 * @see java.awt.GraphicsEnvironment#isHeadless
 * @see #writeObject(ObjectOutputStream)
 */
 @Serial
 private void readObject(ObjectInputStream s)
 throws ClassNotFoundException, IOException, HeadlessException
 {
 GraphicsEnvironment.checkHeadless();
 s.defaultReadObject();

 Object keyOrNull;
 while(null != (keyOrNull = s.readObject())) {
 String key = ((String)keyOrNull).intern();

 if (itemListenerK == key)
 addItemListener((ItemListener)(s.readObject()));

 else // skip value for unrecognized key
 s.readObject();
 }
 }

 /**
 * Initialize JNI field and method IDs
 */
 private static native void initIDs();

/////////////////
// Accessibility support
////////////////

 /**
 * Gets the {@code AccessibleContext} associated with this
 * {@code Choice}. For {@code Choice} components,
 * the {@code AccessibleContext} takes the form of an
 * {@code AccessibleAWTChoice}. A new {@code AccessibleAWTChoice}
 * instance is created if necessary.
 *
 * @return an {@code AccessibleAWTChoice} that serves as the
 * {@code AccessibleContext} of this {@code Choice}
 * @since 1.3
 */
 public AccessibleContext getAccessibleContext() {
 if (accessibleContext == null) {
 accessibleContext = new AccessibleAWTChoice();
 }
 return accessibleContext;
 }

 /**
 * This class implements accessibility support for the
 * {@code Choice} class. It provides an implementation of the
 * Java Accessibility API appropriate to choice user-interface elements.
 * @since 1.3
 */
 protected class AccessibleAWTChoice extends AccessibleAWTComponent
 implements AccessibleAction
 {
 /**
 * Use serialVersionUID from JDK 1.3 for interoperability.
 */
 @Serial
 private static final long serialVersionUID = 7175603582428509322L;

 /**
 * Constructor for {@code AccessibleAWTChoice}
 */
 public AccessibleAWTChoice() {
 super();
 }

 /**
 * Get the AccessibleAction associated with this object. In the
 * implementation of the Java Accessibility API for this class,
 * return this object, which is responsible for implementing the
 * AccessibleAction interface on behalf of itself.
 *
 * @return this object
 * @see AccessibleAction
 */
 public AccessibleAction getAccessibleAction() {
 return this;
 }

 /**
 * Get the role of this object.
 *
 * @return an instance of AccessibleRole describing the role of the
 * object
 * @see AccessibleRole
 */
 public AccessibleRole getAccessibleRole() {
 return AccessibleRole.COMBO_BOX;
 }

 /**
 * Returns the number of accessible actions available in this object
 * If there are more than one, the first one is considered the "default"
 * action of the object.
 *
 * @return the zero-based number of Actions in this object
 */
 public int getAccessibleActionCount() {
 return 0; // To be fully implemented in a future release
 }

 /**
 * Returns a description of the specified action of the object.
 *
 * @param i zero-based index of the actions
 * @return a String description of the action
 * @see #getAccessibleActionCount
 */
 public String getAccessibleActionDescription(int i) {
 return null; // To be fully implemented in a future release
 }

 /**
 * Perform the specified Action on the object
 *
 * @param i zero-based index of actions
 * @return true if the action was performed; otherwise false.
 * @see #getAccessibleActionCount
 */
 public boolean doAccessibleAction(int i) {
 return false; // To be fully implemented in a future release
 }

 } // inner class AccessibleAWTChoice

}

quality97%

¤ Dauer der Verarbeitung: 0.21 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.