diff options
Diffstat (limited to 'libjava/javax/swing/DefaultListModel.java')
| -rw-r--r-- | libjava/javax/swing/DefaultListModel.java | 529 |
1 files changed, 529 insertions, 0 deletions
diff --git a/libjava/javax/swing/DefaultListModel.java b/libjava/javax/swing/DefaultListModel.java new file mode 100644 index 00000000000..3a841635903 --- /dev/null +++ b/libjava/javax/swing/DefaultListModel.java @@ -0,0 +1,529 @@ +/* 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 |