examples/org.eclipse.jface.examples.databinding/src/org/eclipse/jface/examples/databinding/radioGroup/RadioGroup.java - platform/eclipse.platform.ui - Git at Google

 /*******************************************************************************
  * Copyright (c) 2005, 2006 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
  *
  * Contributors:
  *     IBM Corporation - initial API and implementation
  *******************************************************************************/
 package org.eclipse.jface.examples.databinding.radioGroup;

 import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.LinkedList;
 import java.util.List;

 import org.eclipse.jface.examples.databinding.ducks.DuckType;
 import org.eclipse.swt.SWT;
 import org.eclipse.swt.SWTException;
 import org.eclipse.swt.events.SelectionEvent;
 import org.eclipse.swt.events.SelectionListener;
 import org.eclipse.swt.widgets.Display;
 import org.eclipse.swt.widgets.Event;

 /**
  * This object decorates a bunch of SWT.RADIO buttons and provides saner
  * selection semantics than you get by default with those radio buttons.
  * <p>
  * Its API is basically the same API as List, but with unnecessary methods
  * removed.
  */
 public class RadioGroup {

    private final IRadioButton[] buttons;
    private final Object[] values;
    IRadioButton oldSelection = null;
    IRadioButton selectedButton = null;
    IRadioButton potentialNewSelection = null;

    /** (Non-API)
     * Interface IRadioButton.  A duck interface that is used internally by RadioGroup
     * and by RadioGroup's unit tests.
     */
    public static interface IRadioButton {
       void setData(String string, Object object);
       void addSelectionListener(SelectionListener selectionListener);
       void setSelection(boolean b);
       boolean getSelection();
       boolean isFocusControl();
       String getText();
       void setText(String string);
       void notifyListeners(int eventType, Event object);
    }

    /**
     * Constructs an instance of this widget given an array of Button objects to wrap.
     * The Button objects must have been created with the SWT.RADIO style bit set,
     * and they must all be in the same Composite.
     *
     * @param radioButtons Object[] an array of radio buttons to wrap.
     * @param values Object[] an array of objects corresponding to the value of each radio button.
     */
    public RadioGroup(Object[] radioButtons, Object[] values) {
       IRadioButton[] buttons = new IRadioButton[radioButtons.length];
       if (buttons.length < 1) {
          throw new IllegalArgumentException("A RadioGroup must manage at least one Button");
       }
       for (int i = 0; i < buttons.length; i++) {
          if (!DuckType.instanceOf(IRadioButton.class, radioButtons[i])) {
             throw new IllegalArgumentException("A radio button was not passed");
          }
          buttons[i] = (IRadioButton) DuckType.implement(IRadioButton.class, radioButtons[i]);
          buttons[i].setData(Integer.toString(i), new Integer(i));
          buttons[i].addSelectionListener(selectionListener);
       }
       this.buttons = buttons;
       this.values = values;
    }

    /**
     * Returns the object corresponding to the currently-selected radio button
     * or null if no radio button is selected.
     *
     * @return the object corresponding to the currently-selected radio button
     * or null if no radio button is selected.
     */
    public Object getSelection() {
       int selectionIndex = getSelectionIndex();
       if (selectionIndex < 0)
          return "";
       return values[selectionIndex];
    }

    /**
     * Sets the selected radio button to the radio button whose model object
     * equals() the object specified by newSelection.  If !newSelection.equals()
     * any model object managed by this radio group, deselects all radio buttons.
     *
     * @param newSelection A model object corresponding to one of the model
     * objects associated with one of the radio buttons.
     */
    public void setSelection(Object newSelection) {
       deselectAll();
       for (int i = 0; i < values.length; i++) {
          if (values[i].equals(newSelection)) {
             setSelection(i);
             return;
          }
       }
    }

    private SelectionListener selectionListener = new SelectionListener() {
       public void widgetDefaultSelected(SelectionEvent e) {
          widgetSelected(e);
       }

       public void widgetSelected(SelectionEvent e) {
          potentialNewSelection = getButton(e);
          if (! potentialNewSelection.getSelection()) {
             return;
          }
          if (potentialNewSelection.equals(selectedButton)) {
             return;
          }

          if (fireWidgetChangeSelectionEvent(e)) {
             oldSelection = selectedButton;
             selectedButton = potentialNewSelection;
             if (oldSelection == null) {
                oldSelection = selectedButton;
             }

             fireWidgetSelectedEvent(e);
          }
       }

       private IRadioButton getButton(SelectionEvent e) {
          // If the actual IRadioButton is a test fixture, then the test fixture can't
          // set e.widget, so the button object will be in e.data instead and a dummy
          // Widget will be in e.widget.
          if (e.data != null) {
             return (IRadioButton) e.data;
          }
          return (IRadioButton) DuckType.implement(IRadioButton.class, e.widget);
       }
    };

    private List widgetChangeListeners = new LinkedList();

    protected boolean fireWidgetChangeSelectionEvent(SelectionEvent e) {
       for (Iterator listenersIter = widgetChangeListeners.iterator(); listenersIter.hasNext();) {
          VetoableSelectionListener listener = (VetoableSelectionListener) listenersIter.next();
          listener.canWidgetChangeSelection(e);
          if (!e.doit) {
             rollbackSelection();
             return false;
          }
       }
       return true;
    }

    private void rollbackSelection() {
       Display.getCurrent().asyncExec(new Runnable() {
          public void run() {
             potentialNewSelection.setSelection(false);
             selectedButton.setSelection(true);
 //            selectedButton.notifyListeners(SWT.Selection, null);
          }
       });
    }


    /**
     * Adds the listener to the collection of listeners who will
     * be notified when the receiver's selection is about to change, by sending
     * it one of the messages defined in the <code>VetoableSelectionListener</code>
     * interface.
     * <p>
     * <code>widgetSelected</code> is called when the selection changes.
     * <code>widgetDefaultSelected</code> is typically called when an item is double-clicked.
     * </p>
     *
     * @param listener the listener which should be notified
     *
     * @exception IllegalArgumentException <ul>
     *    <li>ERROR_NULL_ARGUMENT - if the listener is null</li>
     * </ul>
     * @exception SWTException <ul>
     *    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
     *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
     * </ul>
     *
     * @see VetoableSelectionListener
     * @see #removeVetoableSelectionListener
     * @see SelectionEvent
     */
    public void addVetoableSelectionListener(VetoableSelectionListener listener) {
       widgetChangeListeners.add(listener);
    }

    /**
     * Removes the listener from the collection of listeners who will
     * be notified when the receiver's selection is about to change.
     *
     * @param listener the listener which should no longer be notified
     *
     * @exception IllegalArgumentException <ul>
     *    <li>ERROR_NULL_ARGUMENT - if the listener is null</li>
     * </ul>
     * @exception SWTException <ul>
     *    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
     *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
     * </ul>
     *
     * @see VetoableSelectionListener
     * @see #addVetoableSelectionListener
     */
    public void removeVetoableSelectionListener(VetoableSelectionListener listener) {
       widgetChangeListeners.remove(listener);
    }


    private List widgetSelectedListeners = new ArrayList();

    protected void fireWidgetSelectedEvent(SelectionEvent e) {
       for (Iterator listenersIter = widgetSelectedListeners.iterator(); listenersIter.hasNext();) {
          SelectionListener listener = (SelectionListener) listenersIter.next();
          listener.widgetSelected(e);
       }
    }

    protected void fireWidgetDefaultSelectedEvent(SelectionEvent e) {
       fireWidgetSelectedEvent(e);
    }

    /**
     * Adds the listener to the collection of listeners who will
     * be notified when the receiver's selection changes, by sending
     * it one of the messages defined in the <code>SelectionListener</code>
     * interface.
     * <p>
     * <code>widgetSelected</code> is called when the selection changes.
     * <code>widgetDefaultSelected</code> is typically called when an item is double-clicked.
     * </p>
     *
     * @param listener the listener which should be notified
     *
     * @exception IllegalArgumentException <ul>
     *    <li>ERROR_NULL_ARGUMENT - if the listener is null</li>
     * </ul>
     * @exception SWTException <ul>
     *    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
     *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
     * </ul>
     *
     * @see SelectionListener
     * @see #removeSelectionListener
     * @see SelectionEvent
     */
    public void addSelectionListener(SelectionListener listener) {
       widgetSelectedListeners.add(listener);
    }

    /**
     * Removes the listener from the collection of listeners who will
     * be notified when the receiver's selection changes.
     *
     * @param listener the listener which should no longer be notified
     *
     * @exception IllegalArgumentException <ul>
     *    <li>ERROR_NULL_ARGUMENT - if the listener is null</li>
     * </ul>
     * @exception SWTException <ul>
     *    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
     *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
     * </ul>
     *
     * @see SelectionListener
     * @see #addSelectionListener
     */
    public void removeSelectionListener(SelectionListener listener) {
       widgetSelectedListeners.remove(listener);
    }

    /**
     * Deselects the item at the given zero-relative index in the receiver.
     * If the item at the index was already deselected, it remains
     * deselected. Indices that are out of range are ignored.
     *
     * @param index the index of the item to deselect
     *
     * @exception SWTException <ul>
     *    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
     *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
     * </ul>
     */
    public void deselect (int index) {
       if (index < 0 || index >= buttons.length)
          return;
       buttons[index].setSelection(false);
    }

    /**
     * Deselects all selected items in the receiver.
     *
     * @exception SWTException <ul>
     *    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
     *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
     * </ul>
     */
    public void deselectAll () {
       for (int i = 0; i < buttons.length; i++)
          buttons[i].setSelection(false);
    }

    /**
     * Returns the zero-relative index of the item which currently
     * has the focus in the receiver, or -1 if no item has focus.
     *
     * @return the index of the selected item
     *
     * @exception SWTException <ul>
     *    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
     *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
     * </ul>
     */
    public int getFocusIndex () {
       for (int i = 0; i < buttons.length; i++) {
          if (buttons[i].isFocusControl()) {
             return i;
          }
       }
       return -1;
    }

    /**
     * Returns the item at the given, zero-relative index in the
     * receiver. Throws an exception if the index is out of range.
     *
     * @param index the index of the item to return
     * @return the item at the given index
     *
     * @exception IllegalArgumentException <ul>
     *    <li>ERROR_INVALID_RANGE - if the index is not between 0 and the number of elements in the list minus 1 (inclusive)</li>
     * </ul>
     * @exception SWTException <ul>
     *    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
     *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
     * </ul>
     *
     * FIXME: tck - this should be renamed to getItemText()
     */
    public String getItem (int index) {
       if (index < 0 || index >= buttons.length)
          SWT.error(SWT.ERROR_INVALID_RANGE, null, "getItem for a nonexistant item");
       return buttons[index].getText();
    }

    /**
     * Returns the number of items contained in the receiver.
     *
     * @return the number of items
     *
     * @exception SWTException <ul>
     *    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
     *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
     * </ul>
     */
    public int getItemCount () {
       return buttons.length;
    }

    /**
     * Returns a (possibly empty) array of <code>String</code>s which
     * are the items in the receiver.
     * <p>
     * Note: This is not the actual structure used by the receiver
     * to maintain its list of items, so modifying the array will
     * not affect the receiver.
     * </p>
     *
     * @return the items in the receiver's list
     *
     * @exception SWTException <ul>
     *    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
     *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
     * </ul>
     */
    public String [] getItems () {
       List itemStrings = new ArrayList();
       for (int i = 0; i < buttons.length; i++) {
          itemStrings.add(buttons[i].getText());
       }
       return (String[]) itemStrings.toArray(new String[itemStrings.size()]);
    }

    public Object[] getButtons() {
       return buttons;
    }

    /**
     * Returns the zero-relative index of the item which is currently
     * selected in the receiver, or -1 if no item is selected.
     *
     * @return the index of the selected item or -1
     *
     * @exception SWTException <ul>
     *    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
     *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
     * </ul>
     */
    public int getSelectionIndex () {
       for (int i = 0; i < buttons.length; i++) {
          if (buttons[i].getSelection() == true) {
             return i;
          }
       }
       return -1;
    }

   /**
     * Gets the index of an item.
     * <p>
     * The list is searched starting at 0 until an
     * item is found that is equal to the search item.
     * If no item is found, -1 is returned.  Indexing
     * is zero based.
     *
     * @param string the search item
     * @return the index of the item
     *
     * @exception IllegalArgumentException <ul>
     *    <li>ERROR_NULL_ARGUMENT - if the string is null</li>
     * </ul>
     * @exception SWTException <ul>
     *    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
     *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
     * </ul>
     */
    public int indexOf (String string) {
       for (int i = 0; i < buttons.length; i++) {
          if (buttons[i].getText().equals(string)) {
             return i;
          }
       }
       return -1;
    }

    /**
     * Searches the receiver's list starting at the given,
     * zero-relative index until an item is found that is equal
     * to the argument, and returns the index of that item. If
     * no item is found or the starting index is out of range,
     * returns -1.
     *
     * @param string the search item
     * @param start the zero-relative index at which to start the search
     * @return the index of the item
     *
     * @exception IllegalArgumentException <ul>
     *    <li>ERROR_NULL_ARGUMENT - if the string is null</li>
     * </ul>
     * @exception SWTException <ul>
     *    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
     *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
     * </ul>
     */
    public int indexOf (String string, int start) {
       for (int i = start; i < buttons.length; i++) {
          if (buttons[i].getText().equals(string)) {
             return i;
          }
       }
       return -1;
    }

    /**
     * Returns <code>true</code> if the item is selected,
     * and <code>false</code> otherwise.  Indices out of
     * range are ignored.
     *
     * @param index the index of the item
     * @return the visibility state of the item at the index
     *
     * @exception SWTException <ul>
     *    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
     *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
     * </ul>
     */
    public boolean isSelected (int index) {
       return buttons[index].getSelection();
    }

    /**
     * Selects the item at the given zero-relative index in the receiver's
     * list.  If the item at the index was already selected, it remains
     * selected. Indices that are out of range are ignored.
     *
     * @param index the index of the item to select
     *
     * @exception SWTException <ul>
     *    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
     *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
     * </ul>
     */
    public void select (int index) {
       if (index < 0 || index >= buttons.length)
          return;
       buttons[index].setSelection(true);
    }

    /**
     * Sets the text of the item in the receiver's list at the given
     * zero-relative index to the string argument. This is equivalent
     * to <code>remove</code>'ing the old item at the index, and then
     * <code>add</code>'ing the new item at that index.
     *
     * @param index the index for the item
     * @param string the new text for the item
     *
     * @exception IllegalArgumentException <ul>
     *    <li>ERROR_INVALID_RANGE - if the index is not between 0 and the number of elements in the list minus 1 (inclusive)</li>
     *    <li>ERROR_NULL_ARGUMENT - if the string is null</li>
     * </ul>
     * @exception SWTException <ul>
     *    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
     *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
     * </ul>
     */
    public void setItem (int index, String string) {
       if (index < 0 || index >= buttons.length)
          SWT.error(SWT.ERROR_INVALID_RANGE, null, "setItem for a nonexistant item");
       buttons[index].setText(string);
    }

    /**
     * Selects the item at the given zero-relative index in the receiver.
     * If the item at the index was already selected, it remains selected.
     * The current selection is first cleared, then the new item is selected.
     * Indices that are out of range are ignored.
     *
     * @param index the index of the item to select
     *
     * @exception SWTException <ul>
     *    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
     *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
     * </ul>
     * @see List#deselectAll()
     * @see List#select(int)
     */
    public void setSelection (int index) {
       if (index < 0 || index > buttons.length - 1) {
          return;
       }
       buttons[index].setSelection(true);
    }

 }
	/*******************************************************************************
	* Copyright (c) 2005, 2006 IBM Corporation and others.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/epl-v10.html
	*
	* Contributors:
	* IBM Corporation - initial API and implementation
	*******************************************************************************/
	package org.eclipse.jface.examples.databinding.radioGroup;

	import java.util.ArrayList;
	import java.util.Iterator;
	import java.util.LinkedList;
	import java.util.List;

	import org.eclipse.jface.examples.databinding.ducks.DuckType;
	import org.eclipse.swt.SWT;
	import org.eclipse.swt.SWTException;
	import org.eclipse.swt.events.SelectionEvent;
	import org.eclipse.swt.events.SelectionListener;
	import org.eclipse.swt.widgets.Display;
	import org.eclipse.swt.widgets.Event;

	/**
	* This object decorates a bunch of SWT.RADIO buttons and provides saner
	* selection semantics than you get by default with those radio buttons.
	* <p>
	* Its API is basically the same API as List, but with unnecessary methods
	* removed.
	*/
	public class RadioGroup {

	private final IRadioButton[] buttons;
	private final Object[] values;
	IRadioButton oldSelection = null;
	IRadioButton selectedButton = null;
	IRadioButton potentialNewSelection = null;

	/** (Non-API)
	* Interface IRadioButton. A duck interface that is used internally by RadioGroup
	* and by RadioGroup's unit tests.
	*/
	public static interface IRadioButton {
	void setData(String string, Object object);
	void addSelectionListener(SelectionListener selectionListener);
	void setSelection(boolean b);
	boolean getSelection();
	boolean isFocusControl();
	String getText();
	void setText(String string);
	void notifyListeners(int eventType, Event object);
	}

	/**
	* Constructs an instance of this widget given an array of Button objects to wrap.
	* The Button objects must have been created with the SWT.RADIO style bit set,
	* and they must all be in the same Composite.
	*
	* @param radioButtons Object[] an array of radio buttons to wrap.
	* @param values Object[] an array of objects corresponding to the value of each radio button.
	*/
	public RadioGroup(Object[] radioButtons, Object[] values) {
	IRadioButton[] buttons = new IRadioButton[radioButtons.length];
	if (buttons.length < 1) {
	throw new IllegalArgumentException("A RadioGroup must manage at least one Button");
	}
	for (int i = 0; i < buttons.length; i++) {
	if (!DuckType.instanceOf(IRadioButton.class, radioButtons[i])) {
	throw new IllegalArgumentException("A radio button was not passed");
	}
	buttons[i] = (IRadioButton) DuckType.implement(IRadioButton.class, radioButtons[i]);
	buttons[i].setData(Integer.toString(i), new Integer(i));
	buttons[i].addSelectionListener(selectionListener);
	}
	this.buttons = buttons;
	this.values = values;
	}

	/**
	* Returns the object corresponding to the currently-selected radio button
	* or null if no radio button is selected.
	*
	* @return the object corresponding to the currently-selected radio button
	* or null if no radio button is selected.
	*/
	public Object getSelection() {
	int selectionIndex = getSelectionIndex();
	if (selectionIndex < 0)
	return "";
	return values[selectionIndex];
	}

	/**
	* Sets the selected radio button to the radio button whose model object
	* equals() the object specified by newSelection. If !newSelection.equals()
	* any model object managed by this radio group, deselects all radio buttons.
	*
	* @param newSelection A model object corresponding to one of the model
	* objects associated with one of the radio buttons.
	*/
	public void setSelection(Object newSelection) {
	deselectAll();
	for (int i = 0; i < values.length; i++) {
	if (values[i].equals(newSelection)) {
	setSelection(i);
	return;
	}
	}
	}

	private SelectionListener selectionListener = new SelectionListener() {
	public void widgetDefaultSelected(SelectionEvent e) {
	widgetSelected(e);
	}

	public void widgetSelected(SelectionEvent e) {
	potentialNewSelection = getButton(e);
	if (! potentialNewSelection.getSelection()) {
	return;
	}
	if (potentialNewSelection.equals(selectedButton)) {
	return;
	}

	if (fireWidgetChangeSelectionEvent(e)) {
	oldSelection = selectedButton;
	selectedButton = potentialNewSelection;
	if (oldSelection == null) {
	oldSelection = selectedButton;
	}

	fireWidgetSelectedEvent(e);
	}
	}

	private IRadioButton getButton(SelectionEvent e) {
	// If the actual IRadioButton is a test fixture, then the test fixture can't
	// set e.widget, so the button object will be in e.data instead and a dummy
	// Widget will be in e.widget.
	if (e.data != null) {
	return (IRadioButton) e.data;
	}
	return (IRadioButton) DuckType.implement(IRadioButton.class, e.widget);
	}
	};

	private List widgetChangeListeners = new LinkedList();

	protected boolean fireWidgetChangeSelectionEvent(SelectionEvent e) {
	for (Iterator listenersIter = widgetChangeListeners.iterator(); listenersIter.hasNext();) {
	VetoableSelectionListener listener = (VetoableSelectionListener) listenersIter.next();
	listener.canWidgetChangeSelection(e);
	if (!e.doit) {
	rollbackSelection();
	return false;
	}
	}
	return true;
	}

	private void rollbackSelection() {
	Display.getCurrent().asyncExec(new Runnable() {
	public void run() {
	potentialNewSelection.setSelection(false);
	selectedButton.setSelection(true);
	// selectedButton.notifyListeners(SWT.Selection, null);
	}
	});
	}


	/**
	* Adds the listener to the collection of listeners who will
	* be notified when the receiver's selection is about to change, by sending
	* it one of the messages defined in the <code>VetoableSelectionListener</code>
	* interface.
	* <p>
	* <code>widgetSelected</code> is called when the selection changes.
	* <code>widgetDefaultSelected</code> is typically called when an item is double-clicked.
	* </p>
	*
	* @param listener the listener which should be notified
	*
	* @exception IllegalArgumentException <ul>
	* <li>ERROR_NULL_ARGUMENT - if the listener is null</li>
	* </ul>
	* @exception SWTException <ul>
	* <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
	* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
	* </ul>
	*
	* @see VetoableSelectionListener
	* @see #removeVetoableSelectionListener
	* @see SelectionEvent
	*/
	public void addVetoableSelectionListener(VetoableSelectionListener listener) {
	widgetChangeListeners.add(listener);
	}

	/**
	* Removes the listener from the collection of listeners who will
	* be notified when the receiver's selection is about to change.
	*
	* @param listener the listener which should no longer be notified
	*
	* @exception IllegalArgumentException <ul>
	* <li>ERROR_NULL_ARGUMENT - if the listener is null</li>
	* </ul>
	* @exception SWTException <ul>
	* <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
	* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
	* </ul>
	*
	* @see VetoableSelectionListener
	* @see #addVetoableSelectionListener
	*/
	public void removeVetoableSelectionListener(VetoableSelectionListener listener) {
	widgetChangeListeners.remove(listener);
	}


	private List widgetSelectedListeners = new ArrayList();

	protected void fireWidgetSelectedEvent(SelectionEvent e) {
	for (Iterator listenersIter = widgetSelectedListeners.iterator(); listenersIter.hasNext();) {
	SelectionListener listener = (SelectionListener) listenersIter.next();
	listener.widgetSelected(e);
	}
	}

	protected void fireWidgetDefaultSelectedEvent(SelectionEvent e) {
	fireWidgetSelectedEvent(e);
	}

	/**
	* Adds the listener to the collection of listeners who will
	* be notified when the receiver's selection changes, by sending
	* it one of the messages defined in the <code>SelectionListener</code>
	* interface.
	* <p>
	* <code>widgetSelected</code> is called when the selection changes.
	* <code>widgetDefaultSelected</code> is typically called when an item is double-clicked.
	* </p>
	*
	* @param listener the listener which should be notified
	*
	* @exception IllegalArgumentException <ul>
	* <li>ERROR_NULL_ARGUMENT - if the listener is null</li>
	* </ul>
	* @exception SWTException <ul>
	* <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
	* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
	* </ul>
	*
	* @see SelectionListener
	* @see #removeSelectionListener
	* @see SelectionEvent
	*/
	public void addSelectionListener(SelectionListener listener) {
	widgetSelectedListeners.add(listener);
	}

	/**
	* Removes the listener from the collection of listeners who will
	* be notified when the receiver's selection changes.
	*
	* @param listener the listener which should no longer be notified
	*
	* @exception IllegalArgumentException <ul>
	* <li>ERROR_NULL_ARGUMENT - if the listener is null</li>
	* </ul>
	* @exception SWTException <ul>
	* <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
	* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
	* </ul>
	*
	* @see SelectionListener
	* @see #addSelectionListener
	*/
	public void removeSelectionListener(SelectionListener listener) {
	widgetSelectedListeners.remove(listener);
	}

	/**
	* Deselects the item at the given zero-relative index in the receiver.
	* If the item at the index was already deselected, it remains
	* deselected. Indices that are out of range are ignored.
	*
	* @param index the index of the item to deselect
	*
	* @exception SWTException <ul>
	* <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
	* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
	* </ul>
	*/
	public void deselect (int index) {
	if (index < 0 \|\| index >= buttons.length)
	return;
	buttons[index].setSelection(false);
	}

	/**
	* Deselects all selected items in the receiver.
	*
	* @exception SWTException <ul>
	* <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
	* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
	* </ul>
	*/
	public void deselectAll () {
	for (int i = 0; i < buttons.length; i++)
	buttons[i].setSelection(false);
	}

	/**
	* Returns the zero-relative index of the item which currently
	* has the focus in the receiver, or -1 if no item has focus.
	*
	* @return the index of the selected item
	*
	* @exception SWTException <ul>
	* <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
	* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
	* </ul>
	*/
	public int getFocusIndex () {
	for (int i = 0; i < buttons.length; i++) {
	if (buttons[i].isFocusControl()) {
	return i;
	}
	}
	return -1;
	}

	/**
	* Returns the item at the given, zero-relative index in the
	* receiver. Throws an exception if the index is out of range.
	*
	* @param index the index of the item to return
	* @return the item at the given index
	*
	* @exception IllegalArgumentException <ul>
	* <li>ERROR_INVALID_RANGE - if the index is not between 0 and the number of elements in the list minus 1 (inclusive)</li>
	* </ul>
	* @exception SWTException <ul>
	* <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
	* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
	* </ul>
	*
	* FIXME: tck - this should be renamed to getItemText()
	*/
	public String getItem (int index) {
	if (index < 0 \|\| index >= buttons.length)
	SWT.error(SWT.ERROR_INVALID_RANGE, null, "getItem for a nonexistant item");
	return buttons[index].getText();
	}

	/**
	* Returns the number of items contained in the receiver.
	*
	* @return the number of items
	*
	* @exception SWTException <ul>
	* <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
	* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
	* </ul>
	*/
	public int getItemCount () {
	return buttons.length;
	}

	/**
	* Returns a (possibly empty) array of <code>String</code>s which
	* are the items in the receiver.
	* <p>
	* Note: This is not the actual structure used by the receiver
	* to maintain its list of items, so modifying the array will
	* not affect the receiver.
	* </p>
	*
	* @return the items in the receiver's list
	*
	* @exception SWTException <ul>
	* <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
	* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
	* </ul>
	*/
	public String [] getItems () {
	List itemStrings = new ArrayList();
	for (int i = 0; i < buttons.length; i++) {
	itemStrings.add(buttons[i].getText());
	}
	return (String[]) itemStrings.toArray(new String[itemStrings.size()]);
	}

	public Object[] getButtons() {
	return buttons;
	}

	/**
	* Returns the zero-relative index of the item which is currently
	* selected in the receiver, or -1 if no item is selected.
	*
	* @return the index of the selected item or -1
	*
	* @exception SWTException <ul>
	* <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
	* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
	* </ul>
	*/
	public int getSelectionIndex () {
	for (int i = 0; i < buttons.length; i++) {
	if (buttons[i].getSelection() == true) {
	return i;
	}
	}
	return -1;
	}

	/**
	* Gets the index of an item.
	* <p>
	* The list is searched starting at 0 until an
	* item is found that is equal to the search item.
	* If no item is found, -1 is returned. Indexing
	* is zero based.
	*
	* @param string the search item
	* @return the index of the item
	*
	* @exception IllegalArgumentException <ul>
	* <li>ERROR_NULL_ARGUMENT - if the string is null</li>
	* </ul>
	* @exception SWTException <ul>
	* <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
	* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
	* </ul>
	*/
	public int indexOf (String string) {
	for (int i = 0; i < buttons.length; i++) {
	if (buttons[i].getText().equals(string)) {
	return i;
	}
	}
	return -1;
	}

	/**
	* Searches the receiver's list starting at the given,
	* zero-relative index until an item is found that is equal
	* to the argument, and returns the index of that item. If
	* no item is found or the starting index is out of range,
	* returns -1.
	*
	* @param string the search item
	* @param start the zero-relative index at which to start the search
	* @return the index of the item
	*
	* @exception IllegalArgumentException <ul>
	* <li>ERROR_NULL_ARGUMENT - if the string is null</li>
	* </ul>
	* @exception SWTException <ul>
	* <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
	* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
	* </ul>
	*/
	public int indexOf (String string, int start) {
	for (int i = start; i < buttons.length; i++) {
	if (buttons[i].getText().equals(string)) {
	return i;
	}
	}
	return -1;
	}

	/**
	* Returns <code>true</code> if the item is selected,
	* and <code>false</code> otherwise. Indices out of
	* range are ignored.
	*
	* @param index the index of the item
	* @return the visibility state of the item at the index
	*
	* @exception SWTException <ul>
	* <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
	* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
	* </ul>
	*/
	public boolean isSelected (int index) {
	return buttons[index].getSelection();
	}

	/**
	* Selects the item at the given zero-relative index in the receiver's
	* list. If the item at the index was already selected, it remains
	* selected. Indices that are out of range are ignored.
	*
	* @param index the index of the item to select
	*
	* @exception SWTException <ul>
	* <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
	* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
	* </ul>
	*/
	public void select (int index) {
	if (index < 0 \|\| index >= buttons.length)
	return;
	buttons[index].setSelection(true);
	}

	/**
	* Sets the text of the item in the receiver's list at the given
	* zero-relative index to the string argument. This is equivalent
	* to <code>remove</code>'ing the old item at the index, and then
	* <code>add</code>'ing the new item at that index.
	*
	* @param index the index for the item
	* @param string the new text for the item
	*
	* @exception IllegalArgumentException <ul>
	* <li>ERROR_INVALID_RANGE - if the index is not between 0 and the number of elements in the list minus 1 (inclusive)</li>
	* <li>ERROR_NULL_ARGUMENT - if the string is null</li>
	* </ul>
	* @exception SWTException <ul>
	* <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
	* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
	* </ul>
	*/
	public void setItem (int index, String string) {
	if (index < 0 \|\| index >= buttons.length)
	SWT.error(SWT.ERROR_INVALID_RANGE, null, "setItem for a nonexistant item");
	buttons[index].setText(string);
	}

	/**
	* Selects the item at the given zero-relative index in the receiver.
	* If the item at the index was already selected, it remains selected.
	* The current selection is first cleared, then the new item is selected.
	* Indices that are out of range are ignored.
	*
	* @param index the index of the item to select
	*
	* @exception SWTException <ul>
	* <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
	* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
	* </ul>
	* @see List#deselectAll()
	* @see List#select(int)
	*/
	public void setSelection (int index) {
	if (index < 0 \|\| index > buttons.length - 1) {
	return;
	}
	buttons[index].setSelection(true);
	}

	}