gcc/libjava/java/awt/Choice.java

/* Copyright (C) 2000  Free Software Foundation

   This file is part of libgcj.

This software is copyrighted work licensed under the terms of the
Libgcj License.  Please consult the file "LIBGCJ_LICENSE" for
details.  */

package java.awt;
import java.awt.event.*;
import java.awt.peer.ChoicePeer;
import java.util.ArrayList;

/** This component lets the user choose an item from a list of
 * Strings.
 * @author Tom Tromey <tromey@redhat.com>
 * @date December 25, 2000
 */
public class Choice extends Component implements ItemSelectable
{
  /** Create a new Choice object.  */
  public Choice ()
  {
    items = new ArrayList ();
    selected = -1;
  }

  /** Add a new item to this Choice object.  If the item is the first
   * item on the list, then it is selected.
   * @param item The new item; must be non-null.
   */
  public synchronized void add (String item)
  {
    if (item == null)
      throw new IllegalArgumentException ("item must be non-null");
    items.add (item);

    int i = items.size () - 1;
    if (peer != null)
      {
	ChoicePeer cp = (ChoicePeer) peer;
	cp.add (item, i);
      }

    if (i == 0)
      select (0);
  }

  /** Add a new item to this Choice object.  This is the same as the
   * add method.  */
  public void addItem (String item)
  {
    add (item);
  }

  /** Add a listener for item events.
   * @param listener The listener to add.
   */
  public synchronized void addItemListener (ItemListener listener)
  {
    listeners = AWTEventMulticaster.add (listeners, listener);
  }

  /** This creates the component's peer.  */
  public void addNotify ()
  {
    if (peer == null)
      peer = getToolkit ().createChoice (this);
  }

  /** Returns number of items.
   * @deprecated
   */
  public int countItems ()
  {
    return getItemCount ();
  }

  /** Returns an item from this choice.
   * @param index Index of the item.  Indices start at zero.
   */
  public String getItem (int index)
  {
    return (String) items.get (index);
  }

  /** Returns number of items in Choice.  */
  public int getItemCount ()
  {
    return items.size ();
  }

  /** Returns index of selected item; -1 if no item is selected.  */
  public int getSelectedIndex ()
  {
    return selected;
  }

  /** Returns currently selected item; null if no item is selected.  */
  public synchronized String getSelectedItem ()
  {
    return selected == -1 ? null : (String) items.get (selected);
  }

  /** Returns the currently selected item.  */
  public synchronized Object[] getSelectedObjects ()
  {
    // The JCL says this can return null but that breaks the contract
    // for ItemSelectable.
    Object[] r;
    if (selected != -1)
      {
	r = new Object[1];
	r[0] = items.get (selected);
      }
    else
      r = new Object[0];
    return r;
  }

  /** Inserts an item into this Choice.  Existing items are shifted
   * upwards.  If the new item is the only item, then it is selected.
   * If the currently selected item is shifted, then the first item is
   * selected.  If the currently selected item is not shifted, then it
   * remains selected.
   * @param item The new item
   * @param index The position at which to insert it.
   */
  public synchronized void insert (String item, int index)
  {
    if (index > items.size ())
      index = items.size ();
    items.add (index, item);

    if (peer != null)
      {
	ChoicePeer cp = (ChoicePeer) peer;
	cp.add (item, index);
      }

    if (items.size () == 1 || selected >= index)
      select (0);
  }

  /** Generates a String representation of this Choice's state.  */
  protected String paramString ()
  {
    return ("Choice["
	    + "selected=" + selected
	    + "]");
  }

  /** Process an event for this Choice
   * @param event The event the process.
   */
  protected void processEvent (AWTEvent event)
  {
    if (event instanceof ItemEvent)
      processItemEvent ((ItemEvent) event);
    else
      super.processEvent (event);
  }

  /** Process an item event for this Choice.
   * @param event The ItemEvent to process
   */
  protected void processItemEvent (ItemEvent event)
  {
    if (listeners != null)
      listeners.itemStateChanged (event);
  }

  /** Remove an item from this Choice.  If several matches exist, the
   * first one is removed.  If the removed item is selected, the the
   * first item is selected.
   * @param item The item string.
   */
  public synchronized void remove (String item)
  {
    int size = items.size ();
    for (int i = 0; i < size; ++i)
      {
	if (item.equals (items.get (i)))
	  {
	    remove (i);
	    break;
	  }
      }
    throw new IllegalArgumentException ("item \"" + item + "\" not in Choice");
  }

  /** Remove an item from this Choice.  If the removed item is
   * selected, the the first item is selected.
   * @param index Index of the item to remove
   */
  public synchronized void remove (int index)
  {
    items.remove (index);

    if (peer != null)
      {
	ChoicePeer cp = (ChoicePeer) peer;
	cp.remove (index);
      }

    if (index == selected)
      select (0);
    else if (selected > index)
      --selected;
  }

  /** Remove all items from this choice.  */
  public synchronized void removeAll ()
  {
    int oldsize = items.size ();
    items.clear ();
    selected = -1;

    if (peer != null)
      {
	ChoicePeer cp = (ChoicePeer) peer;
	for (int i = 0; i < oldsize; ++i)
	  {
	    // Always remove item 0.
	    cp.remove (0);
	  }
      }
  }

  /** Remove an item listener.
   * @param listener Item listener to remove.
   */
  public synchronized void removeItemListener (ItemListener listener)
  {
    listeners = AWTEventMulticaster.remove (listeners, listener);
  }

  /** Select an item in this Choice.
   * @param item Name of the item to select.
   */
  public synchronized void select (String item)
  {
    int size = items.size ();
    for (int i = 0; i < size; ++i)
      {
	if (item.equals (items.get (i)))
	  {
	    select (i);
	    break;
	  }
      }
  }

  /** Select an item in this choice.
   * @param index Index of item to select.
   */
  public synchronized void select (int index)
  {
    if (index < 0 || index > items.size ())
      throw new IllegalArgumentException ("index out of range");
    selected = index;
    if (peer != null)
      {
	ChoicePeer cp = (ChoicePeer) peer;
	cp.select (index);
      }
  }

  private ItemListener listeners;

  // List of items.
  ArrayList items;
  // Index of selected item.
  int selected;
}