/* DefaultListModel.java --
   Copyright (C) 2002 Free Software Foundation, Inc.

This file is part of GNU Classpath.

GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.

GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
General Public License for more details.

You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING.  If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.

Linking this library statically or dynamically with other modules is
making a combined work based on this library.  Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.

As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module.  An independent module is a module which is not derived from
or based on this library.  If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so.  If you do not wish to do so, delete this
exception statement from your version. */

package javax.swing;

// Imports
import java.util.*;

/**
 * DefaultListModel
 * @author	Andrew Selkirk
 * @version	1.0
 */
public class DefaultListModel extends AbstractListModel {

	//-------------------------------------------------------------
	// Variables --------------------------------------------------
	//-------------------------------------------------------------

	/**
	 * elements.  Note: Sun obviously implemented the storage as a
	 * Vector according to the similar API on this class.  I choose
	 * instead to implement the model with a proper collection object.
	 * Is this a good choice?  Probably not (ya..I know there are
	 * sync issues by doing this)
	 */
	private ArrayList elements = new ArrayList();


	//-------------------------------------------------------------
	// Initialization ---------------------------------------------
	//-------------------------------------------------------------

	/**
	 * Constructor DefaultListModel
	 */
	public DefaultListModel() {
		// TODO
	} // DefaultListModel()


	//-------------------------------------------------------------
	// Methods ----------------------------------------------------
	//-------------------------------------------------------------

	/**
	 * elementAt
	 * @param index TODO
	 * @returns Object
	 */
	public Object elementAt(int index) {
		return elements.get(index);
	} // elementAt()

	/**
	 * toString
	 * @returns String
	 */
	public String toString() {
		return elements.toString();
	} // toString()

	/**
	 * indexOf
	 * @param element TODO
	 * @returns int
	 */
	public int indexOf(Object element) {
		return elements.indexOf(element);
	} // indexOf()

	/**
	 * indexOf
	 * @param element TODO
	 * @param startIndex TODO
	 * @returns int
	 */
	public int indexOf(Object element, int startIndex) {

		// Variables
		int		index;
		Object	test;

		// Process Elements
		for (index = startIndex; index < elements.size(); index++) {
			test = elements.get(index);
			if (test.equals(element) == true) {
				return index;
			} // if
		} // for
		return -1;

	} // indexOf()

	/**
	 * lastIndexOf
	 * @param element TODO
	 * @returns int
	 */
	public int lastIndexOf(Object element) {
		return elements.lastIndexOf(element);
	} // lastIndexOf()

	/**
	 * lastIndexOf
	 * @param element TODO
	 * @param endIndex TODO
	 * @returns int
	 */
	public int lastIndexOf(Object element, int endIndex) {

		// Variables
		int		index;
		Object	test;

		// Process Elements
		for (index = endIndex; index >= 0; index--) {
			test = elements.get(index);
			if (test.equals(element) == true) {
				return index;
			} // if
		} // for
		return -1;

	} // lastIndexOf()

	/**
	 * get
	 * @param index TODO
	 * @returns Object
	 */
	public Object get(int index) {
		return elements.get(index);
	} // get()

	/**
	 * set
	 * @param index TODO
	 * @param element TODO
	 * @returns Object
	 */
	public Object set(int index, Object element) {

		// Variables
		Object	result;

		// Process Action
		result = elements.set(index, element);

		// Send event
		fireContentsChanged(this, index, index);

		return result;

	} // set()

	/**
	 * add
	 * @param index TODO
	 * @param element TODO
	 */
	public void add(int index, Object element) {

		// Process Action
		elements.add(index, element);

		// Send event
		fireContentsChanged(this, index, index);

	} // add()

	/**
	 * addElement
	 * @param element TODO
	 */
	public void addElement(Object element) {

		// Process Action
		elements.add(element);

		// Send event
		fireIntervalAdded(this, elements.size(), elements.size());

	} // addElement()

	/**
	 * size
	 * @returns int
	 */
	public int size() {
		return elements.size();
	} // size()

	/**
	 * toArray
	 * @returns Object[]
	 */
	public Object[] toArray() {
		return elements.toArray();
	} // toArray()

	/**
	 * contains
	 * @param element TODO
	 * @returns boolean
	 */
	public boolean contains(Object element) {
		return elements.contains(element);
	} // contains()

	/**
	 * copyInto
	 * @param array TODO
	 */
	public void copyInto(Object[] array) {

		// Variables
		int		index;
		int		size;
		Object[]	srcArray;

		// Initialize
		size = size();
		srcArray = toArray();

		// Process Elements
		for (index = 0; index < size; index++) {
			array[index] = srcArray[index];
		} // for

	} // copyInto()

