< prev index next >
src/java.desktop/share/classes/javax/swing/RowSorter.java
Print this page
@@ -27,78 +27,78 @@
import javax.swing.SortOrder;
import javax.swing.event.*;
import java.util.*;
/**
- * <code>RowSorter</code> provides the basis for sorting and filtering.
- * Beyond creating and installing a <code>RowSorter</code>, you very rarely
+ * {@code RowSorter} provides the basis for sorting and filtering.
+ * Beyond creating and installing a {@code RowSorter}, you very rarely
* need to interact with one directly. Refer to
* {@link javax.swing.table.TableRowSorter TableRowSorter} for a concrete
- * implementation of <code>RowSorter</code> for <code>JTable</code>.
+ * implementation of {@code RowSorter} for {@code JTable}.
* <p>
- * <code>RowSorter</code>'s primary role is to provide a mapping between
+ * {@code RowSorter}'s primary role is to provide a mapping between
* two coordinate systems: that of the view (for example a
- * <code>JTable</code>) and that of the underlying data source, typically a
+ * {@code JTable}) and that of the underlying data source, typically a
* model.
* <p>
- * The view invokes the following methods on the <code>RowSorter</code>:
+ * The view invokes the following methods on the {@code RowSorter}:
* <ul>
- * <li><code>toggleSortOrder</code> — The view invokes this when the
+ * <li>{@code toggleSortOrder} — The view invokes this when the
* appropriate user gesture has occurred to trigger a sort. For example,
* the user clicked a column header in a table.
* <li>One of the model change methods — The view invokes a model
* change method when the underlying model
* has changed. There may be order dependencies in how the events are
- * delivered, so a <code>RowSorter</code> should not update its mapping
+ * delivered, so a {@code RowSorter} should not update its mapping
* until one of these methods is invoked.
* </ul>
* Because the view makes extensive use of the
- * <code>convertRowIndexToModel</code>,
- * <code>convertRowIndexToView</code> and <code>getViewRowCount</code> methods,
+ * {@code convertRowIndexToModel},
+ * {@code convertRowIndexToView} and {@code getViewRowCount} methods,
* these methods need to be fast.
* <p>
- * <code>RowSorter</code> provides notification of changes by way of
- * <code>RowSorterListener</code>. Two types of notification are sent:
+ * {@code RowSorter} provides notification of changes by way of
+ * {@code RowSorterListener}. Two types of notification are sent:
* <ul>
- * <li><code>RowSorterEvent.Type.SORT_ORDER_CHANGED</code> — notifies
+ * <li>{@code RowSorterEvent.Type.SORT_ORDER_CHANGED} — notifies
* listeners that the sort order has changed. This is typically followed
* by a notification that the sort has changed.
- * <li><code>RowSorterEvent.Type.SORTED</code> — notifies listeners that
- * the mapping maintained by the <code>RowSorter</code> has changed in
+ * <li>{@code RowSorterEvent.Type.SORTED} — notifies listeners that
+ * the mapping maintained by the {@code RowSorter} has changed in
* some way.
* </ul>
- * <code>RowSorter</code> implementations typically don't have a one-to-one
+ * {@code RowSorter} implementations typically don't have a one-to-one
* mapping with the underlying model, but they can.
* For example, if a database does the sorting,
- * <code>toggleSortOrder</code> might call through to the database
+ * {@code toggleSortOrder} might call through to the database
* (on a background thread), and override the mapping methods to return the
* argument that is passed in.
* <p>
- * Concrete implementations of <code>RowSorter</code>
- * need to reference a model such as <code>TableModel</code> or
- * <code>ListModel</code>. The view classes, such as
- * <code>JTable</code> and <code>JList</code>, will also have a
+ * Concrete implementations of {@code RowSorter}
+ * need to reference a model such as {@code TableModel} or
+ * {@code ListModel}. The view classes, such as
+ * {@code JTable} and {@code JList}, will also have a
* reference to the model. To avoid ordering dependencies,
- * <code>RowSorter</code> implementations should not install a
+ * {@code RowSorter} implementations should not install a
* listener on the model. Instead the view class will call into the
- * <code>RowSorter</code> when the model changes. For
- * example, if a row is updated in a <code>TableModel</code>
- * <code>JTable</code> invokes <code>rowsUpdated</code>.
+ * {@code RowSorter} when the model changes. For
+ * example, if a row is updated in a {@code TableModel}
+ * {@code JTable} invokes {@code rowsUpdated}.
* When the model changes, the view may call into any of the following methods:
- * <code>modelStructureChanged</code>, <code>allRowsChanged</code>,
- * <code>rowsInserted</code>, <code>rowsDeleted</code> and
- * <code>rowsUpdated</code>.
+ * {@code modelStructureChanged}, {@code allRowsChanged},
+ * {@code rowsInserted}, {@code rowsDeleted} and
+ * {@code rowsUpdated}.
*
* @param <M> the type of the underlying model
* @see javax.swing.table.TableRowSorter
* @since 1.6
*/
public abstract class RowSorter<M> {
private EventListenerList listenerList = new EventListenerList();
/**
- * Creates a <code>RowSorter</code>.
+ * Creates a {@code RowSorter}.
*/
public RowSorter() {
}
/**
@@ -117,51 +117,51 @@
* the primary sorted column, with an ascending sort order. If
* the specified column is not sortable, this method has no
* effect.
* <p>
* If this results in changing the sort order and sorting, the
- * appropriate <code>RowSorterListener</code> notification will be
+ * appropriate {@code RowSorterListener} notification will be
* sent.
*
* @param column the column to toggle the sort ordering of, in
* terms of the underlying model
* @throws IndexOutOfBoundsException if column is outside the range of
* the underlying model
*/
public abstract void toggleSortOrder(int column);
/**
- * Returns the location of <code>index</code> in terms of the
- * underlying model. That is, for the row <code>index</code> in
+ * Returns the location of {@code index} in terms of the
+ * underlying model. That is, for the row {@code index} in
* the coordinates of the view this returns the row index in terms
* of the underlying model.
*
* @param index the row index in terms of the underlying view
* @return row index in terms of the view
- * @throws IndexOutOfBoundsException if <code>index</code> is outside the
+ * @throws IndexOutOfBoundsException if {@code index} is outside the
* range of the view
*/
public abstract int convertRowIndexToModel(int index);
/**
- * Returns the location of <code>index</code> in terms of the
- * view. That is, for the row <code>index</code> in the
+ * Returns the location of {@code index} in terms of the
+ * view. That is, for the row {@code index} in the
* coordinates of the underlying model this returns the row index
* in terms of the view.
*
* @param index the row index in terms of the underlying model
* @return row index in terms of the view, or -1 if index has been
* filtered out of the view
- * @throws IndexOutOfBoundsException if <code>index</code> is outside
+ * @throws IndexOutOfBoundsException if {@code index} is outside
* the range of the model
*/
public abstract int convertRowIndexToView(int index);
/**
* Sets the current sort keys.
*
- * @param keys the new <code>SortKeys</code>; <code>null</code>
+ * @param keys the new {@code SortKeys}; {@code null}
* is a shorthand for specifying an empty list,
* indicating that the view should be unsorted
*/
public abstract void setSortKeys(List<? extends SortKey> keys);
@@ -195,11 +195,11 @@
public abstract int getModelRowCount();
/**
* Invoked when the underlying model structure has completely
* changed. For example, if the number of columns in a
- * <code>TableModel</code> changed, this method would be invoked.
+ * {@code TableModel} changed, this method would be invoked.
* <p>
* You normally do not call this method. This method is public
* to allow view classes to call it.
*/
public abstract void modelStructureChanged();
@@ -232,11 +232,11 @@
* to allow view classes to call it.
*
* @param firstRow the first row
* @param endRow the last row
* @throws IndexOutOfBoundsException if either argument is invalid, or
- * <code>firstRow</code> > <code>endRow</code>
+ * {@code firstRow > endRow}
*/
public abstract void rowsInserted(int firstRow, int endRow);
/**
* Invoked when rows have been deleted from the underlying model
@@ -252,11 +252,11 @@
*
* @param firstRow the first row
* @param endRow the last row
* @throws IndexOutOfBoundsException if either argument is outside
* the range of the model before the change, or
- * <code>firstRow</code> > <code>endRow</code>
+ * {@code firstRow > endRow}
*/
public abstract void rowsDeleted(int firstRow, int endRow);
/**
* Invoked when rows have been changed in the underlying model
@@ -267,11 +267,11 @@
*
* @param firstRow the first row, in terms of the underlying model
* @param endRow the last row, in terms of the underlying model
* @throws IndexOutOfBoundsException if either argument is outside
* the range of the underlying model, or
- * <code>firstRow</code> > <code>endRow</code>
+ * {@code firstRow > endRow}
*/
public abstract void rowsUpdated(int firstRow, int endRow);
/**
* Invoked when the column in the rows have been updated in
@@ -284,34 +284,34 @@
* @param endRow the last row, in terms of the underlying model
* @param column the column that has changed, in terms of the underlying
* model
* @throws IndexOutOfBoundsException if either argument is outside
* the range of the underlying model after the change,
- * <code>firstRow</code> > <code>endRow</code>, or
- * <code>column</code> is outside the range of the underlying
+ * {@code firstRow > endRow}, or
+ * {@code column} is outside the range of the underlying
* model
*/
public abstract void rowsUpdated(int firstRow, int endRow, int column);
/**
- * Adds a <code>RowSorterListener</code> to receive notification
- * about this <code>RowSorter</code>. If the same
+ * Adds a {@code RowSorterListener} to receive notification
+ * about this {@code RowSorter}. If the same
* listener is added more than once it will receive multiple
- * notifications. If <code>l</code> is <code>null</code> nothing
+ * notifications. If {@code l} is {@code null} nothing
* is done.
*
- * @param l the <code>RowSorterListener</code>
+ * @param l the {@code RowSorterListener}
*/
public void addRowSorterListener(RowSorterListener l) {
listenerList.add(RowSorterListener.class, l);
}
/**
- * Removes a <code>RowSorterListener</code>. If
- * <code>l</code> is <code>null</code> nothing is done.
+ * Removes a {@code RowSorterListener}. If
+ * {@code l} is {@code null} nothing is done.
*
- * @param l the <code>RowSorterListener</code>
+ * @param l the {@code RowSorterListener}
*/
public void removeRowSorterListener(RowSorterListener l) {
listenerList.remove(RowSorterListener.class, l);
}
@@ -324,11 +324,11 @@
/**
* Notifies listener that the mapping has changed.
*
* @param lastRowIndexToModel the mapping from model indices to
- * view indices prior to the sort, may be <code>null</code>
+ * view indices prior to the sort, may be {@code null}
*/
protected void fireRowSorterChanged(int[] lastRowIndexToModel) {
fireRowSorterChanged(new RowSorterEvent(this,
RowSorterEvent.Type.SORTED, lastRowIndexToModel));
}
@@ -353,17 +353,17 @@
public static class SortKey {
private int column;
private SortOrder sortOrder;
/**
- * Creates a <code>SortKey</code> for the specified column with
+ * Creates a {@code SortKey} for the specified column with
* the specified sort order.
*
* @param column index of the column, in terms of the model
* @param sortOrder the sorter order
- * @throws IllegalArgumentException if <code>sortOrder</code> is
- * <code>null</code>
+ * @throws IllegalArgumentException if {@code sortOrder} is
+ * {@code null}
*/
public SortKey(int column, SortOrder sortOrder) {
if (sortOrder == null) {
throw new IllegalArgumentException(
"sort order must be non-null");
@@ -389,11 +389,11 @@
public final SortOrder getSortOrder() {
return sortOrder;
}
/**
- * Returns the hash code for this <code>SortKey</code>.
+ * Returns the hash code for this {@code SortKey}.
*
* @return hash code
*/
public int hashCode() {
int result = 17;
@@ -402,16 +402,16 @@
return result;
}
/**
* Returns true if this object equals the specified object.
- * If the specified object is a <code>SortKey</code> and
+ * If the specified object is a {@code SortKey} and
* references the same column and sort order, the two objects
* are equal.
*
* @param o the object to compare to
- * @return true if <code>o</code> is equal to this <code>SortKey</code>
+ * @return true if {@code o} is equal to this {@code SortKey}
*/
public boolean equals(Object o) {
if (o == this) {
return true;
}
< prev index next >