/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 1997-2007 Sun Microsystems, Inc. All rights reserved.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common
 * Development and Distribution License("CDDL") (collectively, the
 * "License"). You may not use this file except in compliance with the
 * License. You can obtain a copy of the License at
 * http://www.netbeans.org/cddl-gplv2.html
 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
 * specific language governing permissions and limitations under the
 * License.  When distributing the software, include this License Header
 * Notice in each file and include the License file at
 * nbbuild/licenses/CDDL-GPL-2-CP.  Sun designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Sun in the GPL Version 2 section of the License file that
 * accompanied this code. If applicable, add the following below the
 * License Header, with the fields enclosed by brackets [] replaced by
 * your own identifying information:
 * "Portions Copyrighted [year] [name of copyright owner]"
 *
 * Contributor(s): Alexandre Iline.
 *
 * The Original Software is the Jemmy library.
 * The Initial Developer of the Original Software is Alexandre Iline.
 * All Rights Reserved.
 *
 * If you wish your version of this file to be governed by only the CDDL
 * or only the GPL Version 2, indicate your decision by adding
 * "[Contributor] elects to include this software in this distribution
 * under the [CDDL or GPL Version 2] license." If you do not indicate a
 * single choice of license, a recipient has the option to distribute
 * your version of this file under either the CDDL, the GPL Version 2 or
 * to extend the choice of license to its licensees as provided above.
 * However, if you add GPL Version 2 code and therefore, elected the GPL
 * Version 2 license, then the option applies only if the new code is
 * made subject to such option by the copyright holder.
 *
 *
 *
 * $Id$ $Revision$ $Date$
 *
 */

package org.netbeans.jemmy.operators;

import java.awt.Color;
import java.awt.Component;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.Point;
import java.awt.Rectangle;
import java.util.Hashtable;
import java.util.Vector;

import javax.swing.JList;
import javax.swing.JScrollPane;
import javax.swing.ListCellRenderer;
import javax.swing.ListModel;
import javax.swing.ListSelectionModel;
import javax.swing.event.ListSelectionListener;
import javax.swing.plaf.ListUI;

import org.netbeans.jemmy.ComponentChooser;
import org.netbeans.jemmy.ComponentSearcher;
import org.netbeans.jemmy.JemmyInputException;
import org.netbeans.jemmy.Outputable;
import org.netbeans.jemmy.QueueTool;
import org.netbeans.jemmy.TestOut;
import org.netbeans.jemmy.TimeoutExpiredException;
import org.netbeans.jemmy.drivers.DriverManager;
import org.netbeans.jemmy.drivers.MultiSelListDriver;
import org.netbeans.jemmy.util.EmptyVisualizer;

/**
 * <BR><BR>Timeouts used: <BR>
 * ComponentOperator.WaitComponentTimeout - time to wait component displayed <BR>
 * ComponentOperator.WaitStateTimeout - time to wait for item, and for item to be selected <BR>
 * JScrollBarOperator.OneScrollClickTimeout - time for one scroll click <BR>
 * JScrollBarOperator.WholeScrollTimeout - time for the whole scrolling <BR>.
 *
 * @see org.netbeans.jemmy.Timeouts
 *
 * @author Alexandre Iline (alexandre.iline@sun.com)
 *	
 */