	/**
	 * clear
	 */
	public void clear() {

		// Process Action
		elements.clear();

		// Send event
		fireIntervalRemoved(this, 0, elements.size());

	} // clear()

	/**
	 * remove
	 * @param index TODO
	 * @returns Object
	 */
	public Object remove(int index) {

		// Variables
		Object	result;

		// Process Action
		result = elements.remove(index);

		// Send event
		fireIntervalRemoved(this, index, index);

		return result;

	} // remove()

	/**
	 * isEmpty
	 * @returns boolean
	 */
	public boolean isEmpty() {
		return elements.isEmpty();
	} // isEmpty()

	/**
	 * elements
	 * @returns Enumeration
	 */
	public Enumeration elements() {

		// TODO
		// Note: This is a pathetic implementation.  If Vector
		// was used for storage, this wouldn't be an issue.  I'll
		// have to implement an Enumeration inner class sometime.

		// Variables
		Vector	vector;

		// Get Enumeration
		vector = new Vector(elements);
		return vector.elements();

	} // elements()

	/**
	 * trimToSize
	 */
	public void trimToSize() {
		elements.trimToSize();
	} // trimToSize()

	/**
	 * ensureCapacity
	 * @param size TODO
	 */
	public void ensureCapacity(int size) {
		elements.ensureCapacity(size);
	} // ensureCapacity()

	/**
	 * setSize
	 * @param size TODO
	 */
	public void setSize(int size) {
		elements.ensureCapacity(size);
	} // setSize()

	/**
	 * capacity
	 * @returns int
	 */
	public int capacity() {
		return elements.size();
	} // capacity()

	/**
	 * firstElement
	 * @returns Object
	 */
	public Object firstElement() {

		// Variables
		Object	element;

		try {
			element = elements.get(0);
			return element;
		} catch (IndexOutOfBoundsException e) {
			throw new NoSuchElementException();
		} // try

	} // firstElement()

	/**
	 * lastElement
	 * @returns Object
	 */
	public Object lastElement() {

		// Variables
		Object	element;

		try {
			element = elements.get(elements.size() - 1);
			return element;
		} catch (ArrayIndexOutOfBoundsException e) {
			throw new NoSuchElementException();
		} // try

	} // lastElement()

	/**
	 * setElementAt
	 * @param element TODO
	 * @param index TODO
	 */
	public void setElementAt(Object element, int index) {

		// Process Action
		elements.set(index, element);

		// Send event
		fireContentsChanged(this, index, index);

	} // setElementAt()

	/**
	 * removeElementAt
	 * @param index TODO
	 */
	public void removeElementAt(int index) {

		// Process Action
		elements.remove(index);

		// Send event
		fireIntervalRemoved(this, index, index);

	} // removeElementAt()

	/**
	 * insertElementAt
	 * @param element TODO
	 * @param index TODO
	 */
	public void insertElementAt(Object element, int index) {

		// Process Action
		elements.add(index, element);

		// Send event
		fireIntervalRemoved(this, index, index);

	} // insertElementAt()

	/**
	 * removeElement
	 * @param element TODO
	 * @returns boolean
	 */
	public boolean removeElement(Object element) {

		// Variables
		int		index;

		index = elements.indexOf(element);
		if (index != -1) {
			elements.remove(index);

			// Send event
			fireIntervalRemoved(this, index, index);

			return true;

		} // if

		return false;

	} // removeElement()

	/**
	 * removeAllElements
	 */
	public void removeAllElements() {

		// Variables
		int		size;

		size = size();

		if (size > 0) {

			// Process Action
			elements.clear();

			// Send event
			fireIntervalRemoved(this, 0, size - 1);

		} // if

	} // removeAllElements()

	/**
	 * removeRange
	 * @param startIndex TODO
	 * @param endIndex TODO
	 */
	public void removeRange(int startIndex, int endIndex) {

		// Variables
		int		index;

		// Check Indices
		if (startIndex > endIndex) {
			throw new IllegalArgumentException();
		} // if

		// Process Elements
		for (index = endIndex; index >= startIndex; index--) {
			elements.remove(index);
		} // for

		// Send event
		fireIntervalRemoved(this, startIndex, endIndex);

	} // removeRange()

	/**
	 * getSize
	 * @returns int
	 */
	public int getSize() {
		return elements.size();
	} // getSize()

	/**
	 * getElementAt
	 * @param index TODO
	 * @returns Object
	 */
	public Object getElementAt(int index) {
		return elements.get(index);
	} // getElementAt()


} // DefaultListModel