    rev 48858 : Work in progress for JDK-6303622
    Use generic in Swing components like JComboBox
    1. Added generic return type and parameter type for JComboBox.
    2. Modified JList related classes as well.
    3. Reverted the changes made to "getSelectedValues" as suggested by Joe.
    4. Modified files that were failing on Linux and Mac as well.

       1 /*
       2  * Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved.
       3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
       4  *
       5  * This code is free software; you can redistribute it and/or modify it
       6  * under the terms of the GNU General Public License version 2 only, as
       7  * published by the Free Software Foundation.  Oracle designates this
       8  * particular file as subject to the "Classpath" exception as provided
       9  * by Oracle in the LICENSE file that accompanied this code.
      10  *
      11  * This code is distributed in the hope that it will be useful, but WITHOUT
      12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
      13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
      14  * version 2 for more details (a copy is included in the LICENSE file that
      15  * accompanied this code).
      16  *
      17  * You should have received a copy of the GNU General Public License version
      18  * 2 along with this work; if not, write to the Free Software Foundation,
      19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
      20  *
      21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
      22  * or visit www.oracle.com if you need additional information or have any
      23  * questions.
      24  */
      25
      26 package javax.swing;
      27
      28 import java.util.Vector;
      29 import java.util.Enumeration;
      30
      31 import javax.swing.event.*;
      32
      33
      34 /**
      35  * This class loosely implements the <code>java.util.Vector</code>
      36  * API, in that it implements the 1.1.x version of
      37  * <code>java.util.Vector</code>, has no collection class support,
      38  * and notifies the <code>ListDataListener</code>s when changes occur.
      39  * Presently it delegates to a <code>Vector</code>,
      40  * in a future release it will be a real Collection implementation.
      41  * <p>
      42  * <strong>Warning:</strong>
      43  * Serialized objects of this class will not be compatible with
      44  * future Swing releases. The current serialization support is
      45  * appropriate for short term storage or RMI between applications running
      46  * the same version of Swing.  As of 1.4, support for long term storage
      47  * of all JavaBeans&trade;
      48  * has been added to the <code>java.beans</code> package.
      49  * Please see {@link java.beans.XMLEncoder}.
      50  *
      51  * @param <E> the type of the elements of this model
      52  *
      53  * @author Hans Muller
      54  * @since 1.2
      55  */
      56 @SuppressWarnings("serial") // Same-version serialization only
      57 public class DefaultListModel<E> extends AbstractListModel<E>
      58 {
      59     private Vector<E> delegate = new Vector<E>();
      60
      61     /**
      62      * Returns the number of components in this list.
      63      * <p>
      64      * This method is identical to <code>size</code>, which implements the
      65      * <code>List</code> interface defined in the 1.2 Collections framework.
      66      * This method exists in conjunction with <code>setSize</code> so that
      67      * <code>size</code> is identifiable as a JavaBean property.
      68      *
      69      * @return  the number of components in this list
      70      * @see #size()
      71      */
      72     public int getSize() {
      73         return delegate.size();
      74     }
      75
      76     /**
      77      * Returns the component at the specified index.
      78      * <blockquote>
      79      * <b>Note:</b> Although this method is not deprecated, the preferred
      80      *    method to use is <code>get(int)</code>, which implements the
      81      *    <code>List</code> interface defined in the 1.2 Collections framework.
      82      * </blockquote>
      83      * @param      index   an index into this list
      84      * @return     the component at the specified index
      85      * @exception  ArrayIndexOutOfBoundsException  if the <code>index</code>
      86      *             is negative or greater than the current size of this
      87      *             list
      88      * @see #get(int)
      89      */
      90     public E getElementAt(int index) {
      91         return delegate.elementAt(index);
      92     }
      93
      94     /**
      95      * Copies the components of this list into the specified array.
      96      * The array must be big enough to hold all the objects in this list,
      97      * else an <code>IndexOutOfBoundsException</code> is thrown.
      98      *
      99      * @param   anArray   the array into which the components get copied
     100      * @see Vector#copyInto(Object[])
     101      */
     102     public void copyInto(Object anArray[]) {
     103         delegate.copyInto(anArray);
     104     }
     105
     106     /**
     107      * Trims the capacity of this list to be the list's current size.
     108      *
     109      * @see Vector#trimToSize()
     110      */
     111     public void trimToSize() {
     112         delegate.trimToSize();
     113     }
     114
     115     /**
     116      * Increases the capacity of this list, if necessary, to ensure
     117      * that it can hold at least the number of components specified by
     118      * the minimum capacity argument.
     119      *
     120      * @param   minCapacity   the desired minimum capacity
     121      * @see Vector#ensureCapacity(int)
     122      */
     123     public void ensureCapacity(int minCapacity) {
     124         delegate.ensureCapacity(minCapacity);
     125     }
     126
     127     /**
     128      * Sets the size of this list.
     129      *
     130      * @param   newSize   the new size of this list
     131      * @see Vector#setSize(int)
     132      */
     133     public void setSize(int newSize) {
     134         int oldSize = delegate.size();
     135         delegate.setSize(newSize);
     136         if (oldSize > newSize) {
     137             fireIntervalRemoved(this, newSize, oldSize-1);
     138         }
     139         else if (oldSize < newSize) {
     140             fireIntervalAdded(this, oldSize, newSize-1);
     141         }
     142     }
     143
     144     /**
     145      * Returns the current capacity of this list.
     146      *
     147      * @return  the current capacity
     148      * @see Vector#capacity()
     149      */
     150     public int capacity() {
     151         return delegate.capacity();
     152     }
     153
     154     /**
     155      * Returns the number of components in this list.
     156      *
     157      * @return  the number of components in this list
     158      * @see Vector#size()
     159      */
     160     public int size() {
     161         return delegate.size();
     162     }
     163
     164     /**
     165      * Tests whether this list has any components.
     166      *
     167      * @return  <code>true</code> if and only if this list has
     168      *          no components, that is, its size is zero;
     169      *          <code>false</code> otherwise
     170      * @see Vector#isEmpty()
     171      */
     172     public boolean isEmpty() {
     173         return delegate.isEmpty();
     174     }
     175
     176     /**
     177      * Returns an enumeration of the components of this list.
     178      *
     179      * @return  an enumeration of the components of this list
     180      * @see Vector#elements()
     181      */
     182     public Enumeration<E> elements() {
     183         return delegate.elements();
     184     }
     185
     186     /**
     187      * Tests whether the specified object is a component in this list.
     188      *

     189      * @param   elem   an object
     190      * @return  <code>true</code> if the specified object
     191      *          is the same as a component in this list
     192      * @see Vector#contains(Object)
     193      */
     194     public boolean contains(Object elem) {
     195         return delegate.contains(elem);
     196     }
     197
     198     /**
     199      * Searches for the first occurrence of <code>elem</code>.
     200      *

     201      * @param   elem   an object
     202      * @return  the index of the first occurrence of the argument in this
     203      *          list; returns <code>-1</code> if the object is not found
     204      * @see Vector#indexOf(Object)
     205      */
     206     public int indexOf(Object elem) {
     207         return delegate.indexOf(elem);
     208     }
     209
     210     /**
     211      * Searches for the first occurrence of <code>elem</code>, beginning
     212      * the search at <code>index</code>.
     213      *

     214      * @param   elem    an desired component
     215      * @param   index   the index from which to begin searching
     216      * @return  the index where the first occurrence of <code>elem</code>
     217      *          is found after <code>index</code>; returns <code>-1</code>
     218      *          if the <code>elem</code> is not found in the list
     219      * @see Vector#indexOf(Object,int)
     220      */
     221      public int indexOf(Object elem, int index) {
     222         return delegate.indexOf(elem, index);
     223     }
     224
     225     /**
     226      * Returns the index of the last occurrence of <code>elem</code>.
     227      *

     228      * @param   elem   the desired component
     229      * @return  the index of the last occurrence of <code>elem</code>
     230      *          in the list; returns <code>-1</code> if the object is not found
     231      * @see Vector#lastIndexOf(Object)
     232      */
     233     public int lastIndexOf(Object elem) {
     234         return delegate.lastIndexOf(elem);
     235     }
     236
     237     /**
     238      * Searches backwards for <code>elem</code>, starting from the
     239      * specified index, and returns an index to it.
     240      *

     241      * @param  elem    the desired component
     242      * @param  index   the index to start searching from
     243      * @return the index of the last occurrence of the <code>elem</code>
     244      *          in this list at position less than <code>index</code>;
     245      *          returns <code>-1</code> if the object is not found
     246      * @see Vector#lastIndexOf(Object,int)
     247      */
     248     public int lastIndexOf(Object elem, int index) {
     249         return delegate.lastIndexOf(elem, index);
     250     }
     251
     252     /**
     253      * Returns the component at the specified index.
     254      * Throws an <code>ArrayIndexOutOfBoundsException</code> if the index
     255      * is negative or not less than the size of the list.
     256      * <blockquote>
     257      * <b>Note:</b> Although this method is not deprecated, the preferred
     258      *    method to use is <code>get(int)</code>, which implements the
     259      *    <code>List</code> interface defined in the 1.2 Collections framework.
     260      * </blockquote>
     261      *
     262      * @param      index   an index into this list
     263      * @return     the component at the specified index
     264      * @see #get(int)
     265      * @see Vector#elementAt(int)
     266      */
     267     public E elementAt(int index) {
     268         return delegate.elementAt(index);
     269     }
     270
     271     /**
     272      * Returns the first component of this list.
     273      * Throws a <code>NoSuchElementException</code> if this
     274      * vector has no components.
     275      * @return     the first component of this list
     276      * @see Vector#firstElement()
     277      */
     278     public E firstElement() {
     279         return delegate.firstElement();
     280     }
     281
     282     /**
     283      * Returns the last component of the list.
     284      * Throws a <code>NoSuchElementException</code> if this vector
     285      * has no components.
     286      *
     287      * @return  the last component of the list
     288      * @see Vector#lastElement()
     289      */
     290     public E lastElement() {
     291         return delegate.lastElement();
     292     }
     293
     294     /**
     295      * Sets the component at the specified <code>index</code> of this
     296      * list to be the specified element. The previous component at that
     297      * position is discarded.
     298      * <p>
     299      * Throws an <code>ArrayIndexOutOfBoundsException</code> if the index
     300      * is invalid.
     301      * <blockquote>
     302      * <b>Note:</b> Although this method is not deprecated, the preferred
     303      *    method to use is <code>set(int,Object)</code>, which implements the
     304      *    <code>List</code> interface defined in the 1.2 Collections framework.
     305      * </blockquote>
     306      *
     307      * @param      element what the component is to be set to
     308      * @param      index   the specified index
     309      * @see #set(int,Object)
     310      * @see Vector#setElementAt(Object,int)
     311      */
     312     public void setElementAt(E element, int index) {
     313         delegate.setElementAt(element, index);
     314         fireContentsChanged(this, index, index);
     315     }
     316
     317     /**
     318      * Deletes the component at the specified index.
     319      * <p>
     320      * Throws an <code>ArrayIndexOutOfBoundsException</code> if the index
     321      * is invalid.
     322      * <blockquote>
     323      * <b>Note:</b> Although this method is not deprecated, the preferred
     324      *    method to use is <code>remove(int)</code>, which implements the
     325      *    <code>List</code> interface defined in the 1.2 Collections framework.
     326      * </blockquote>
     327      *
     328      * @param      index   the index of the object to remove
     329      * @see #remove(int)
     330      * @see Vector#removeElementAt(int)
     331      */
     332     public void removeElementAt(int index) {
     333         delegate.removeElementAt(index);
     334         fireIntervalRemoved(this, index, index);
     335     }
     336
     337     /**
     338      * Inserts the specified element as a component in this list at the
     339      * specified <code>index</code>.
     340      * <p>
     341      * Throws an <code>ArrayIndexOutOfBoundsException</code> if the index
     342      * is invalid.
     343      * <blockquote>
     344      * <b>Note:</b> Although this method is not deprecated, the preferred
     345      *    method to use is <code>add(int,Object)</code>, which implements the
     346      *    <code>List</code> interface defined in the 1.2 Collections framework.
     347      * </blockquote>
     348      *
     349      * @param      element the component to insert
     350      * @param      index   where to insert the new component
     351      * @exception  ArrayIndexOutOfBoundsException  if the index was invalid
     352      * @see #add(int,Object)
     353      * @see Vector#insertElementAt(Object,int)
     354      */
     355     public void insertElementAt(E element, int index) {
     356         delegate.insertElementAt(element, index);
     357         fireIntervalAdded(this, index, index);
     358     }
     359
     360     /**
     361      * Adds the specified component to the end of this list.
     362      *
     363      * @param   element   the component to be added
     364      * @see Vector#addElement(Object)
     365      */
     366     public void addElement(E element) {
     367         int index = delegate.size();
     368         delegate.addElement(element);
     369         fireIntervalAdded(this, index, index);
     370     }
     371
     372     /**
     373      * Removes the first (lowest-indexed) occurrence of the argument
     374      * from this list.
     375      *

     376      * @param   obj   the component to be removed
     377      * @return  <code>true</code> if the argument was a component of this
     378      *          list; <code>false</code> otherwise
     379      * @see Vector#removeElement(Object)
     380      */
     381     public boolean removeElement(Object obj) {
     382         int index = indexOf(obj);
     383         boolean rv = delegate.removeElement(obj);
     384         if (index >= 0) {
     385             fireIntervalRemoved(this, index, index);
     386         }
     387         return rv;
     388     }
     389
     390
     391     /**
     392      * Removes all components from this list and sets its size to zero.
     393      * <blockquote>
     394      * <b>Note:</b> Although this method is not deprecated, the preferred
     395      *    method to use is <code>clear</code>, which implements the
     396      *    <code>List</code> interface defined in the 1.2 Collections framework.
     397      * </blockquote>
     398      *
     399      * @see #clear()
     400      * @see Vector#removeAllElements()
     401      */
     402     public void removeAllElements() {
     403         int index1 = delegate.size()-1;
     404         delegate.removeAllElements();
     405         if (index1 >= 0) {
     406             fireIntervalRemoved(this, 0, index1);
     407         }
     408     }
     409
     410
     411     /**
     412      * Returns a string that displays and identifies this
     413      * object's properties.
     414      *
     415      * @return a String representation of this object
     416      */
     417    public String toString() {
     418         return delegate.toString();
     419     }
     420
     421
     422     /* The remaining methods are included for compatibility with the
     423      * Java 2 platform Vector class.
     424      */
     425
     426     /**
     427      * Returns an array containing all of the elements in this list in the
     428      * correct order.
     429      *
     430      * @return an array containing the elements of the list
     431      * @see Vector#toArray()
     432      */
     433     public Object[] toArray() {
     434         Object[] rv = new Object[delegate.size()];
     435         delegate.copyInto(rv);
     436         return rv;
     437     }
     438
     439     /**
     440      * Returns the element at the specified position in this list.
     441      * <p>
     442      * Throws an <code>ArrayIndexOutOfBoundsException</code>
     443      * if the index is out of range
     444      * (<code>index &lt; 0 || index &gt;= size()</code>).
     445      *
     446      * @param index index of element to return
     447      * @return the element at the specified position in this list
     448      */
     449     public E get(int index) {
     450         return delegate.elementAt(index);
     451     }
     452
     453     /**
     454      * Replaces the element at the specified position in this list with the
     455      * specified element.
     456      * <p>
     457      * Throws an <code>ArrayIndexOutOfBoundsException</code>
     458      * if the index is out of range
     459      * (<code>index &lt; 0 || index &gt;= size()</code>).
     460      *
     461      * @param index index of element to replace
     462      * @param element element to be stored at the specified position
     463      * @return the element previously at the specified position
     464      */
     465     public E set(int index, E element) {
     466         E rv = delegate.elementAt(index);
     467         delegate.setElementAt(element, index);
     468         fireContentsChanged(this, index, index);
     469         return rv;
     470     }
     471
     472     /**
     473      * Inserts the specified element at the specified position in this list.
     474      * <p>
     475      * Throws an <code>ArrayIndexOutOfBoundsException</code> if the
     476      * index is out of range
     477      * (<code>index &lt; 0 || index &gt; size()</code>).
     478      *
     479      * @param index index at which the specified element is to be inserted
     480      * @param element element to be inserted
     481      */
     482     public void add(int index, E element) {
     483         delegate.insertElementAt(element, index);
     484         fireIntervalAdded(this, index, index);
     485     }
     486
     487     /**
     488      * Removes the element at the specified position in this list.
     489      * Returns the element that was removed from the list.
     490      * <p>
     491      * Throws an <code>ArrayIndexOutOfBoundsException</code>
     492      * if the index is out of range
     493      * (<code>index &lt; 0 || index &gt;= size()</code>).
     494      *
     495      * @param index the index of the element to removed
     496      * @return the element previously at the specified position
     497      */
     498     public E remove(int index) {
     499         E rv = delegate.elementAt(index);
     500         delegate.removeElementAt(index);
     501         fireIntervalRemoved(this, index, index);
     502         return rv;
     503     }
     504
     505     /**
     506      * Removes all of the elements from this list.  The list will
     507      * be empty after this call returns (unless it throws an exception).
     508      */
     509     public void clear() {
     510         int index1 = delegate.size()-1;
     511         delegate.removeAllElements();
     512         if (index1 >= 0) {
     513             fireIntervalRemoved(this, 0, index1);
     514         }
     515     }
     516
     517     /**
     518      * Deletes the components at the specified range of indexes.
     519      * The removal is inclusive, so specifying a range of (1,5)
     520      * removes the component at index 1 and the component at index 5,
     521      * as well as all components in between.
     522      * <p>
     523      * Throws an <code>ArrayIndexOutOfBoundsException</code>
     524      * if the index was invalid.
     525      * Throws an <code>IllegalArgumentException</code> if
     526      * <code>fromIndex &gt; toIndex</code>.
     527      *
     528      * @param      fromIndex the index of the lower end of the range
     529      * @param      toIndex   the index of the upper end of the range
     530      * @see        #remove(int)
     531      */
     532     public void removeRange(int fromIndex, int toIndex) {
     533         if (fromIndex > toIndex) {
     534             throw new IllegalArgumentException("fromIndex must be <= toIndex");
     535         }
     536         for(int i = toIndex; i >= fromIndex; i--) {
     537             delegate.removeElementAt(i);
     538         }
     539         fireIntervalRemoved(this, fromIndex, toIndex);
     540     }
     541
     542     /*
     543     public void addAll(Collection c) {
     544     }
     545
     546     public void addAll(int index, Collection c) {
     547     }
     548     */
     549 }
    --- EOF ---