530 lines
10 KiB
Java
530 lines
10 KiB
Java
/* 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
|