History

My first initial commit with all of mine experimental changes.

Dmitry Kabak (userdima committed 13 years ago

Commit d37b88d1 parent 3f5b46618352 files · +2598093 −-8690Browse files

Showing the changes to java/pkg/javax/swing/DefaultListModel.java (1 of 18352 files). Show all

Unified · Split

java/pkg/javax/swing/DefaultListModel.java+546−0
@@ -0,0 +1,546 @@
1/*
2 * Copyright (c) 1997, 2004, 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
26package javax.swing;
27
28import java.util.Vector;
29import java.util.Enumeration;
30
31import 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<sup><font size="-2">TM</font></sup>
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 */
55public class DefaultListModel<E> extends AbstractListModel<E>
56{
57 private Vector<E> delegate = new Vector<E>();
58
59 /**
60 * Returns the number of components in this list.
61 * <p>
62 * This method is identical to <code>size</code>, which implements the
63 * <code>List</code> interface defined in the 1.2 Collections framework.
64 * This method exists in conjunction with <code>setSize</code> so that
65 * <code>size</code> is identifiable as a JavaBean property.
66 *
67 * @return the number of components in this list
68 * @see #size()
69 */
70 public int getSize() {
71 return delegate.size();
72 }
73
74 /**
75 * Returns the component at the specified index.
76 * <blockquote>
77 * <b>Note:</b> Although this method is not deprecated, the preferred
78 * method to use is <code>get(int)</code>, which implements the
79 * <code>List</code> interface defined in the 1.2 Collections framework.
80 * </blockquote>
81 * @param index an index into this list
82 * @return the component at the specified index
83 * @exception ArrayIndexOutOfBoundsException if the <code>index</code>
84 * is negative or greater than the current size of this
85 * list
86 * @see #get(int)
87 */
88 public E getElementAt(int index) {
89 return delegate.elementAt(index);
90 }
91
92 /**
93 * Copies the components of this list into the specified array.
94 * The array must be big enough to hold all the objects in this list,
95 * else an <code>IndexOutOfBoundsException</code> is thrown.
96 *
97 * @param anArray the array into which the components get copied
98 * @see Vector#copyInto(Object[])
99 */
100 public void copyInto(Object anArray[]) {
101 delegate.copyInto(anArray);
102 }
103
104 /**
105 * Trims the capacity of this list to be the list's current size.
106 *
107 * @see Vector#trimToSize()
108 */
109 public void trimToSize() {
110 delegate.trimToSize();
111 }
112
113 /**
114 * Increases the capacity of this list, if necessary, to ensure
115 * that it can hold at least the number of components specified by
116 * the minimum capacity argument.
117 *
118 * @param minCapacity the desired minimum capacity
119 * @see Vector#ensureCapacity(int)
120 */
121 public void ensureCapacity(int minCapacity) {
122 delegate.ensureCapacity(minCapacity);
123 }
124
125 /**
126 * Sets the size of this list.
127 *
128 * @param newSize the new size of this list
129 * @see Vector#setSize(int)
130 */
131 public void setSize(int newSize) {
132 int oldSize = delegate.size();
133 delegate.setSize(newSize);
134 if (oldSize > newSize) {
135 fireIntervalRemoved(this, newSize, oldSize-1);
136 }
137 else if (oldSize < newSize) {
138 fireIntervalAdded(this, oldSize, newSize-1);
139 }
140 }
141
142 /**
143 * Returns the current capacity of this list.
144 *
145 * @return the current capacity
146 * @see Vector#capacity()
147 */
148 public int capacity() {
149 return delegate.capacity();
150 }
151
152 /**
153 * Returns the number of components in this list.
154 *
155 * @return the number of components in this list
156 * @see Vector#size()
157 */
158 public int size() {
159 return delegate.size();
160 }
161
162 /**
163 * Tests whether this list has any components.
164 *
165 * @return <code>true</code> if and only if this list has
166 * no components, that is, its size is zero;
167 * <code>false</code> otherwise
168 * @see Vector#isEmpty()
169 */
170 public boolean isEmpty() {
171 return delegate.isEmpty();
172 }
173
174 /**
175 * Returns an enumeration of the components of this list.
176 *
177 * @return an enumeration of the components of this list
178 * @see Vector#elements()
179 */
180 public Enumeration<E> elements() {
181 return delegate.elements();
182 }
183
184 /**
185 * Tests whether the specified object is a component in this list.
186 *
187 * @param elem an object
188 * @return <code>true</code> if the specified object
189 * is the same as a component in this list
190 * @see Vector#contains(Object)
191 */
192 public boolean contains(Object elem) {
193 return delegate.contains(elem);
194 }
195
196 /**
197 * Searches for the first occurrence of <code>elem</code>.
198 *
199 * @param elem an object
200 * @return the index of the first occurrence of the argument in this
201 * list; returns <code>-1</code> if the object is not found
202 * @see Vector#indexOf(Object)
203 */
204 public int indexOf(Object elem) {
205 return delegate.indexOf(elem);
206 }
207
208 /**
209 * Searches for the first occurrence of <code>elem</code>, beginning
210 * the search at <code>index</code>.
211 *
212 * @param elem an desired component
213 * @param index the index from which to begin searching
214 * @return the index where the first occurrence of <code>elem</code>
215 * is found after <code>index</code>; returns <code>-1</code>
216 * if the <code>elem</code> is not found in the list
217 * @see Vector#indexOf(Object,int)
218 */
219 public int indexOf(Object elem, int index) {
220 return delegate.indexOf(elem, index);
221 }
222
223 /**
224 * Returns the index of the last occurrence of <code>elem</code>.
225 *
226 * @param elem the desired component
227 * @return the index of the last occurrence of <code>elem</code>
228 * in the list; returns <code>-1</code> if the object is not found
229 * @see Vector#lastIndexOf(Object)
230 */
231 public int lastIndexOf(Object elem) {
232 return delegate.lastIndexOf(elem);
233 }
234
235 /**
236 * Searches backwards for <code>elem</code>, starting from the
237 * specified index, and returns an index to it.
238 *
239 * @param elem the desired component
240 * @param index the index to start searching from
241 * @return the index of the last occurrence of the <code>elem</code>
242 * in this list at position less than <code>index</code>;
243 * returns <code>-1</code> if the object is not found
244 * @see Vector#lastIndexOf(Object,int)
245 */
246 public int lastIndexOf(Object elem, int index) {
247 return delegate.lastIndexOf(elem, index);
248 }
249
250 /**
251 * Returns the component at the specified index.
252 * Throws an <code>ArrayIndexOutOfBoundsException</code> if the index
253 * is negative or not less than the size of the list.
254 * <blockquote>
255 * <b>Note:</b> Although this method is not deprecated, the preferred
256 * method to use is <code>get(int)</code>, which implements the
257 * <code>List</code> interface defined in the 1.2 Collections framework.
258 * </blockquote>
259 *
260 * @param index an index into this list
261 * @return the component at the specified index
262 * @see #get(int)
263 * @see Vector#elementAt(int)
264 */
265 public E elementAt(int index) {
266 return delegate.elementAt(index);
267 }
268
269 /**
270 * Returns the first component of this list.
271 * Throws a <code>NoSuchElementException</code> if this
272 * vector has no components.
273 * @return the first component of this list
274 * @see Vector#firstElement()
275 */
276 public E firstElement() {
277 return delegate.firstElement();
278 }
279
280 /**
281 * Returns the last component of the list.
282 * Throws a <code>NoSuchElementException</code> if this vector
283 * has no components.
284 *
285 * @return the last component of the list
286 * @see Vector#lastElement()
287 */
288 public E lastElement() {
289 return delegate.lastElement();
290 }
291
292 /**
293 * Sets the component at the specified <code>index</code> of this
294 * list to be the specified element. The previous component at that
295 * position is discarded.
296 * <p>
297 * Throws an <code>ArrayIndexOutOfBoundsException</code> if the index
298 * is invalid.
299 * <blockquote>
300 * <b>Note:</b> Although this method is not deprecated, the preferred
301 * method to use is <code>set(int,Object)</code>, which implements the
302 * <code>List</code> interface defined in the 1.2 Collections framework.
303 * </blockquote>
304 *
305 * @param element what the component is to be set to
306 * @param index the specified index
307 * @see #set(int,Object)
308 * @see Vector#setElementAt(Object,int)
309 */
310 public void setElementAt(E element, int index) {
311 delegate.setElementAt(element, index);
312 fireContentsChanged(this, index, index);
313 }
314
315 /**
316 * Deletes the component at the specified index.
317 * <p>
318 * Throws an <code>ArrayIndexOutOfBoundsException</code> if the index
319 * is invalid.
320 * <blockquote>
321 * <b>Note:</b> Although this method is not deprecated, the preferred
322 * method to use is <code>remove(int)</code>, which implements the
323 * <code>List</code> interface defined in the 1.2 Collections framework.
324 * </blockquote>
325 *
326 * @param index the index of the object to remove
327 * @see #remove(int)
328 * @see Vector#removeElementAt(int)
329 */
330 public void removeElementAt(int index) {
331 delegate.removeElementAt(index);
332 fireIntervalRemoved(this, index, index);
333 }
334
335 /**
336 * Inserts the specified element as a component in this list at the
337 * specified <code>index</code>.
338 * <p>
339 * Throws an <code>ArrayIndexOutOfBoundsException</code> if the index
340 * is invalid.
341 * <blockquote>
342 * <b>Note:</b> Although this method is not deprecated, the preferred
343 * method to use is <code>add(int,Object)</code>, which implements the
344 * <code>List</code> interface defined in the 1.2 Collections framework.
345 * </blockquote>
346 *
347 * @param element the component to insert
348 * @param index where to insert the new component
349 * @exception ArrayIndexOutOfBoundsException if the index was invalid
350 * @see #add(int,Object)
351 * @see Vector#insertElementAt(Object,int)
352 */
353 public void insertElementAt(E element, int index) {
354 delegate.insertElementAt(element, index);
355 fireIntervalAdded(this, index, index);
356 }
357
358 /**
359 * Adds the specified component to the end of this list.
360 *
361 * @param element the component to be added
362 * @see Vector#addElement(Object)
363 */
364 public void addElement(E element) {
365 int index = delegate.size();
366 delegate.addElement(element);
367 fireIntervalAdded(this, index, index);
368 }
369
370 /**
371 * Removes the first (lowest-indexed) occurrence of the argument
372 * from this list.
373 *
374 * @param obj the component to be removed
375 * @return <code>true</code> if the argument was a component of this
376 * list; <code>false</code> otherwise
377 * @see Vector#removeElement(Object)
378 */
379 public boolean removeElement(Object obj) {
380 int index = indexOf(obj);
381 boolean rv = delegate.removeElement(obj);
382 if (index >= 0) {
383 fireIntervalRemoved(this, index, index);
384 }
385 return rv;
386 }
387
388
389 /**
390 * Removes all components from this list and sets its size to zero.
391 * <blockquote>
392 * <b>Note:</b> Although this method is not deprecated, the preferred
393 * method to use is <code>clear</code>, which implements the
394 * <code>List</code> interface defined in the 1.2 Collections framework.
395 * </blockquote>
396 *
397 * @see #clear()
398 * @see Vector#removeAllElements()
399 */
400 public void removeAllElements() {
401 int index1 = delegate.size()-1;
402 delegate.removeAllElements();
403 if (index1 >= 0) {
404 fireIntervalRemoved(this, 0, index1);
405 }
406 }
407
408
409 /**
410 * Returns a string that displays and identifies this
411 * object's properties.
412 *
413 * @return a String representation of this object
414 */
415 public String toString() {
416 return delegate.toString();
417 }
418
419
420 /* The remaining methods are included for compatibility with the
421 * Java 2 platform Vector class.
422 */
423
424 /**
425 * Returns an array containing all of the elements in this list in the
426 * correct order.
427 *
428 * @return an array containing the elements of the list
429 * @see Vector#toArray()
430 */
431 public Object[] toArray() {
432 Object[] rv = new Object[delegate.size()];
433 delegate.copyInto(rv);
434 return rv;
435 }
436
437 /**
438 * Returns the element at the specified position in this list.
439 * <p>
440 * Throws an <code>ArrayIndexOutOfBoundsException</code>
441 * if the index is out of range
442 * (<code>index &lt; 0 || index &gt;= size()</code>).
443 *
444 * @param index index of element to return
445 */
446 public E get(int index) {
447 return delegate.elementAt(index);
448 }
449
450 /**
451 * Replaces the element at the specified position in this list with the
452 * specified element.
453 * <p>
454 * Throws an <code>ArrayIndexOutOfBoundsException</code>
455 * if the index is out of range
456 * (<code>index &lt; 0 || index &gt;= size()</code>).
457 *
458 * @param index index of element to replace
459 * @param element element to be stored at the specified position
460 * @return the element previously at the specified position
461 */
462 public E set(int index, E element) {
463 E rv = delegate.elementAt(index);
464 delegate.setElementAt(element, index);
465 fireContentsChanged(this, index, index);
466 return rv;
467 }
468
469 /**
470 * Inserts the specified element at the specified position in this list.
471 * <p>
472 * Throws an <code>ArrayIndexOutOfBoundsException</code> if the
473 * index is out of range
474 * (<code>index &lt; 0 || index &gt; size()</code>).
475 *
476 * @param index index at which the specified element is to be inserted
477 * @param element element to be inserted
478 */
479 public void add(int index, E element) {
480 delegate.insertElementAt(element, index);
481 fireIntervalAdded(this, index, index);
482 }
483
484 /**
485 * Removes the element at the specified position in this list.
486 * Returns the element that was removed from the list.
487 * <p>
488 * Throws an <code>ArrayIndexOutOfBoundsException</code>
489 * if the index is out of range
490 * (<code>index &lt; 0 || index &gt;= size()</code>).
491 *
492 * @param index the index of the element to removed
493 * @return the element previously at the specified position
494 */
495 public E remove(int index) {
496 E rv = delegate.elementAt(index);
497 delegate.removeElementAt(index);
498 fireIntervalRemoved(this, index, index);
499 return rv;
500 }
501
502 /**
503 * Removes all of the elements from this list. The list will
504 * be empty after this call returns (unless it throws an exception).
505 */
506 public void clear() {
507 int index1 = delegate.size()-1;
508 delegate.removeAllElements();
509 if (index1 >= 0) {
510 fireIntervalRemoved(this, 0, index1);
511 }
512 }
513
514 /**
515 * Deletes the components at the specified range of indexes.
516 * The removal is inclusive, so specifying a range of (1,5)
517 * removes the component at index 1 and the component at index 5,
518 * as well as all components in between.
519 * <p>
520 * Throws an <code>ArrayIndexOutOfBoundsException</code>
521 * if the index was invalid.
522 * Throws an <code>IllegalArgumentException</code> if
523 * <code>fromIndex &gt; toIndex</code>.
524 *
525 * @param fromIndex the index of the lower end of the range
526 * @param toIndex the index of the upper end of the range
527 * @see #remove(int)
528 */
529 public void removeRange(int fromIndex, int toIndex) {
530 if (fromIndex > toIndex) {
531 throw new IllegalArgumentException("fromIndex must be <= toIndex");
532 }
533 for(int i = toIndex; i >= fromIndex; i--) {
534 delegate.removeElementAt(i);
535 }
536 fireIntervalRemoved(this, fromIndex, toIndex);
537 }
538
539 /*
540 public void addAll(Collection c) {
541 }
542
543 public void addAll(int index, Collection c) {
544 }
545 */
546}