public class JListOperator extends JComponentOperator
    implements Outputable {

    /**
     * Identifier for a "item" properties.
     * @see #getDump
     */
    public static final String ITEM_PREFIX_DPROP = "Item";

    /**
     * Identifier for a "selected item" property.
     * @see #getDump
     */
    public static final String SELECTED_ITEM_PREFIX_DPROP = "SelectedItem";

    private TestOut output;
    private MultiSelListDriver driver;

    /**
     * Constructor.
     * @param b a component
     */
    public JListOperator(JList b) {
	super(b);
	driver = DriverManager.getMultiSelListDriver(getClass());
    }

    /**
     * Constructs a JListOperator object.
     * @param cont a container
     * @param chooser a component chooser specifying searching criteria.
     * @param index an index between appropriate ones.
     */
    public JListOperator(ContainerOperator cont, ComponentChooser chooser, int index) {
	this((JList)cont.
             waitSubComponent(new JListFinder(chooser),
                              index));
	copyEnvironment(cont);
    }

    /**
     * Constructs a JListOperator object.
     * @param cont a container
     * @param chooser a component chooser specifying searching criteria.
     */
    public JListOperator(ContainerOperator cont, ComponentChooser chooser) {
	this(cont, chooser, 0);
    }

    /**
     * Constructor.
     * Waits item text first.
     * Uses cont's timeout and output for waiting and to init operator.
     * @param cont a container
     * @param text Text of item which is currently selected. 
     * @param itemIndex Item index.
     * @param index Ordinal component index.
     * 
     */
    public JListOperator(ContainerOperator cont, String text, int itemIndex, int index) {
	this((JList)waitComponent(cont, 
				  new JListByItemFinder(text, itemIndex,
							cont.getComparator()),
				  index));
	copyEnvironment(cont);
    }

    /**
     * Constructor.
     * Waits component by selected item text first.
     * Uses cont's timeout and output for waiting and to init operator.
     * @param cont a container
     * @param text Text of item which is currently selected. 
     * @param index Ordinal component index.
     * @see ComponentOperator#isCaptionEqual(String, String, boolean, boolean)
     * 
     */
    public JListOperator(ContainerOperator cont, String text, int index) {
	this(cont, text, -1, index);
    }

    /**
     * Constructor.
     * Waits component in container first.
     * Uses cont's timeout and output for waiting and to init operator.
     * @param cont a container
     * @param text Text of item which is currently selected. 
     * @see ComponentOperator#isCaptionEqual(String, String, boolean, boolean)
     * 
     */
    public JListOperator(ContainerOperator cont, String text) {
	this(cont, text, 0);
    }

    /**
     * Constructor.
     * Waits component in container first.
     * Uses cont's timeout and output for waiting and to init operator.
     * @param cont a container
     * @param index Ordinal component index.
     * 
     */
    public JListOperator(ContainerOperator cont, int index) {
	this((JList)
	     waitComponent(cont, 
			   new JListFinder(),
			   index));
	copyEnvironment(cont);
    }

    /**
     * Constructor.
     * Waits component in container first.
     * Uses cont's timeout and output for waiting and to init operator.
     * @param cont a container
     * 
     */
    public JListOperator(ContainerOperator cont) {
	this(cont, 0);
    }

    /**
     * Searches JList in container.
     * @param cont Container to search component in.
     * @param chooser org.netbeans.jemmy.ComponentChooser implementation.
     * @param index Ordinal component index.
     * @return JList instance or null if component was not found.
     */
    public static JList findJList(Container cont, ComponentChooser chooser, int index) {
	return((JList)findComponent(cont, new JListFinder(chooser), index));
    }

    /**
     * Searches 0'th JList in container.
     * @param cont Container to search component in.
     * @param chooser org.netbeans.jemmy.ComponentChooser implementation.
     * @return JList instance or null if component was not found.
     */
    public static JList findJList(Container cont, ComponentChooser chooser) {
	return(findJList(cont, chooser, 0));
    }

    /**
     * Searches JList by item.
     * @param cont Container to search component in.
     * @param text Item text. If null, contents is not checked.
     * @param ce Compare text exactly.
     * @param ccs Compare text case sensitively.
     * @param itemIndex Index of item to compare text. If -1, selected item is checked.
     * @param index Ordinal component index.
     * @return JList instance or null if component was not found.
     * @see ComponentOperator#isCaptionEqual(String, String, boolean, boolean)
     */
    public static JList findJList(Container cont, String text, boolean ce, boolean ccs, int itemIndex, int index) {
	return(findJList(cont, new JListByItemFinder(text, itemIndex, new DefaultStringComparator(ce, ccs)), index));
    }

    /**
     * Searches JList by item.
     * @param cont Container to search component in.
     * @param text Item text. If null, contents is not checked.
     * @param ce Compare text exactly.
     * @param ccs Compare text case sensitively.
     * @param itemIndex Index of item to compare text. If -1, selected item is checked.
     * @return JList instance or null if component was not found.
     * @see ComponentOperator#isCaptionEqual(String, String, boolean, boolean)
     */
    public static JList findJList(Container cont, String text, boolean ce, boolean ccs, int itemIndex) {
	return(findJList(cont, text, ce, ccs, itemIndex, 0));
    }

    /**
     * Waits JList in container.
     * @param cont Container to search component in.
     * @param chooser org.netbeans.jemmy.ComponentChooser implementation.
     * @param index Ordinal component index.
     * @return JList instance or null if component was not found.
     * 
     */
    public static JList waitJList(Container cont, ComponentChooser chooser, int index) {
	return((JList)waitComponent(cont, new JListFinder(chooser), index));
    }

    /**
     * Waits 0'th JList in container.
     * @param cont Container to search component in.
     * @param chooser org.netbeans.jemmy.ComponentChooser implementation.
     * @return JList instance or null if component was not found.
     * 
     */
    public static JList waitJList(Container cont, ComponentChooser chooser) {
	return(waitJList(cont, chooser, 0));
    }

    /**
     * Waits JList by item.
     * @param cont Container to search component in.
     * @param text Item text. If null, contents is not checked.
     * @param ce Compare text exactly.
     * @param ccs Compare text case sensitively.
     * @param itemIndex Index of item to compare text. If -1, selected item is checked.
     * @param index Ordinal component index.
     * @return JList instance or null if component was not found.
     * @see ComponentOperator#isCaptionEqual(String, String, boolean, boolean)
     * 
     */
    public static JList waitJList(Container cont, String text, boolean ce, boolean ccs, int itemIndex, int index) {
	return(waitJList(cont, new JListByItemFinder(text, itemIndex, new DefaultStringComparator(ce, ccs)), index));
    }

    /**
     * Waits JList by item.
     * @param cont Container to search component in.
     * @param text Item text. If null, contents is not checked.
     * @param ce Compare text exactly.
     * @param ccs Compare text case sensitively.
     * @param itemIndex Index of item to compare text. If -1, selected item is checked.
     * @return JList instance or null if component was not found.
     * @see ComponentOperator#isCaptionEqual(String, String, boolean, boolean)
     * 
     */
    public static JList waitJList(Container cont, String text, boolean ce, boolean ccs, int itemIndex) {
	return(waitJList(cont, text, ce, ccs, itemIndex, 0));
    }

    public void setOutput(TestOut output) {
	super.setOutput(output.createErrorOutput());
	this.output = output;
    }

    public TestOut getOutput() {
	return(output);
    }

    public void copyEnvironment(Operator anotherOperator) {
	super.copyEnvironment(anotherOperator);
	driver = 
	    (MultiSelListDriver)DriverManager.
	    getDriver(DriverManager.MULTISELLIST_DRIVER_ID,
		      getClass(), 
		      anotherOperator.getProperties());
    }

    /**
     * Gets point to click on itemIndex'th item.
     * @param itemIndex an index of an item to click.
     * @return a Point in component's coordinate system.
     */
    public Point getClickPoint(int itemIndex) {
	Rectangle rect = getCellBounds(itemIndex, itemIndex);
	return(new Point(rect.x + rect.width / 2,
			 rect.y + rect.height / 2));
    }

    /**
     * Ask renderer for component to be displayed.
     * @param itemIndex Item index.
     * @param isSelected True if the specified cell was selected.
     * @param cellHasFocus True if the specified cell has the focus.
     * @return Component to be displayed.
     */
    public Component getRenderedComponent(int itemIndex, boolean isSelected, boolean cellHasFocus) {
	return(getCellRenderer().
	       getListCellRendererComponent((JList)getSource(),
					    getModel().getElementAt(itemIndex),
					    itemIndex,
					    isSelected,
					    cellHasFocus));
    }

    /**
     * Ask renderer for component to be displayed.
     * Uses isSelectedIndex(itemIndex) to determine whether item is selected.
     * Supposes item do not have focus.
     * @param itemIndex Item index.
     * @return Component to be displayed.
     */
    public Component getRenderedComponent(int itemIndex) {
	return(getRenderedComponent(itemIndex, isSelectedIndex(itemIndex), false));
    }

    /**
     * Searches for index'th item good from chooser's point of view.
     * @param chooser Item verifying object.
     * @param index Ordinal item index.
     * @return Item index or -1 if search was insuccessful.
     */
    public int findItemIndex(ListItemChooser chooser, int index) {
	ListModel model = getModel();
	int count = 0;
	for(int i = 0; i < model.getSize(); i++) {
	    if(chooser.checkItem(this, i)) {
		if(count == index) {
		    return(i);
		} else {
		    count++;
		}
	    }
	}
	return(-1);
    }

    /**
     * Searches for an item good from chooser's point of view.
     * @param chooser Item verifying object.
     * @return Item index or -1 if serch was insuccessful.
     * @see #findItemIndex(JListOperator.ListItemChooser, int)
     * @see #findItemIndex(String, boolean, boolean)
     */
    public int findItemIndex(ListItemChooser chooser) {
	return(findItemIndex(chooser, 0));
    }

    /**
     * Searches for an item good from chooser's point of view.
     * @param item a text pattern
     * @param comparator a string comparision algorithm
     * @param index Ordinal item index.
     * @return Item index or -1 if serch was insuccessful.
     * @see #findItemIndex(JListOperator.ListItemChooser, int)
     * @see #findItemIndex(String, boolean, boolean)
     */
    public int findItemIndex(String item, StringComparator comparator, int index){
	return(findItemIndex(new BySubStringListItemChooser(item, comparator), index));
    }

    /**
     * Searched for index'th item by text.
     * @param item a text pattern
     * @param ce Compare text exactly.
     * @param cc Compare text case sensitively.
     * @param index Ordinal item index.
     * @return Item index or -1 if serch was insuccessful.
     * @see ComponentOperator#isCaptionEqual(String, String, boolean, boolean)
     * @deprecated Use findItemIndex(String, int) or findItemIndex(String, StringComparator, int)
     */
    public int findItemIndex(String item, boolean ce, boolean cc, int index){
	return(findItemIndex(item, new DefaultStringComparator(ce, cc), index));
    }
    
    /**
     * Searched for index'th item by text.
     * Uses StringComparator assigned to this object.
     * @param item a text pattern
     * @param index Ordinal item index.
     * @return Item index or -1 if search was insuccessful.
     */
    public int findItemIndex(String item, int index){
	return(findItemIndex(item, getComparator(), index));
    }
    
    /**
     * Searches for an item good from chooser's point of view.
     * @param item a text pattern
     * @param comparator a string comparision algorithm
     * @return Item index or -1 if serch was insuccessful.
     * @see #findItemIndex(JListOperator.ListItemChooser, int)
     * @see #findItemIndex(String, boolean, boolean)
     */
    public int findItemIndex(String item, StringComparator comparator){
	return(findItemIndex(item, comparator, 0));
    }

    /**
     * Searched  item by text.
     * @param item a text pattern
     * @param ce Compare text exactly.
     * @param cc Compare text case sensitively.
     * @return Item index or -1 if search was insuccessful.
     * @see ComponentOperator#isCaptionEqual(String, String, boolean, boolean)
     * @deprecated Use findItemIndex(String) or findItemIndex(String, StringComparator)
     */
    public int findItemIndex(String item, boolean ce, boolean cc) {
	return(findItemIndex(item, ce, cc, 0));
    }
    
    /**
     * Searched for first item by text.
     * Uses StringComparator assigned to this object.
     * @param item a text pattern
     * @return Item index or -1 if search was insuccessful.
     * @see ComponentOperator#isCaptionEqual(String, String, boolean, boolean)
     */
    public int findItemIndex(String item){
	return(findItemIndex(item, 0));
    }
    
    /**
     * Searches for index'th item by rendered component.
     * @param chooser Component verifying object.
     * @param index Ordinal item index.
     * @return Item index or -1 if serch was insuccessful.
     * @see #getRenderedComponent(int, boolean, boolean)
     */
    public int findItemIndex(ComponentChooser chooser, int index) {
	return(findItemIndex(new ByRenderedComponentListItemChooser(chooser), index));
    }
    
    /**
     * Searches for an item by rendered component.
     * @param chooser Component verifying object.
     * @return Item index or -1 if serch was insuccessful.
     * @see #getRenderedComponent(int, boolean, boolean)
     */
    public int findItemIndex(ComponentChooser chooser) {
	return(findItemIndex(chooser, 0));
    }
    
    /**
     * Clicks on item by item index.
     * @param itemIndex Item index.
     * @param clickCount count click.
     * @return Click point or null if list does not contains itemIndex'th item.
     * @throws NoSuchItemException
     */
    public Object clickOnItem(final int itemIndex, final int clickCount) {
	output.printLine("Click " + Integer.toString(clickCount) +
			 " times on JList\n    : " + toStringSource());
	output.printGolden("Click " + Integer.toString(clickCount) +
			 " times on JList");
        checkIndex(itemIndex);
	try {
	    scrollToItem(itemIndex);
	} catch(TimeoutExpiredException e) {
	    output.printStackTrace(e);
	}
	if(((JList)getSource()).getModel().getSize() <= itemIndex) {
	    output.printErrLine("JList " + toStringSource() + " does not contain " +
				Integer.toString(itemIndex) + "'th item");
	    return(null);
	}
	if(((JList)getSource()).getAutoscrolls()) {
	    ((JList)getSource()).ensureIndexIsVisible(itemIndex);
	}
        return(getQueueTool().invokeSmoothly(new QueueTool.QueueAction("Path selecting") {
                public Object launch() {
                    Rectangle rect = getCellBounds(itemIndex, itemIndex);
                    if(rect == null) {
                        output.printErrLine("Impossible to determine click point for " +
                                            Integer.toString(itemIndex) + "'th item");
                        return(null);
                    }
                    Point point = new Point((int)(rect.getX() + rect.getWidth() / 2),
                                            (int)(rect.getY() + rect.getHeight() / 2));
                    Object result = getModel().getElementAt(itemIndex);
                    clickMouse(point.x, point.y, clickCount);
                    return(result);
                }
            }));
    }
    
    /**
     * Finds item by item text, and do mouse click on it.
     * @param item Item text.
     * @param comparator a string comparision algorithm
     * @param clickCount count click.
     * @return Click point or null if list does not contains itemIndex'th item.
     * @throws NoSuchItemException
     */
    public Object clickOnItem(final String item, final StringComparator comparator, final int clickCount) {
        scrollToItem(findItemIndex(item, comparator, 0));
        return(getQueueTool().invokeSmoothly(new QueueTool.QueueAction("Path selecting") {
                public Object launch() {
                    int index = findItemIndex(item, comparator, 0);
                    if(index != -1) {
                        return(clickOnItem(index, clickCount));
                    } else {
                        throw(new NoSuchItemException(item));
                    }
                }
            }));
    }
    
    /**
     * Finds item by item text, and do mouse click on it.
     * @param item Item text.
     * @param ce Compare exactly.
     * @param cc Compare case sensitively.
     * @param clickCount count click.
     * @return Click point or null if list does not contains itemIndex'th item.
     * @throws NoSuchItemException
     * @deprecated Use clickOnItem(String, int) or clickOnItem(String, StringComparator, int)
     */
    public Object clickOnItem(String item, boolean ce, boolean cc, int clickCount) {
	return(clickOnItem(item, new DefaultStringComparator(ce, cc), clickCount));
    }

    /**
     * Finds item by item text, and do mouse click on it.
     * Uses StringComparator assigned to this object.
     * @param item Item text.
     * @param clickCount count click.
     * @return Click point or null if list does not contains itemIndex'th item.
     * @throws NoSuchItemException
     */
    public Object clickOnItem(String item, int clickCount) {
	return(clickOnItem(item, getComparator(), clickCount));
    }

    /**
     * Finds item by item text, and do simple mouse click on it.
     * Uses StringComparator assigned to this object.
     * @param item Item text.
     * @param comparator a string comparision algorithm
     * @return Click point or null if list does not contains itemIndex'th item.
     * @throws NoSuchItemException
     */
    public Object clickOnItem(String item, StringComparator comparator) {
	return(clickOnItem(item, comparator, 1));
    }

    /**
     * Finds item by item text, and do simple mouse click on it.
     * @param item Item text.
     * @param ce Compare exactly.
     * @param cc Compare case sensitively.
     * @return Click point or null if list does not contains itemIndex'th item.
     * @throws NoSuchItemException
     * @deprecated Use clickOnItem(String) or clickOnItem(String, StringComparator)
     */
    public Object clickOnItem(String item, boolean ce, boolean cc) {
	return(clickOnItem(item, ce, cc, 1));
    }

    /**
     * Finds item by item text, and do simple mouse click on it.
     * Uses StringComparator assigned to this object.
     * @param item Item text.
     * @return Click point or null if list does not contains itemIndex'th item.
     * @throws NoSuchItemException
     */
    public Object clickOnItem(String item) {
	return(clickOnItem(item, 0));
    }

    /**
     * Scrolls to an item if the list is on a JScrollPane component.
     * @param itemIndex an item index.
     * @see #scrollToItem(String, boolean, boolean)
     * 
     * @throws NoSuchItemException
     */
    public void scrollToItem(int itemIndex) {
	output.printTrace("Scroll JList to " + Integer.toString(itemIndex) + "'th item\n    : " +
			  toStringSource());
	output.printGolden("Scroll JList to " + Integer.toString(itemIndex) + "'th item");
        checkIndex(itemIndex);
	makeComponentVisible();
	//try to find JScrollPane under.
	JScrollPane scroll = (JScrollPane)getContainer(new JScrollPaneOperator.
						       JScrollPaneFinder(ComponentSearcher.
									 getTrueChooser("JScrollPane")));
	if(scroll == null) {
	    return;
	}
	JScrollPaneOperator scroller = new JScrollPaneOperator(scroll);
	scroller.copyEnvironment(this);
	scroller.setVisualizer(new EmptyVisualizer());
	Rectangle rect = getCellBounds(itemIndex, itemIndex);
	scroller.scrollToComponentRectangle(getSource(), 
					    (int)rect.getX(),
					    (int)rect.getY(),
					    (int)rect.getWidth(),
					    (int)rect.getHeight());
    }

    /**
     * Scrolls to an item if the list is on a JScrollPane component.
     * @param item Item text
     * @param comparator a string comparision algorithm
     * @see #scrollToItem(String, boolean, boolean)
     * 
     */
    public void scrollToItem(String item, StringComparator comparator) {
	scrollToItem(findItemIndex(item, comparator));
    }

    /**
     * Scrolls to an item if the list is on a JScrollPane component.
     * @param item Item text
     * @param ce Compare exactly.
     * @param cc Compare case sensitively.
     * @see #scrollToItem(String, boolean, boolean)
     * 
     * @deprecated Use scrollToItem(String) or scrollToItem(String, StringComparator)
     */
    public void scrollToItem(String item, boolean ce, boolean cc) {
	scrollToItem(findItemIndex(item, ce, cc));
    }

    /**
     * Selects an item by index.
     * @param index an item index.
     */
    public void selectItem(int index) {
        checkIndex(index);
        driver.selectItem(this, index);
	if(getVerification()) {
            waitItemSelection(index, true);
        }
    }

    /**
     * Selects an item by text.
     * @param item an item text.
     */
    public void selectItem(final String item) {
        scrollToItem(findItemIndex(item));
        getQueueTool().invokeSmoothly(new QueueTool.QueueAction("Path selecting") {
                public Object launch() {
                    driver.selectItem(JListOperator.this, findItemIndex(item));
                    return(null);
                }
            });
    }

    /**
     * Selects items by indices.
     * @param indices item indices.
     */
    public void selectItems(int[] indices) {
        checkIndices(indices);
	driver.selectItems(this, indices);
	if(getVerification()) {
            waitItemsSelection(indices, true);
        }
    }

    /**
     * Selects items by texts.
     * @param items item texts.
     */
    public void selectItem(String[] items) {
	int[] indices = new int[items.length];
	for(int i = 0; i < items.length; i++) {
	    indices[i] = findItemIndex(items[i]);
	}
	selectItems(indices);
    }

    /**
     * Waits for items to be selected.
     * @param itemIndices item indices to be selected
     * @param selected Selected (true) or unselected (false).
     */
    public void waitItemsSelection(final int[] itemIndices, final boolean selected) {
	getOutput().printLine("Wait items to be " +
			      (selected ? "" : "un") + "selected in component \n    : "+
			      toStringSource());
	getOutput().printGolden("Wait items to be " +
				(selected ? "" : "un") + "selected");
	waitState(new ComponentChooser() {
		public boolean checkComponent(Component comp) {
                    int[] indices = getSelectedIndices();
                    for(int i = 0; i < indices.length; i++) {
                        if(indices[i] != itemIndices[i]) {
                            return(false);
                        }
                    }
                    return(true);
		}
		public String getDescription() {
		    return("Item has been " + 
			   (selected ? "" : "un") + "selected");
		}
	    });
    }

    /**
     * Waits for item to be selected.
     * @param itemIndex an item needs to be selected
     * @param selected Selected (true) or unselected (false).
     */
    public void waitItemSelection(final int itemIndex, final boolean selected) {
        waitItemsSelection(new int[] {itemIndex}, selected);
    }

    /**
     * Waits for item. Uses getComparator() comparator.
     * @param item an item text
     * @param itemIndex Index of item to check or -1 to check selected item.
     */
    public void waitItem(String item, int itemIndex) {
	getOutput().printLine("Wait \"" + item + "\" at the " + Integer.toString(itemIndex) + 
			      " position in component \n    : "+
			      toStringSource());
	getOutput().printGolden("Wait \"" + item + "\" at the " + Integer.toString(itemIndex) + 
				" position");
	waitState(new JListByItemFinder(item, itemIndex, getComparator()));
    }

    /**
     * Returns information about component.
     */
    public Hashtable getDump() {
	Hashtable result = super.getDump();
	String[] items = new String[((JList)getSource()).getModel().getSize()];
	for(int i = 0; i < ((JList)getSource()).getModel().getSize(); i++) {
	    items[i] = ((JList)getSource()).getModel().getElementAt(i).toString();
	}
	int[] selectedIndices = ((JList)getSource()).getSelectedIndices();
	String[] selectedItems = new String[selectedIndices.length];
	for(int i = 0; i < selectedIndices.length; i++) {
	    selectedItems[i] = items[selectedIndices[i]];
	}
	addToDump(result, ITEM_PREFIX_DPROP, items);
	addToDump(result, SELECTED_ITEM_PREFIX_DPROP, selectedItems);
	return(result);
    }

    ////////////////////////////////////////////////////////
    //Mapping                                             //

    /**Maps <code>JList.addListSelectionListener(ListSelectionListener)</code> through queue*/
    public void addListSelectionListener(final ListSelectionListener listSelectionListener) {
	runMapping(new MapVoidAction("addListSelectionListener") {
		public void map() {
		    ((JList)getSource()).addListSelectionListener(listSelectionListener);
		}});}

    /**Maps <code>JList.addSelectionInterval(int, int)</code> through queue*/
    public void addSelectionInterval(final int i, final int i1) {
	runMapping(new MapVoidAction("addSelectionInterval") {
		public void map() {
		    ((JList)getSource()).addSelectionInterval(i, i1);
		}});}

    /**Maps <code>JList.clearSelection()</code> through queue*/
    public void clearSelection() {
	runMapping(new MapVoidAction("clearSelection") {
		public void map() {
		    ((JList)getSource()).clearSelection();
		}});}

    /**Maps <code>JList.ensureIndexIsVisible(int)</code> through queue*/
    public void ensureIndexIsVisible(final int i) {
	runMapping(new MapVoidAction("ensureIndexIsVisible") {
		public void map() {
		    ((JList)getSource()).ensureIndexIsVisible(i);
		}});}

    /**Maps <code>JList.getAnchorSelectionIndex()</code> through queue*/
    public int getAnchorSelectionIndex() {
	return(runMapping(new MapIntegerAction("getAnchorSelectionIndex") {
		public int map() {
		    return(((JList)getSource()).getAnchorSelectionIndex());
		}}));}

    /**Maps <code>JList.getCellBounds(int, int)</code> through queue*/
    public Rectangle getCellBounds(final int i, final int i1) {
	return((Rectangle)runMapping(new MapAction("getCellBounds") {
		public Object map() {
		    return(((JList)getSource()).getCellBounds(i, i1));
		}}));}

    /**Maps <code>JList.getCellRenderer()</code> through queue*/
    public ListCellRenderer getCellRenderer() {
	return((ListCellRenderer)runMapping(new MapAction("getCellRenderer") {
		public Object map() {
		    return(((JList)getSource()).getCellRenderer());
		}}));}

    /**Maps <code>JList.getFirstVisibleIndex()</code> through queue*/
    public int getFirstVisibleIndex() {
	return(runMapping(new MapIntegerAction("getFirstVisibleIndex") {
		public int map() {
		    return(((JList)getSource()).getFirstVisibleIndex());
		}}));}

    /**Maps <code>JList.getFixedCellHeight()</code> through queue*/
    public int getFixedCellHeight() {
	return(runMapping(new MapIntegerAction("getFixedCellHeight") {
		public int map() {
		    return(((JList)getSource()).getFixedCellHeight());
		}}));}

    /**Maps <code>JList.getFixedCellWidth()</code> through queue*/
    public int getFixedCellWidth() {
	return(runMapping(new MapIntegerAction("getFixedCellWidth") {
		public int map() {
		    return(((JList)getSource()).getFixedCellWidth());
		}}));}

    /**Maps <code>JList.getLastVisibleIndex()</code> through queue*/
    public int getLastVisibleIndex() {
	return(runMapping(new MapIntegerAction("getLastVisibleIndex") {
		public int map() {
		    return(((JList)getSource()).getLastVisibleIndex());
		}}));}

    /**Maps <code>JList.getLeadSelectionIndex()</code> through queue*/
    public int getLeadSelectionIndex() {
	return(runMapping(new MapIntegerAction("getLeadSelectionIndex") {
		public int map() {
		    return(((JList)getSource()).getLeadSelectionIndex());
		}}));}

    /**Maps <code>JList.getMaxSelectionIndex()</code> through queue*/
    public int getMaxSelectionIndex() {
	return(runMapping(new MapIntegerAction("getMaxSelectionIndex") {
		public int map() {
		    return(((JList)getSource()).getMaxSelectionIndex());
		}}));}

    /**Maps <code>JList.getMinSelectionIndex()</code> through queue*/
    public int getMinSelectionIndex() {
	return(runMapping(new MapIntegerAction("getMinSelectionIndex") {
		public int map() {
		    return(((JList)getSource()).getMinSelectionIndex());
		}}));}

    /**Maps <code>JList.getModel()</code> through queue*/
    public ListModel getModel() {
	return((ListModel)runMapping(new MapAction("getModel") {
		public Object map() {
		    return(((JList)getSource()).getModel());
		}}));}

    /**Maps <code>JList.getPreferredScrollableViewportSize()</code> through queue*/
    public Dimension getPreferredScrollableViewportSize() {
	return((Dimension)runMapping(new MapAction("getPreferredScrollableViewportSize") {
		public Object map() {
		    return(((JList)getSource()).getPreferredScrollableViewportSize());
		}}));}

    /**Maps <code>JList.getPrototypeCellValue()</code> through queue*/
    public Object getPrototypeCellValue() {
	return((Object)runMapping(new MapAction("getPrototypeCellValue") {
		public Object map() {
		    return(((JList)getSource()).getPrototypeCellValue());
		}}));}

    /**Maps <code>JList.getScrollableBlockIncrement(Rectangle, int, int)</code> through queue*/
    public int getScrollableBlockIncrement(final Rectangle rectangle, final int i, final int i1) {
	return(runMapping(new MapIntegerAction("getScrollableBlockIncrement") {
		public int map() {
		    return(((JList)getSource()).getScrollableBlockIncrement(rectangle, i, i1));
		}}));}

    /**Maps <code>JList.getScrollableTracksViewportHeight()</code> through queue*/
    public boolean getScrollableTracksViewportHeight() {
	return(runMapping(new MapBooleanAction("getScrollableTracksViewportHeight") {
		public boolean map() {
		    return(((JList)getSource()).getScrollableTracksViewportHeight());
		}}));}

    /**Maps <code>JList.getScrollableTracksViewportWidth()</code> through queue*/
    public boolean getScrollableTracksViewportWidth() {
	return(runMapping(new MapBooleanAction("getScrollableTracksViewportWidth") {
		public boolean map() {
		    return(((JList)getSource()).getScrollableTracksViewportWidth());
		}}));}

    /**Maps <code>JList.getScrollableUnitIncrement(Rectangle, int, int)</code> through queue*/
    public int getScrollableUnitIncrement(final Rectangle rectangle, final int i, final int i1) {
	return(runMapping(new MapIntegerAction("getScrollableUnitIncrement") {
		public int map() {
		    return(((JList)getSource()).getScrollableUnitIncrement(rectangle, i, i1));
		}}));}

    /**Maps <code>JList.getSelectedIndex()</code> through queue*/
    public int getSelectedIndex() {
	return(runMapping(new MapIntegerAction("getSelectedIndex") {
		public int map() {
		    return(((JList)getSource()).getSelectedIndex());
		}}));}

    /**Maps <code>JList.getSelectedIndices()</code> through queue*/
    public int[] getSelectedIndices() {
	return((int[])runMapping(new MapAction("getSelectedIndices") {
		public Object map() {
		    return(((JList)getSource()).getSelectedIndices());
		}}));}

    /**Maps <code>JList.getSelectedValue()</code> through queue*/
    public Object getSelectedValue() {
	return((Object)runMapping(new MapAction("getSelectedValue") {
		public Object map() {
		    return(((JList)getSource()).getSelectedValue());
		}}));}

    /**Maps <code>JList.getSelectedValues()</code> through queue*/
    public Object[] getSelectedValues() {
	return((Object[])runMapping(new MapAction("getSelectedValues") {
		public Object map() {
		    return(((JList)getSource()).getSelectedValues());
		}}));}

    /**Maps <code>JList.getSelectionBackground()</code> through queue*/
    public Color getSelectionBackground() {
	return((Color)runMapping(new MapAction("getSelectionBackground") {
		public Object map() {
		    return(((JList)getSource()).getSelectionBackground());
		}}));}

    /**Maps <code>JList.getSelectionForeground()</code> through queue*/
    public Color getSelectionForeground() {
	return((Color)runMapping(new MapAction("getSelectionForeground") {
		public Object map() {
		    return(((JList)getSource()).getSelectionForeground());
		}}));}

    /**Maps <code>JList.getSelectionMode()</code> through queue*/
    public int getSelectionMode() {
	return(runMapping(new MapIntegerAction("getSelectionMode") {
		public int map() {
		    return(((JList)getSource()).getSelectionMode());
		}}));}

    /**Maps <code>JList.getSelectionModel()</code> through queue*/
    public ListSelectionModel getSelectionModel() {
	return((ListSelectionModel)runMapping(new MapAction("getSelectionModel") {
		public Object map() {
		    return(((JList)getSource()).getSelectionModel());
		}}));}

    /**Maps <code>JList.getUI()</code> through queue*/
    public ListUI getUI() {
	return((ListUI)runMapping(new MapAction("getUI") {
		public Object map() {
		    return(((JList)getSource()).getUI());
		}}));}

    /**Maps <code>JList.getValueIsAdjusting()</code> through queue*/
    public boolean getValueIsAdjusting() {
	return(runMapping(new MapBooleanAction("getValueIsAdjusting") {
		public boolean map() {
		    return(((JList)getSource()).getValueIsAdjusting());
		}}));}

    /**Maps <code>JList.getVisibleRowCount()</code> through queue*/
    public int getVisibleRowCount() {
	return(runMapping(new MapIntegerAction("getVisibleRowCount") {
		public int map() {
		    return(((JList)getSource()).getVisibleRowCount());
		}}));}

    /**Maps <code>JList.indexToLocation(int)</code> through queue*/
    public Point indexToLocation(final int i) {
	return((Point)runMapping(new MapAction("indexToLocation") {
		public Object map() {
		    return(((JList)getSource()).indexToLocation(i));
		}}));}

    /**Maps <code>JList.isSelectedIndex(int)</code> through queue*/
    public boolean isSelectedIndex(final int i) {
	return(runMapping(new MapBooleanAction("isSelectedIndex") {
		public boolean map() {
		    return(((JList)getSource()).isSelectedIndex(i));
		}}));}

    /**Maps <code>JList.isSelectionEmpty()</code> through queue*/
    public boolean isSelectionEmpty() {
	return(runMapping(new MapBooleanAction("isSelectionEmpty") {
		public boolean map() {
		    return(((JList)getSource()).isSelectionEmpty());
		}}));}

    /**Maps <code>JList.locationToIndex(Point)</code> through queue*/
    public int locationToIndex(final Point point) {
	return(runMapping(new MapIntegerAction("locationToIndex") {
		public int map() {
		    return(((JList)getSource()).locationToIndex(point));
		}}));}

    /**Maps <code>JList.removeListSelectionListener(ListSelectionListener)</code> through queue*/
    public void removeListSelectionListener(final ListSelectionListener listSelectionListener) {
	runMapping(new MapVoidAction("removeListSelectionListener") {
		public void map() {
		    ((JList)getSource()).removeListSelectionListener(listSelectionListener);
		}});}

    /**Maps <code>JList.removeSelectionInterval(int, int)</code> through queue*/
    public void removeSelectionInterval(final int i, final int i1) {
	runMapping(new MapVoidAction("removeSelectionInterval") {
		public void map() {
		    ((JList)getSource()).removeSelectionInterval(i, i1);
		}});}

    /**Maps <code>JList.setCellRenderer(ListCellRenderer)</code> through queue*/
    public void setCellRenderer(final ListCellRenderer listCellRenderer) {
	runMapping(new MapVoidAction("setCellRenderer") {
		public void map() {
		    ((JList)getSource()).setCellRenderer(listCellRenderer);
		}});}

    /**Maps <code>JList.setFixedCellHeight(int)</code> through queue*/
    public void setFixedCellHeight(final int i) {
	runMapping(new MapVoidAction("setFixedCellHeight") {
		public void map() {
		    ((JList)getSource()).setFixedCellHeight(i);
		}});}

    /**Maps <code>JList.setFixedCellWidth(int)</code> through queue*/
    public void setFixedCellWidth(final int i) {
	runMapping(new MapVoidAction("setFixedCellWidth") {
		public void map() {
		    ((JList)getSource()).setFixedCellWidth(i);
		}});}

    /**Maps <code>JList.setListData(Vector)</code> through queue*/
    public void setListData(final Vector vector) {
	runMapping(new MapVoidAction("setListData") {
		public void map() {
		    ((JList)getSource()).setListData(vector);
		}});}

    /**Maps <code>JList.setListData(Object[])</code> through queue*/
    public void setListData(final Object[] object) {
	runMapping(new MapVoidAction("setListData") {
		public void map() {
		    ((JList)getSource()).setListData(object);
		}});}

    /**Maps <code>JList.setModel(ListModel)</code> through queue*/
    public void setModel(final ListModel listModel) {
	runMapping(new MapVoidAction("setModel") {
		public void map() {
		    ((JList)getSource()).setModel(listModel);
		}});}

    /**Maps <code>JList.setPrototypeCellValue(Object)</code> through queue*/
    public void setPrototypeCellValue(final Object object) {
	runMapping(new MapVoidAction("setPrototypeCellValue") {
		public void map() {
		    ((JList)getSource()).setPrototypeCellValue(object);
		}});}

    /**Maps <code>JList.setSelectedIndex(int)</code> through queue*/
    public void setSelectedIndex(final int i) {
	runMapping(new MapVoidAction("setSelectedIndex") {
		public void map() {
		    ((JList)getSource()).setSelectedIndex(i);
		}});}

    /**Maps <code>JList.setSelectedIndices(int[])</code> through queue*/
    public void setSelectedIndices(final int[] i) {
	runMapping(new MapVoidAction("setSelectedIndices") {
		public void map() {
		    ((JList)getSource()).setSelectedIndices(i);
		}});}

    /**Maps <code>JList.setSelectedValue(Object, boolean)</code> through queue*/
    public void setSelectedValue(final Object object, final boolean b) {
	runMapping(new MapVoidAction("setSelectedValue") {
		public void map() {
		    ((JList)getSource()).setSelectedValue(object, b);
		}});}

    /**Maps <code>JList.setSelectionBackground(Color)</code> through queue*/
    public void setSelectionBackground(final Color color) {
	runMapping(new MapVoidAction("setSelectionBackground") {
		public void map() {
		    ((JList)getSource()).setSelectionBackground(color);
		}});}

    /**Maps <code>JList.setSelectionForeground(Color)</code> through queue*/
    public void setSelectionForeground(final Color color) {
	runMapping(new MapVoidAction("setSelectionForeground") {
		public void map() {
		    ((JList)getSource()).setSelectionForeground(color);
		}});}

    /**Maps <code>JList.setSelectionInterval(int, int)</code> through queue*/
    public void setSelectionInterval(final int i, final int i1) {
	runMapping(new MapVoidAction("setSelectionInterval") {
		public void map() {
		    ((JList)getSource()).setSelectionInterval(i, i1);
		}});}

    /**Maps <code>JList.setSelectionMode(int)</code> through queue*/
    public void setSelectionMode(final int i) {
	runMapping(new MapVoidAction("setSelectionMode") {
		public void map() {
		    ((JList)getSource()).setSelectionMode(i);
		}});}

    /**Maps <code>JList.setSelectionModel(ListSelectionModel)</code> through queue*/
    public void setSelectionModel(final ListSelectionModel listSelectionModel) {
	runMapping(new MapVoidAction("setSelectionModel") {
		public void map() {
		    ((JList)getSource()).setSelectionModel(listSelectionModel);
		}});}

    /**Maps <code>JList.setUI(ListUI)</code> through queue*/
    public void setUI(final ListUI listUI) {
	runMapping(new MapVoidAction("setUI") {
		public void map() {
		    ((JList)getSource()).setUI(listUI);
		}});}

    /**Maps <code>JList.setValueIsAdjusting(boolean)</code> through queue*/
    public void setValueIsAdjusting(final boolean b) {
	runMapping(new MapVoidAction("setValueIsAdjusting") {
		public void map() {
		    ((JList)getSource()).setValueIsAdjusting(b);
		}});}

    /**Maps <code>JList.setVisibleRowCount(int)</code> through queue*/
    public void setVisibleRowCount(final int i) {
	runMapping(new MapVoidAction("setVisibleRowCount") {
		public void map() {
		    ((JList)getSource()).setVisibleRowCount(i);
		}});}

    //End of mapping                                      //
    ////////////////////////////////////////////////////////

    private void checkIndex(int index) {
        if(index < 0 ||
           index >= getModel().getSize()) {
            throw(new NoSuchItemException(index));
        }
    }
    private void checkIndices(int[] indices) {
        for(int i = 0; i < indices.length; i++) {
            checkIndex(indices[i]);
        }
    }
    /**
     * Iterface to choose list item.
     */
    public interface ListItemChooser {
	/**
	 * Should be true if item is good.
	 * @param oper Operator used to search item.
	 * @param index Index of an item be checked.
         * @return true if the item fits the criteria
	 */
	public boolean checkItem(JListOperator oper, int index);

	/**
	 * Item description.
         * @return a description.
	 */
	public String getDescription();
    }

    /**
     * Can be throught during item selecting if list does not have
     * item requested.
     */
    public class NoSuchItemException extends JemmyInputException {
	/**
	 * Constructor.
         * @param item an item's text
	 */
	public NoSuchItemException(String item) {
	    super("No such item as \"" + item + "\"", getSource());
	}
	/**
	 * Constructor.
         * @param index an item's index
	 */
	public NoSuchItemException(int index) {
	    super("List does not contain " + index + "'th item", getSource());
	}
    }

    private class BySubStringListItemChooser implements ListItemChooser {
	String subString;
	StringComparator comparator;

	public BySubStringListItemChooser(String subString, StringComparator comparator) {
	    this.subString = subString;
	    this.comparator = comparator;
	}

	public boolean checkItem(JListOperator oper, int index) {
	    return(comparator.equals(oper.getModel().getElementAt(index).toString(), 
				     subString));
	}

	public String getDescription() {
	    return("Item containing \"" + subString + "\" string");
	}
    }

    private class ByRenderedComponentListItemChooser implements ListItemChooser {
	ComponentChooser chooser;
	public ByRenderedComponentListItemChooser(ComponentChooser chooser) {
	    this.chooser = chooser;
	}
	public boolean checkItem(JListOperator oper, int index) {
	    return(chooser.checkComponent(oper.getRenderedComponent(index)));
	}
	public String getDescription() {
	    return(chooser.getDescription());
	}
    }

    /**
     * Allows to find component by an item.
     */
    public static class JListByItemFinder implements ComponentChooser {
	String label;
	int itemIndex;
	StringComparator comparator;
        /**
         * Constructs JListByItemFinder.
         * @param lb a text pattern
         * @param ii item index to check. If equal to -1, selected item is checked.
         * @param comparator specifies string comparision algorithm.
         */
	public JListByItemFinder(String lb, int ii, StringComparator comparator) {
	    label = lb;
	    itemIndex = ii;
	    this.comparator = comparator;
	}
        /**
         * Constructs JListByItemFinder.
         * @param lb a text pattern
         * @param ii item index to check. If equal to -1, selected item is checked.
         */
	public JListByItemFinder(String lb, int ii) {
            this(lb, ii, Operator.getDefaultStringComparator());
	}
	public boolean checkComponent(Component comp) {
	    if(comp instanceof JList) {
                if(label == null) {
                    return(true);
                }
		if(((JList)comp).getModel().getSize() > itemIndex) {
		    int ii = itemIndex;
		    if(ii == -1) {
                        ii = ((JList)comp).getSelectedIndex();
                        if(ii == -1) {
                            return(false);
                        }
		    }
		    return(comparator.equals(((JList)comp).getModel().getElementAt(ii).toString(),
					     label));
		}
	    }
	    return(false);
	}
	public String getDescription() {
	    return("JList with text \"" + label + "\" in " + 
		   (new Integer(itemIndex)).toString() + "'th item");
	}
    }

    /**
     * Checks component type.
     */
    public static class JListFinder extends Finder {
        /**
         * Constructs JListFinder.
         * @param sf other searching criteria.
         */
	public JListFinder(ComponentChooser sf) {
            super(JList.class, sf);
	}
        /**
         * Constructs JListFinder.
         */
	public JListFinder() {
            super(JList.class);
	}
    }
}
