| /* |
| * Copyright (c) 1997, 2018, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * This code 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 |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| package javax.swing; |
| |
| import java.util.Vector; |
| import java.util.Collection; |
| import java.util.Enumeration; |
| |
| |
| /** |
| * This class loosely implements the {@code java.util.Vector} |
| * API, in that it implements the 1.1.x version of |
| * {@code java.util.Vector}, has no collection class support, |
| * and notifies the {@code ListDataListener}s when changes occur. |
| * Presently it delegates to a {@code Vector}, |
| * in a future release it will be a real Collection implementation. |
| * <p> |
| * <strong>Warning:</strong> |
| * Serialized objects of this class will not be compatible with |
| * future Swing releases. The current serialization support is |
| * appropriate for short term storage or RMI between applications running |
| * the same version of Swing. As of 1.4, support for long term storage |
| * of all JavaBeans™ |
| * has been added to the {@code java.beans} package. |
| * Please see {@link java.beans.XMLEncoder}. |
| * |
| * @param <E> the type of the elements of this model |
| * |
| * @author Hans Muller |
| * @since 1.2 |
| */ |
| @SuppressWarnings("serial") // Same-version serialization only |
| public class DefaultListModel<E> extends AbstractListModel<E> |
| { |
| private Vector<E> delegate = new Vector<E>(); |
| |
| /** |
| * Returns the number of components in this list. |
| * <p> |
| * This method is identical to {@code size}, which implements the |
| * {@code List} interface defined in the 1.2 Collections framework. |
| * This method exists in conjunction with {@code setSize} so that |
| * {@code size} is identifiable as a JavaBean property. |
| * |
| * @return the number of components in this list |
| * @see #size() |
| */ |
| public int getSize() { |
| return delegate.size(); |
| } |
| |
| /** |
| * Returns the component at the specified index. |
| * <blockquote> |
| * <b>Note:</b> Although this method is not deprecated, the preferred |
| * method to use is {@code get(int)}, which implements the {@code List} |
| * interface defined in the 1.2 Collections framework. |
| * </blockquote> |
| * @param index an index into this list |
| * @return the component at the specified index |
| * @throws ArrayIndexOutOfBoundsException if the {@code index} |
| * is negative or greater than the current size of this |
| * list |
| * @see #get(int) |
| */ |
| public E getElementAt(int index) { |
| return delegate.elementAt(index); |
| } |
| |
| /** |
| * Copies the components of this list into the specified array. |
| * The array must be big enough to hold all the objects in this list, |
| * else an {@code IndexOutOfBoundsException} is thrown. |
| * |
| * @param anArray the array into which the components get copied |
| * @see Vector#copyInto(Object[]) |
| */ |
| public void copyInto(Object anArray[]) { |
| delegate.copyInto(anArray); |
| } |
| |
| /** |
| * Trims the capacity of this list to be the list's current size. |
| * |
| * @see Vector#trimToSize() |
| */ |
| public void trimToSize() { |
| delegate.trimToSize(); |
| } |
| |
| /** |
| * Increases the capacity of this list, if necessary, to ensure |
| * that it can hold at least the number of components specified by |
| * the minimum capacity argument. |
| * |
| * @param minCapacity the desired minimum capacity |
| * @see Vector#ensureCapacity(int) |
| */ |
| public void ensureCapacity(int minCapacity) { |
| delegate.ensureCapacity(minCapacity); |
| } |
| |
| /** |
| * Sets the size of this list. |
| * |
| * @param newSize the new size of this list |
| * @see Vector#setSize(int) |
| */ |
| public void setSize(int newSize) { |
| int oldSize = delegate.size(); |
| delegate.setSize(newSize); |
| if (oldSize > newSize) { |
| fireIntervalRemoved(this, newSize, oldSize-1); |
| } |
| else if (oldSize < newSize) { |
| fireIntervalAdded(this, oldSize, newSize-1); |
| } |
| } |
| |
| /** |
| * Returns the current capacity of this list. |
| * |
| * @return the current capacity |
| * @see Vector#capacity() |
| */ |
| public int capacity() { |
| return delegate.capacity(); |
| } |
| |
| /** |
| * Returns the number of components in this list. |
| * |
| * @return the number of components in this list |
| * @see Vector#size() |
| */ |
| public int size() { |
| return delegate.size(); |
| } |
| |
| /** |
| * Tests whether this list has any components. |
| * |
| * @return {@code true} if and only if this list has |
| * no components, that is, its size is zero; |
| * {@code false} otherwise |
| * @see Vector#isEmpty() |
| */ |
| public boolean isEmpty() { |
| return delegate.isEmpty(); |
| } |
| |
| /** |
| * Returns an enumeration of the components of this list. |
| * |
| * @return an enumeration of the components of this list |
| * @see Vector#elements() |
| */ |
| public Enumeration<E> elements() { |
| return delegate.elements(); |
| } |
| |
| /** |
| * Tests whether the specified object is a component in this list. |
| * |
| * @param elem an object |
| * @return {@code true} if the specified object |
| * is the same as a component in this list |
| * @see Vector#contains(Object) |
| */ |
| public boolean contains(Object elem) { |
| return delegate.contains(elem); |
| } |
| |
| /** |
| * Searches for the first occurrence of {@code elem}. |
| * |
| * @param elem an object |
| * @return the index of the first occurrence of the argument in this |
| * list; returns {@code -1} if the object is not found |
| * @see Vector#indexOf(Object) |
| */ |
| public int indexOf(Object elem) { |
| return delegate.indexOf(elem); |
| } |
| |
| /** |
| * Searches for the first occurrence of {@code elem}, beginning |
| * the search at {@code index}. |
| * |
| * @param elem the desired component |
| * @param index the index from which to begin searching |
| * @return the index where the first occurrence of {@code elem} |
| * is found after {@code index}; returns {@code -1} |
| * if the {@code elem} is not found in the list |
| * @see Vector#indexOf(Object,int) |
| */ |
| public int indexOf(Object elem, int index) { |
| return delegate.indexOf(elem, index); |
| } |
| |
| /** |
| * Returns the index of the last occurrence of {@code elem}. |
| * |
| * @param elem the desired component |
| * @return the index of the last occurrence of {@code elem} |
| * in the list; returns {@code elem} if the object is not found |
| * @see Vector#lastIndexOf(Object) |
| */ |
| public int lastIndexOf(Object elem) { |
| return delegate.lastIndexOf(elem); |
| } |
| |
| /** |
| * Searches backwards for {@code elem}, starting from the |
| * specified index, and returns an index to it. |
| * |
| * @param elem the desired component |
| * @param index the index to start searching from |
| * @return the index of the last occurrence of the {@code elem} |
| * in this list at position less than {@code index}; |
| * returns {@code -1} if the object is not found |
| * @see Vector#lastIndexOf(Object,int) |
| */ |
| public int lastIndexOf(Object elem, int index) { |
| return delegate.lastIndexOf(elem, index); |
| } |
| |
| /** |
| * Returns the component at the specified index. |
| * <blockquote> |
| * <b>Note:</b> Although this method is not deprecated, the preferred |
| * method to use is {@code get(int)}, which implements the |
| * {@code List} interface defined in the 1.2 Collections framework. |
| * </blockquote> |
| * |
| * @param index an index into this list |
| * @return the component at the specified index |
| * @throws ArrayIndexOutOfBoundsException if the index |
| * is negative or not less than the size of the list |
| * @see #get(int) |
| * @see Vector#elementAt(int) |
| */ |
| public E elementAt(int index) { |
| return delegate.elementAt(index); |
| } |
| |
| /** |
| * Returns the first component of this list. |
| * @return the first component of this list |
| * @see Vector#firstElement() |
| * @throws NoSuchElementException if this |
| * vector has no components |
| */ |
| public E firstElement() { |
| return delegate.firstElement(); |
| } |
| |
| /** |
| * Returns the last component of the list. |
| * |
| * @return the last component of the list |
| * @see Vector#lastElement() |
| * @throws NoSuchElementException if this vector |
| * has no components |
| */ |
| public E lastElement() { |
| return delegate.lastElement(); |
| } |
| |
| /** |
| * Sets the component at the specified {@code index} of this |
| * list to be the specified element. The previous component at that |
| * position is discarded. |
| * <blockquote> |
| * <b>Note:</b> Although this method is not deprecated, the preferred |
| * method to use is {@code set(int,Object)}, which implements the |
| * {@code List} interface defined in the 1.2 Collections framework. |
| * </blockquote> |
| * |
| * @param element what the component is to be set to |
| * @param index the specified index |
| * @throws ArrayIndexOutOfBoundsException if the index is invalid |
| * @see #set(int,Object) |
| * @see Vector#setElementAt(Object,int) |
| */ |
| public void setElementAt(E element, int index) { |
| delegate.setElementAt(element, index); |
| fireContentsChanged(this, index, index); |
| } |
| |
| /** |
| * Deletes the component at the specified index. |
| * <blockquote> |
| * <b>Note:</b> Although this method is not deprecated, the preferred |
| * method to use is {@code remove(int)}, which implements the |
| * {@code List} interface defined in the 1.2 Collections framework. |
| * </blockquote> |
| * |
| * @param index the index of the object to remove |
| * @see #remove(int) |
| * @see Vector#removeElementAt(int) |
| * @throws ArrayIndexOutOfBoundsException if the index is invalid |
| */ |
| public void removeElementAt(int index) { |
| delegate.removeElementAt(index); |
| fireIntervalRemoved(this, index, index); |
| } |
| |
| /** |
| * Inserts the specified element as a component in this list at the |
| * specified <code>index</code>. |
| * <blockquote> |
| * <b>Note:</b> Although this method is not deprecated, the preferred |
| * method to use is {@code add(int,Object)}, which implements the |
| * {@code List} interface defined in the 1.2 Collections framework. |
| * </blockquote> |
| * |
| * @param element the component to insert |
| * @param index where to insert the new component |
| * @exception ArrayIndexOutOfBoundsException if the index was invalid |
| * @see #add(int,Object) |
| * @see Vector#insertElementAt(Object,int) |
| */ |
| public void insertElementAt(E element, int index) { |
| delegate.insertElementAt(element, index); |
| fireIntervalAdded(this, index, index); |
| } |
| |
| /** |
| * Adds the specified component to the end of this list. |
| * |
| * @param element the component to be added |
| * @see Vector#addElement(Object) |
| */ |
| public void addElement(E element) { |
| int index = delegate.size(); |
| delegate.addElement(element); |
| fireIntervalAdded(this, index, index); |
| } |
| |
| /** |
| * Removes the first (lowest-indexed) occurrence of the argument |
| * from this list. |
| * |
| * @param obj the component to be removed |
| * @return {@code true} if the argument was a component of this |
| * list; {@code false} otherwise |
| * @see Vector#removeElement(Object) |
| */ |
| public boolean removeElement(Object obj) { |
| int index = indexOf(obj); |
| boolean rv = delegate.removeElement(obj); |
| if (index >= 0) { |
| fireIntervalRemoved(this, index, index); |
| } |
| return rv; |
| } |
| |
| |
| /** |
| * Removes all components from this list and sets its size to zero. |
| * <blockquote> |
| * <b>Note:</b> Although this method is not deprecated, the preferred |
| * method to use is {@code clear}, which implements the |
| * {@code List} interface defined in the 1.2 Collections framework. |
| * </blockquote> |
| * |
| * @see #clear() |
| * @see Vector#removeAllElements() |
| */ |
| public void removeAllElements() { |
| int index1 = delegate.size()-1; |
| delegate.removeAllElements(); |
| if (index1 >= 0) { |
| fireIntervalRemoved(this, 0, index1); |
| } |
| } |
| |
| |
| /** |
| * Returns a string that displays and identifies this |
| * object's properties. |
| * |
| * @return a String representation of this object |
| */ |
| public String toString() { |
| return delegate.toString(); |
| } |
| |
| |
| /* The remaining methods are included for compatibility with the |
| * Java 2 platform Vector class. |
| */ |
| |
| /** |
| * Returns an array containing all of the elements in this list in the |
| * correct order. |
| * |
| * @return an array containing the elements of the list |
| * @see Vector#toArray() |
| */ |
| public Object[] toArray() { |
| Object[] rv = new Object[delegate.size()]; |
| delegate.copyInto(rv); |
| return rv; |
| } |
| |
| /** |
| * Returns the element at the specified position in this list. |
| * |
| * @param index index of element to return |
| * @return the element at the specified position in this list |
| * @throws ArrayIndexOutOfBoundsException if the index is out of range |
| * ({@code index < 0 || index >= size()}) |
| */ |
| public E get(int index) { |
| return delegate.elementAt(index); |
| } |
| |
| /** |
| * Replaces the element at the specified position in this list with the |
| * specified element. |
| * |
| * @param index index of element to replace |
| * @param element element to be stored at the specified position |
| * @return the element previously at the specified position |
| * @throws ArrayIndexOutOfBoundsException if the index is out of range |
| * ({@code index < 0 || index >= size()}) |
| */ |
| public E set(int index, E element) { |
| E rv = delegate.elementAt(index); |
| delegate.setElementAt(element, index); |
| fireContentsChanged(this, index, index); |
| return rv; |
| } |
| |
| /** |
| * Inserts the specified element at the specified position in this list. |
| * |
| * @param index index at which the specified element is to be inserted |
| * @param element element to be inserted |
| * @throws ArrayIndexOutOfBoundsException if the index is out of range |
| * ({@code index < 0 || index > size()}) |
| */ |
| public void add(int index, E element) { |
| delegate.insertElementAt(element, index); |
| fireIntervalAdded(this, index, index); |
| } |
| |
| /** |
| * Removes the element at the specified position in this list. |
| * Returns the element that was removed from the list |
| * |
| * @param index the index of the element to removed |
| * @return the element previously at the specified position |
| * @throws ArrayIndexOutOfBoundsException if the index is out of range |
| * ({@code index < 0 || index >= size()}) |
| */ |
| public E remove(int index) { |
| E rv = delegate.elementAt(index); |
| delegate.removeElementAt(index); |
| fireIntervalRemoved(this, index, index); |
| return rv; |
| } |
| |
| /** |
| * Removes all of the elements from this list. The list will |
| * be empty after this call returns (unless it throws an exception). |
| */ |
| public void clear() { |
| int index1 = delegate.size()-1; |
| delegate.removeAllElements(); |
| if (index1 >= 0) { |
| fireIntervalRemoved(this, 0, index1); |
| } |
| } |
| |
| /** |
| * Deletes the components at the specified range of indexes. |
| * The removal is inclusive, so specifying a range of (1,5) |
| * removes the component at index 1 and the component at index 5, |
| * as well as all components in between. |
| * |
| * @param fromIndex the index of the lower end of the range |
| * @param toIndex the index of the upper end of the range |
| * @throws ArrayIndexOutOfBoundsException if the index was invalid |
| * @throws IllegalArgumentException if {@code fromIndex > toIndex} |
| * @see #remove(int) |
| */ |
| public void removeRange(int fromIndex, int toIndex) { |
| if (fromIndex > toIndex) { |
| throw new IllegalArgumentException("fromIndex must be <= toIndex"); |
| } |
| for(int i = toIndex; i >= fromIndex; i--) { |
| delegate.removeElementAt(i); |
| } |
| fireIntervalRemoved(this, fromIndex, toIndex); |
| } |
| |
| /** |
| * Adds all of the elements present in the collection to the list. |
| * |
| * @param c the collection which contains the elements to add |
| * @throws NullPointerException if {@code c} is null |
| */ |
| public void addAll(Collection<? extends E> c) { |
| if (c.isEmpty()) { |
| return; |
| } |
| |
| int startIndex = getSize(); |
| |
| delegate.addAll(c); |
| fireIntervalAdded(this, startIndex, getSize() - 1); |
| } |
| |
| /** |
| * Adds all of the elements present in the collection, starting |
| * from the specified index. |
| * |
| * @param index index at which to insert the first element from the |
| * specified collection |
| * @param c the collection which contains the elements to add |
| * @throws ArrayIndexOutOfBoundsException if {@code index} does not |
| * fall within the range of number of elements currently held |
| * @throws NullPointerException if {@code c} is null |
| */ |
| public void addAll(int index, Collection<? extends E> c) { |
| if (index < 0 || index > getSize()) { |
| throw new ArrayIndexOutOfBoundsException("index out of range: " + |
| index); |
| } |
| |
| if (c.isEmpty()) { |
| return; |
| } |
| |
| delegate.addAll(index, c); |
| fireIntervalAdded(this, index, index + c.size() - 1); |
| } |
| } |
