Author: tchemit Date: 2013-02-05 10:02:11 +0100 (Tue, 05 Feb 2013) New Revision: 2557 Url: http://nuiton.org/projects/jaxx/repository/revisions/2557 Log: fixes #2520: Introduce a new comboBoxModel which does not use a Vector fixes #2521: Introduce a new listModel which does not use a Vector fixes #2522: Improve the DoubleListBean api Added: trunk/jaxx-runtime/src/main/java/jaxx/runtime/swing/model/JaxxDefaultComboBoxModel.java trunk/jaxx-runtime/src/main/java/jaxx/runtime/swing/model/JaxxDefaultListModel.java Modified: trunk/jaxx-runtime/src/main/java/jaxx/runtime/SwingUtil.java trunk/jaxx-validator/src/main/java/jaxx/runtime/validator/swing/SwingValidatorMessageWidget.java trunk/jaxx-validator/src/main/resources/icons/action-table-error.png trunk/jaxx-widgets/src/main/java/jaxx/runtime/swing/editor/bean/BeanComboBox.css trunk/jaxx-widgets/src/main/java/jaxx/runtime/swing/editor/bean/BeanComboBox.jaxx trunk/jaxx-widgets/src/main/java/jaxx/runtime/swing/editor/bean/BeanDoubleList.css trunk/jaxx-widgets/src/main/java/jaxx/runtime/swing/editor/bean/BeanDoubleList.jaxx trunk/jaxx-widgets/src/main/java/jaxx/runtime/swing/editor/bean/BeanDoubleListModel.java Modified: trunk/jaxx-runtime/src/main/java/jaxx/runtime/SwingUtil.java =================================================================== --- trunk/jaxx-runtime/src/main/java/jaxx/runtime/SwingUtil.java 2013-01-09 18:40:51 UTC (rev 2556) +++ trunk/jaxx-runtime/src/main/java/jaxx/runtime/SwingUtil.java 2013-02-05 09:02:11 UTC (rev 2557) @@ -27,6 +27,8 @@ import jaxx.runtime.swing.Item; import jaxx.runtime.swing.JAXXComboBox; import jaxx.runtime.swing.editor.BooleanCellEditor; +import jaxx.runtime.swing.model.JaxxDefaultComboBoxModel; +import jaxx.runtime.swing.model.JaxxDefaultListModel; import jaxx.runtime.swing.renderer.BooleanCellRenderer; import jaxx.runtime.swing.renderer.EmptyNumberTableCellRenderer; import jaxx.runtime.swing.renderer.EnumTableCellRenderer; @@ -37,6 +39,7 @@ import org.jdesktop.jxlayer.plaf.LayerUI; import org.jdesktop.swingx.JXTreeTable; +import javax.swing.ComboBoxModel; import javax.swing.DefaultComboBoxModel; import javax.swing.DefaultListModel; import javax.swing.Icon; @@ -50,6 +53,7 @@ import javax.swing.JTabbedPane; import javax.swing.JTable; import javax.swing.JTree; +import javax.swing.ListModel; import javax.swing.ListSelectionModel; import javax.swing.SwingUtilities; import javax.swing.UIManager; @@ -199,23 +203,41 @@ */ public static void fillComboBox(JComboBox combo, Collection<?> data, Object select) { - if (!(combo.getModel() instanceof DefaultComboBoxModel)) { + + ComboBoxModel comboBoxModel = combo.getModel(); + + if (comboBoxModel instanceof JaxxDefaultComboBoxModel) { + JaxxDefaultComboBoxModel model = + (JaxxDefaultComboBoxModel) comboBoxModel; + + // evince the model + model.removeListDataListener(combo); + + // set data + model.setAllElements((Collection) data); + + // attach the model + model.addListDataListener(combo); + model.setSelectedItem(select); + } else if (comboBoxModel instanceof DefaultComboBoxModel) { + DefaultComboBoxModel model = (DefaultComboBoxModel) combo.getModel(); + // evince the model + model.removeListDataListener(combo); + model.removeAllElements(); + if (data != null) { + for (Object o : data) { + model.addElement(o); + } + } + // attach the model + model.addListDataListener(combo); + model.setSelectedItem(select); + } else { throw new IllegalArgumentException( "this method need a DefaultComboBoxModel for " + "this model but was " + combo.getModel().getClass()); } - DefaultComboBoxModel model = (DefaultComboBoxModel) combo.getModel(); - // evince the model - model.removeListDataListener(combo); - model.removeAllElements(); - if (data != null) { - for (Object o : data) { - model.addElement(o); - } - } - // attach the model - model.addListDataListener(combo); - model.setSelectedItem(select); + } /** @@ -226,23 +248,35 @@ * @param select the object to select in combo after reflling his model */ public static void fillList(JList list, Collection<?> data, Object select) { - if (!(list.getModel() instanceof DefaultListModel)) { + ListModel listModel = list.getModel(); + if (listModel instanceof JaxxDefaultListModel) { + JaxxDefaultListModel model = (JaxxDefaultListModel) listModel; + + // evince the model +// model.removeListDataListener(combo); + model.setAllElements(data); + + // attach the model +// model.addListDataListener(combo); + list.setSelectedValue(select, true); + } else if (listModel instanceof DefaultListModel) { + DefaultListModel model = (DefaultListModel) listModel; + // evince the model +// model.removeListDataListener(combo); + model.removeAllElements(); + if (data != null) { + for (Object o : data) { + model.addElement(o); + } + } + // attach the model +// model.addListDataListener(combo); + list.setSelectedValue(select, true); + } else { throw new IllegalArgumentException( "this method need a DefaultListModel for this model " + - "but was " + list.getModel().getClass()); + "but was " + listModel.getClass()); } - DefaultListModel model = (DefaultListModel) list.getModel(); - // evince the model -// model.removeListDataListener(combo); - model.removeAllElements(); - if (data != null) { - for (Object o : data) { - model.addElement(o); - } - } - // attach the model -// model.addListDataListener(combo); - list.setSelectedValue(select, true); } /** Added: trunk/jaxx-runtime/src/main/java/jaxx/runtime/swing/model/JaxxDefaultComboBoxModel.java =================================================================== --- trunk/jaxx-runtime/src/main/java/jaxx/runtime/swing/model/JaxxDefaultComboBoxModel.java (rev 0) +++ trunk/jaxx-runtime/src/main/java/jaxx/runtime/swing/model/JaxxDefaultComboBoxModel.java 2013-02-05 09:02:11 UTC (rev 2557) @@ -0,0 +1,181 @@ +package jaxx.runtime.swing.model; + +/* + * #%L + * JAXX :: Runtime + * $Id$ + * $HeadURL$ + * %% + * Copyright (C) 2008 - 2013 CodeLutin, Tony Chemit + * %% + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. + * + * This program 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 Lesser Public License for more details. + * + * You should have received a copy of the GNU General Lesser Public + * License along with this program. If not, see + * <http://www.gnu.org/licenses/lgpl-3.0.html>. + * #L% + */ + +import org.apache.commons.collections.CollectionUtils; + +import javax.swing.AbstractListModel; +import javax.swing.DefaultComboBoxModel; +import javax.swing.MutableComboBoxModel; +import java.io.Serializable; +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; +import java.util.Vector; + +/** + * To replace the {@link DefaultComboBoxModel} which used {@link Vector}. + * <p/> + * Add some new methods to {@link #addAllElements(Collection)} or + * {@link #setAllElements(Collection)}. + * + * @author tchemit <chemit@codelutin.com> + * @since 2.5.10 + */ +public class JaxxDefaultComboBoxModel<E> extends AbstractListModel implements MutableComboBoxModel, Serializable { + + private static final long serialVersionUID = 1L; + + protected List<E> delegate; + + protected E selectedObject; + + public JaxxDefaultComboBoxModel() { + delegate = new ArrayList<E>(); + } + + public JaxxDefaultComboBoxModel(E... items) { + delegate = new ArrayList<E>(items.length); + + int i, c; + for (i = 0, c = items.length; i < c; i++) + delegate.add(items[i]); + + if (getSize() > 0) { + selectedObject = getElementAt(0); + } + } + + public JaxxDefaultComboBoxModel(Collection<E> v) { + delegate = new ArrayList<E>(v); + + if (getSize() > 0) { + selectedObject = getElementAt(0); + } + } + + @Override + public void setSelectedItem(Object anObject) { + if ((selectedObject != null && !selectedObject.equals(anObject)) || + selectedObject == null && anObject != null) { + selectedObject = (E) anObject; + fireContentsChanged(this, -1, -1); + } + } + + public int getIndexOf(E anObject) { + return delegate.indexOf(anObject); + } + + + public void setAllElements(Collection<E> objects) { + removeAllElements(); + addAllElements(objects); + } + + public void addAllElements(Collection<E> objects) { + if (CollectionUtils.isNotEmpty(objects)) { + int firstIndex = delegate.size(); + this.delegate.addAll(objects); + int lastIndex = delegate.size() - 1; + if (lastIndex > -1) { + fireIntervalAdded(this, firstIndex, lastIndex); + } + } + } + + /** Empties the list. */ + public void removeAllElements() { + if (delegate.size() > 0) { + int firstIndex = 0; + int lastIndex = delegate.size() - 1; + delegate.clear(); + selectedObject = null; + fireIntervalRemoved(this, firstIndex, lastIndex); + } else { + selectedObject = null; + } + } + + @Override + public E getSelectedItem() { + return selectedObject; + } + + @Override + public int getSize() { + return delegate.size(); + } + + @Override + public E getElementAt(int index) { + E result; + + if (index >= 0 && index < delegate.size()) { + result = delegate.get(index); + } else { + result = null; + } + return result; + } + + @Override + public void addElement(Object anObject) { + delegate.add((E) anObject); + fireIntervalAdded(this, delegate.size() - 1, delegate.size() - 1); + if (delegate.size() == 1 && selectedObject == null && anObject != null) { + setSelectedItem(anObject); + } + } + + @Override + public void insertElementAt(Object anObject, int index) { + delegate.add(index, (E) anObject); + fireIntervalAdded(this, index, index); + } + + @Override + public void removeElementAt(int index) { + if (getElementAt(index) == selectedObject) { + if (index == 0) { + setSelectedItem(getSize() == 1 ? null : getElementAt(index + 1)); + } else { + setSelectedItem(getElementAt(index - 1)); + } + } + + delegate.remove(index); + + fireIntervalRemoved(this, index, index); + } + + @Override + public void removeElement(Object anObject) { + int index = delegate.indexOf(anObject); + if (index != -1) { + removeElementAt(index); + } + } +} Property changes on: trunk/jaxx-runtime/src/main/java/jaxx/runtime/swing/model/JaxxDefaultComboBoxModel.java ___________________________________________________________________ Added: svn:keywords + Author Date Id Revision HeadURL Added: svn:eol-style + native Added: trunk/jaxx-runtime/src/main/java/jaxx/runtime/swing/model/JaxxDefaultListModel.java =================================================================== --- trunk/jaxx-runtime/src/main/java/jaxx/runtime/swing/model/JaxxDefaultListModel.java (rev 0) +++ trunk/jaxx-runtime/src/main/java/jaxx/runtime/swing/model/JaxxDefaultListModel.java 2013-02-05 09:02:11 UTC (rev 2557) @@ -0,0 +1,553 @@ +package jaxx.runtime.swing.model; + +/* + * #%L + * JAXX :: Runtime + * $Id$ + * $HeadURL$ + * %% + * Copyright (C) 2008 - 2013 CodeLutin, Tony Chemit + * %% + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. + * + * This program 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 Lesser Public License for more details. + * + * You should have received a copy of the GNU General Lesser Public + * License along with this program. If not, see + * <http://www.gnu.org/licenses/lgpl-3.0.html>. + * #L% + */ + +import org.apache.commons.collections.CollectionUtils; + +import javax.swing.AbstractListModel; +import javax.swing.DefaultListModel; +import java.util.ArrayList; +import java.util.Collection; +import java.util.NoSuchElementException; +import java.util.Vector; + +/** + * To replace the {@link DefaultListModel} which used {@link Vector}. + * + * @author tchemit <chemit@codelutin.com> + * @since 2.5.10 + */ +public class JaxxDefaultListModel<E> extends AbstractListModel { + + private static final long serialVersionUID = 1L; + + private ArrayList<E> delegate = new ArrayList<E>(); + + /** + * Returns the number of components in this list. + * <p/> + * This method is identical to <code>size</code>, which implements the + * <code>List</code> interface defined in the 1.2 Collections framework. + * This method exists in conjunction with <code>setSize</code> so that + * <code>size</code> is identifiable as a JavaBean property. + * + * @return the number of components in this list + * @see #size() + */ + @Override + 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)</code>, which implements the + * <code>List</code> 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</code> + * is negative or greater than the current size of this + * list + * @see #get(int) + */ + @Override + public E getElementAt(int index) { + return delegate.get(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</code> 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.ensureCapacity(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.size(); + } + + /** + * 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</code> if and only if this list has + * no components, that is, its size is zero; + * <code>false</code> 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.iterator().elements(); +// } + + /** + * Tests whether the specified object is a component in this list. + * + * @param elem an object + * @return <code>true</code> if the specified object + * is the same as a component in this list + * @see Vector#contains(Object) + */ + public boolean contains(E elem) { + return delegate.contains(elem); + } + + /** + * Searches for the first occurrence of <code>elem</code>. + * + * @param elem an object + * @return the index of the first occurrence of the argument in this + * list; returns <code>-1</code> if the object is not found + * @see Vector#indexOf(Object) + */ + public int indexOf(E elem) { + return delegate.indexOf(elem); + } + + /** + * Searches for the first occurrence of <code>elem</code>, beginning + * the search at <code>index</code>. + * + * @param elem an desired component + * @param index the index from which to begin searching + * @return the index where the first occurrence of <code>elem</code> + * is found after <code>index</code>; returns <code>-1</code> + * if the <code>elem</code> is not found in the list + * @see Vector#indexOf(Object, int) + */ + public int indexOf(E elem, int index) { + return delegate.indexOf(elem); + } + + /** + * Returns the index of the last occurrence of <code>elem</code>. + * + * @param elem the desired component + * @return the index of the last occurrence of <code>elem</code> + * in the list; returns <code>-1</code> if the object is not found + * @see Vector#lastIndexOf(Object) + */ + public int lastIndexOf(E elem) { + return delegate.lastIndexOf(elem); + } + + /** + * Searches backwards for <code>elem</code>, 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</code> + * in this list at position less than <code>index</code>; + * returns <code>-1</code> if the object is not found + * @see Vector#lastIndexOf(Object, int) + */ + public int lastIndexOf(E elem, int index) { + return delegate.lastIndexOf(elem); + } + + /** + * Returns the component at the specified index. + * Throws an <code>ArrayIndexOutOfBoundsException</code> if the index + * is negative or not less than the size of the list. + * <blockquote> + * <b>Note:</b> Although this method is not deprecated, the preferred + * method to use is <code>get(int)</code>, which implements the + * <code>List</code> interface defined in the 1.2 Collections framework. + * </blockquote> + * + * @param index an index into this list + * @return the component at the specified index + * @see #get(int) + * @see Vector#elementAt(int) + */ + public E elementAt(int index) { + return delegate.get(index); + } + + /** + * Returns the first component of this list. + * Throws a <code>NoSuchElementException</code> if this + * vector has no components. + * + * @return the first component of this list + * @see Vector#firstElement() + */ + public E firstElement() { + if (isEmpty()) { + throw new NoSuchElementException(); + } + return delegate.get(0); + } + + /** + * Returns the last component of the list. + * Throws a <code>NoSuchElementException</code> if this vector + * has no components. + * + * @return the last component of the list + * @see Vector#lastElement() + */ + public E lastElement() { + if (isEmpty()) { + throw new NoSuchElementException(); + } + return delegate.get(delegate.size() - 1); + } + + /** + * Sets the component at the specified <code>index</code> of this + * list to be the specified element. The previous component at that + * position is discarded. + * <p/> + * Throws an <code>ArrayIndexOutOfBoundsException</code> if the index + * is invalid. + * <blockquote> + * <b>Note:</b> Although this method is not deprecated, the preferred + * method to use is <code>set(int,Object)</code>, which implements the + * <code>List</code> interface defined in the 1.2 Collections framework. + * </blockquote> + * + * @param element what the component is to be set to + * @param index the specified index + * @see #set(int, Object) + * @see Vector#setElementAt(Object, int) + */ + public void setElementAt(E element, int index) { + delegate.set(index, element); + fireContentsChanged(this, index, index); + } + + /** + * Deletes the component at the specified index. + * <p/> + * Throws an <code>ArrayIndexOutOfBoundsException</code> if the index + * is invalid. + * <blockquote> + * <b>Note:</b> Although this method is not deprecated, the preferred + * method to use is <code>remove(int)</code>, which implements the + * <code>List</code> 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) + */ + public void removeElementAt(int index) { + delegate.remove(index); + fireIntervalRemoved(this, index, index); + } + + /** + * Inserts the specified element as a component in this list at the + * specified <code>index</code>. + * <p/> + * Throws an <code>ArrayIndexOutOfBoundsException</code> if the index + * is invalid. + * <blockquote> + * <b>Note:</b> Although this method is not deprecated, the preferred + * method to use is <code>add(int,Object)</code>, which implements the + * <code>List</code> interface defined in the 1.2 Collections framework. + * </blockquote> + * + * @param element the component to insert + * @param index where to insert the new component + * @throws ArrayIndexOutOfBoundsException if the index was invalid + * @see #add(int, Object) + * @see Vector#insertElementAt(Object, int) + */ + public void insertElementAt(E element, int index) { + delegate.set(index, element); + 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.add(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</code> if the argument was a component of this + * list; <code>false</code> otherwise + * @see Vector#removeElement(Object) + */ + public boolean removeElement(E obj) { + int index = indexOf(obj); + boolean rv = delegate.remove(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</code>, which implements the + * <code>List</code> interface defined in the 1.2 Collections framework. + * </blockquote> + * + * @see #clear() + * @see Vector#removeAllElements() + */ + public void removeAllElements() { + int index1 = delegate.size() - 1; + delegate.clear(); + if (index1 >= 0) { + fireIntervalRemoved(this, 0, index1); + } + } + + @Override + 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 = delegate.toArray(); + return rv; + } + + /** + * Returns the element at the specified position in this list. + * <p/> + * Throws an <code>ArrayIndexOutOfBoundsException</code> + * if the index is out of range + * (<code>index < 0 || index >= size()</code>). + * + * @param index index of element to return + */ + public E get(int index) { + return delegate.get(index); + } + + /** + * Replaces the element at the specified position in this list with the + * specified element. + * <p/> + * Throws an <code>ArrayIndexOutOfBoundsException</code> + * if the index is out of range + * (<code>index < 0 || index >= size()</code>). + * + * @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 + */ + public E set(int index, E element) { + E rv = delegate.set(index, element); + fireContentsChanged(this, index, index); + return rv; + } + + /** + * Inserts the specified element at the specified position in this list. + * <p/> + * Throws an <code>ArrayIndexOutOfBoundsException</code> if the + * index is out of range + * (<code>index < 0 || index > size()</code>). + * + * @param index index at which the specified element is to be inserted + * @param element element to be inserted + */ + public void add(int index, E element) { + delegate.add(index, element); + fireIntervalAdded(this, index, index); + } + + public void setAllElements(Collection<E> objects) { + removeAllElements(); + addAllElements(objects); + } + + public void addAllElements(Collection<E> elements) { + if (CollectionUtils.isNotEmpty(elements)) { + + int firstIndex = delegate.size(); + this.delegate.addAll(elements); + int lastIndex = delegate.size() - 1; + if (lastIndex > -1) { + fireIntervalAdded(this, firstIndex, lastIndex); + } + } + } + + /** + * Removes the element at the specified position in this list. + * Returns the element that was removed from the list. + * <p/> + * Throws an <code>ArrayIndexOutOfBoundsException</code> + * if the index is out of range + * (<code>index < 0 || index >= size()</code>). + * + * @param index the index of the element to removed + * @return the element previously at the specified position + */ + public E remove(int index) { + E rv = delegate.remove(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.clear(); + 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. + * <p/> + * Throws an <code>ArrayIndexOutOfBoundsException</code> + * if the index was invalid. + * Throws an <code>IllegalArgumentException</code> if + * <code>fromIndex > toIndex</code>. + * + * @param fromIndex the index of the lower end of the range + * @param toIndex the index of the upper end of the range + * @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.remove(i); + } + fireIntervalRemoved(this, fromIndex, toIndex); + } + + + + /* + public void addAll(Collection c) { + } + + public void addAll(int index, Collection c) { + }*/ +} \ No newline at end of file Property changes on: trunk/jaxx-runtime/src/main/java/jaxx/runtime/swing/model/JaxxDefaultListModel.java ___________________________________________________________________ Added: svn:keywords + Author Date Id Revision HeadURL Added: svn:eol-style + native Modified: trunk/jaxx-validator/src/main/java/jaxx/runtime/validator/swing/SwingValidatorMessageWidget.java =================================================================== --- trunk/jaxx-validator/src/main/java/jaxx/runtime/validator/swing/SwingValidatorMessageWidget.java 2013-01-09 18:40:51 UTC (rev 2556) +++ trunk/jaxx-validator/src/main/java/jaxx/runtime/validator/swing/SwingValidatorMessageWidget.java 2013-02-05 09:02:11 UTC (rev 2557) @@ -1,14 +1,34 @@ package jaxx.runtime.validator.swing; -import java.awt.event.ActionEvent; -import java.awt.event.ActionListener; -import java.awt.event.KeyAdapter; -import java.awt.event.KeyEvent; -import java.awt.event.MouseAdapter; -import java.awt.event.MouseEvent; -import java.awt.event.WindowAdapter; -import java.awt.event.WindowEvent; +/* + * #%L + * JAXX :: Validator + * $Id$ + * $HeadURL$ + * %% + * Copyright (C) 2008 - 2013 CodeLutin + * %% + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. + * + * This program 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 Lesser Public License for more details. + * + * You should have received a copy of the GNU General Lesser Public + * License along with this program. If not, see + * <http://www.gnu.org/licenses/lgpl-3.0.html>. + * #L% + */ + +import jaxx.runtime.SwingUtil; +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; + import javax.swing.AbstractAction; import javax.swing.JComponent; import javax.swing.JDialog; @@ -18,32 +38,34 @@ import javax.swing.JToggleButton; import javax.swing.KeyStroke; import javax.swing.ListSelectionModel; -import javax.swing.event.ChangeEvent; -import javax.swing.event.ChangeListener; -import jaxx.runtime.SwingUtil; -import org.apache.commons.logging.Log; -import org.apache.commons.logging.LogFactory; +import java.awt.event.ActionEvent; +import java.awt.event.ActionListener; +import java.awt.event.KeyEvent; +import java.awt.event.WindowAdapter; +import java.awt.event.WindowEvent; /** - * Button which opens a popup containing a table with the errors found + * Button which opens a popup containing a table with the errors found * by registered validators. - * + * * @author kmorin <kmorin@codelutin.com> * @since 2.5.10 */ public class SwingValidatorMessageWidget extends JToggleButton { private static final Log log = LogFactory.getLog(SwingValidatorMessageWidget.class); - + + private static final long serialVersionUID = 1L; + protected SwingValidatorMessageTableModel errorTableModel = new SwingValidatorMessageTableModel(); - + protected JDialog popup = new JDialog(); - + protected JTable errorTable = new JTable(); - + public SwingValidatorMessageWidget() { super(SwingUtil.createActionIcon("table-error")); - + errorTable.setModel(errorTableModel); errorTable.setRowSelectionAllowed(true); errorTable.setAutoCreateRowSorter(true); @@ -51,20 +73,20 @@ errorTable.setCellSelectionEnabled(false); errorTable.setSelectionMode(ListSelectionModel.SINGLE_SELECTION); errorTable.setFillsViewportHeight(true); - + SwingValidatorUtil.installUI(errorTable, new SwingValidatorMessageTableRenderer()); - + JScrollPane scrollPanel = new JScrollPane(errorTable); scrollPanel.setColumnHeaderView(errorTable.getTableHeader()); popup.add(scrollPanel); popup.setSize(800, 300); - + addActionListener(new ActionListener() { @Override public void actionPerformed(ActionEvent e) { - if(isSelected()) { + if (isSelected()) { popup.setVisible(true); } else { popup.dispose(); @@ -77,9 +99,9 @@ public void windowClosing(WindowEvent e) { setSelected(false); } - + }); - + // add a auto-close action JRootPane rootPane = popup.getRootPane(); @@ -97,13 +119,13 @@ } }); } - + public void registerValidator(SwingValidator validator) { errorTableModel.registerValidator(validator); } - + public void clearValidators() { errorTableModel.clearValidators(); } - + } Property changes on: trunk/jaxx-validator/src/main/java/jaxx/runtime/validator/swing/SwingValidatorMessageWidget.java ___________________________________________________________________ Added: svn:keywords + Author Date Id Revision HeadURL Added: svn:eol-style + native Property changes on: trunk/jaxx-validator/src/main/resources/icons/action-table-error.png ___________________________________________________________________ Added: svn:keywords + Author Date Id Revision HeadURL Modified: trunk/jaxx-widgets/src/main/java/jaxx/runtime/swing/editor/bean/BeanComboBox.css =================================================================== --- trunk/jaxx-widgets/src/main/java/jaxx/runtime/swing/editor/bean/BeanComboBox.css 2013-01-09 18:40:51 UTC (rev 2556) +++ trunk/jaxx-widgets/src/main/java/jaxx/runtime/swing/editor/bean/BeanComboBox.css 2013-02-05 09:02:11 UTC (rev 2557) @@ -70,6 +70,7 @@ } #combobox { + model: {new JaxxDefaultComboBoxModel<O>()}; selectedItem:{getSelectedItem()}; enabled:{isEnabled()}; editable:{isEditable()}; Modified: trunk/jaxx-widgets/src/main/java/jaxx/runtime/swing/editor/bean/BeanComboBox.jaxx =================================================================== --- trunk/jaxx-widgets/src/main/java/jaxx/runtime/swing/editor/bean/BeanComboBox.jaxx 2013-01-09 18:40:51 UTC (rev 2556) +++ trunk/jaxx-widgets/src/main/java/jaxx/runtime/swing/editor/bean/BeanComboBox.jaxx 2013-02-05 09:02:11 UTC (rev 2557) @@ -28,6 +28,7 @@ onFocusGained='combobox.requestFocus()' onFocusLost='hidePopup()'> <import> + jaxx.runtime.swing.model.JaxxDefaultComboBoxModel org.nuiton.util.decorator.JXPathDecorator javax.swing.border.TitledBorder </import> Modified: trunk/jaxx-widgets/src/main/java/jaxx/runtime/swing/editor/bean/BeanDoubleList.css =================================================================== --- trunk/jaxx-widgets/src/main/java/jaxx/runtime/swing/editor/bean/BeanDoubleList.css 2013-01-09 18:40:51 UTC (rev 2556) +++ trunk/jaxx-widgets/src/main/java/jaxx/runtime/swing/editor/bean/BeanDoubleList.css 2013-02-05 09:02:11 UTC (rev 2557) @@ -21,13 +21,9 @@ * <http://www.gnu.org/licenses/lgpl-3.0.html>. * #L% */ -#model { - universeModel:{universeList.getModel()}; - selectedModel:{selectedList.getModel()}; -} #universeList { - model:{new DefaultListModel()}; + model:{model.getUniverseModel()}; } #addButton { @@ -37,7 +33,7 @@ } #selectedList { - model:{new DefaultListModel()}; + model:{model.getSelectedModel()}; } #removeButton { Modified: trunk/jaxx-widgets/src/main/java/jaxx/runtime/swing/editor/bean/BeanDoubleList.jaxx =================================================================== --- trunk/jaxx-widgets/src/main/java/jaxx/runtime/swing/editor/bean/BeanDoubleList.jaxx 2013-01-09 18:40:51 UTC (rev 2556) +++ trunk/jaxx-widgets/src/main/java/jaxx/runtime/swing/editor/bean/BeanDoubleList.jaxx 2013-02-05 09:02:11 UTC (rev 2557) @@ -24,6 +24,7 @@ <Table genericType='O' implements='jaxx.runtime.bean.BeanTypeAware<O>'> <import> + jaxx.runtime.swing.model.JaxxDefaultListModel org.nuiton.util.decorator.JXPathDecorator javax.swing.DefaultListModel </import> Modified: trunk/jaxx-widgets/src/main/java/jaxx/runtime/swing/editor/bean/BeanDoubleListModel.java =================================================================== --- trunk/jaxx-widgets/src/main/java/jaxx/runtime/swing/editor/bean/BeanDoubleListModel.java 2013-01-09 18:40:51 UTC (rev 2556) +++ trunk/jaxx-widgets/src/main/java/jaxx/runtime/swing/editor/bean/BeanDoubleListModel.java 2013-02-05 09:02:11 UTC (rev 2557) @@ -25,11 +25,11 @@ */ import com.google.common.collect.Lists; +import jaxx.runtime.swing.model.JaxxDefaultListModel; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.jdesktop.beans.AbstractSerializableBean; -import javax.swing.DefaultListModel; import javax.swing.ListModel; import java.util.ArrayList; import java.util.List; @@ -57,13 +57,13 @@ protected List<O> universe = new ArrayList<O>(); /** Model containing the remaining available items */ - protected ListModel universeModel = new DefaultListModel(); + protected JaxxDefaultListModel<O> universeModel = new JaxxDefaultListModel<O>(); /** List of the selected items */ protected List<O> selected = new ArrayList<O>(); /** Model containing the selected items */ - protected ListModel selectedModel = new DefaultListModel(); + protected JaxxDefaultListModel<O> selectedModel = new JaxxDefaultListModel<O>(); protected boolean addEnabled; @@ -94,7 +94,7 @@ selected = Lists.newArrayList(); } this.selected.clear(); - ((DefaultListModel) selectedModel).clear(); + selectedModel.clear(); addToSelected(selected); } @@ -122,9 +122,10 @@ } protected void resetUniverse() { - ((DefaultListModel) universeModel).clear(); + universeModel.clear(); + universeModel.addAllElements(universe); for (O item : universe) { - ((DefaultListModel) universeModel).addElement(item); + universeModel.addElement(item); } } @@ -132,17 +133,17 @@ return selectedModel; } - public void setSelectedModel(ListModel selectedModel) { - this.selectedModel = selectedModel; - } +// public void setSelectedModel(ListModel selectedModel) { +// this.selectedModel = selectedModel; +// } public ListModel getUniverseModel() { return universeModel; } - public void setUniverseModel(ListModel universeModel) { - this.universeModel = universeModel; - } +// public void setUniverseModel(ListModel universeModel) { +// this.universeModel = universeModel; +// } /** * Adds an item to the selected items. @@ -151,8 +152,8 @@ */ public void addToSelected(O item) { selected.add(item); - ((DefaultListModel) selectedModel).addElement(item); - ((DefaultListModel) universeModel).removeElement(item); + selectedModel.addElement(item); + universeModel.removeElement(item); } /** @@ -163,8 +164,8 @@ public void addToSelected(List<O> items) { selected.addAll(items); for (O item : items) { - ((DefaultListModel) selectedModel).addElement(item); - ((DefaultListModel) universeModel).removeElement(item); + selectedModel.addElement(item); + universeModel.removeElement(item); } } @@ -175,7 +176,7 @@ */ public void removeFromSelected(O item) { selected.remove(item); - ((DefaultListModel) selectedModel).removeElement(item); + selectedModel.removeElement(item); addToUniverseList(item); } @@ -187,7 +188,7 @@ public void removeFromSelected(List<O> items) { selected.removeAll(items); for (O item : items) { - ((DefaultListModel) selectedModel).removeElement(item); + selectedModel.removeElement(item); addToUniverseList(item); } } @@ -219,27 +220,25 @@ * @param item the item to add to the universe list */ protected void addToUniverseList(O item) { - DefaultListModel universeDefaultListModel = (DefaultListModel) universeModel; - // the maximum index where we should insert the item is its index + // the maximum index where we should insert the item is its index // in the list of all the available items int index = universe.indexOf(item); // if the index is upper than the size of the list of the remaining available items, // get the size of this list - int insertionIndex = Math.min(index, universeDefaultListModel.getSize()); + int insertionIndex = Math.min(index, universeModel.getSize()); // we decrease the index to insert until we meet an item whose index // in the list of all the available index is lower than the one of the item // we want to insert while (insertionIndex > 0) { - O o = (O) universeDefaultListModel.get(--insertionIndex); + O o = universeModel.get(--insertionIndex); int oIndex = universe.indexOf(o); if (oIndex < index) { insertionIndex++; break; } } - ; - universeDefaultListModel.add(insertionIndex, item); + universeModel.add(insertionIndex, item); } }