/** {@inheritDoc} */ public SortOrder getSortOrder(int columnIndex) { for(int k = 0; k < this.sortKeys.size(); k++) { SortKey s = this.sortKeys.get(k); if(s.getColumn() == columnIndex) return s.getSortOrder(); } return SortOrder.UNSORTED; } }
/** {@inheritDoc} */ public void toggleSortOrder(int columnIndex, Comparator comparator) { List<SortKey> newSortKeys = new ArrayList<SortKey>(getSortKeys()); // see if we're already sorting with this column SortOrder columnSortOrder = SortOrder.ASCENDING; for(Iterator<? extends SortKey> s = newSortKeys.iterator(); s.hasNext(); ) { SortKey sortKey = s.next(); if(sortKey.getSortOrder() == SortOrder.UNSORTED) continue; if(sortKey.getColumn() == columnIndex) { columnSortOrder = (sortKey.getSortOrder() == SortOrder.ASCENDING) ? SortOrder.DESCENDING : SortOrder.ASCENDING; s.remove(); break; } } // prepare the new sort order if(!multipleColumnSort) newSortKeys.clear(); newSortKeys.add(new SortKey(columnSortOrder, columnIndex)); // kick off the sort setSortKeys(newSortKeys); }
if ((sortKey == null) || (!sortKey.getSortOrder().isSorted())) { throw new IllegalArgumentException("SortKey must not be null with sorted SortOrder"); if (ascending != sortKey.getSortOrder().isAscending()) { forceRefresh = true; ascending = sortKey.getSortOrder().isAscending(); if (((comparator != null) && !comparator.equals(sortKey.getComparator())) || ((comparator == null) && (sortKey.getComparator() != null))) { forceRefresh = true; comparator = sortKey.getComparator(); if (getColumnIndex() != sortKey.getColumn()) { setColumnIndex(sortKey.getColumn());
/** * Returns the SortOrder. * * @return the interactive sorter's SortOrder * or SortOrder.UNSORTED */ public SortOrder getSortOrder() { SortController sortController = getSortController(); if (sortController == null) return SortOrder.UNSORTED; SortKey sortKey = SortKey.getFirstSortKeyForColumn(sortController.getSortKeys(), 0); return sortKey != null ? sortKey.getSortOrder() : SortOrder.UNSORTED; }
public SortKey getSortKey() { return new SortKey(getSortOrder(), getColumnIndex(), getComparator()); } public void toggle() {
/** * * @return the currently interactively sorted TableColumn or null if there * is not sorter active or if the sorted column index does not * correspond to any column in the TableColumnModel. */ public TableColumn getSortedColumn() { // bloody hack: get primary SortKey and // check if there's a column with it available SortController controller = getSortController(); if (controller != null) { SortKey sortKey = SortKey.getFirstSortingKey(controller .getSortKeys()); if (sortKey != null) { int sorterColumn = sortKey.getColumn(); List<TableColumn> columns = getColumns(true); for (Iterator<TableColumn> iter = columns.iterator(); iter .hasNext();) { TableColumn column = iter.next(); if (column.getModelIndex() == sorterColumn) { return column; } } } } return null; }
/** * Returns the first SortKey in the list which is sorted. * If none is sorted, null is returned. * * @param keys a list of SortKeys to search * @return the first SortKey which is sorted or null, if no * is found. */ public static SortKey getFirstSortingKey(List<? extends SortKey> keys) { for (SortKey key : keys) { if (key.getSortOrder().isSorted()) { return key; } } return null; }
/** * Returns the first SortKey in the list for the given column, * or null if the column has no SortKey. * * @param keys a list of SortKeys to search * @param modelColumn the column index in model coordinates * @return the first SortKey for the given column or null if none is * found. */ public static SortKey getFirstSortKeyForColumn(List<? extends SortKey> keys, int modelColumn) { for (SortKey key : keys) { if (key.getColumn() == modelColumn) { return key; } } return null; }
public void setSortKeys(List<? extends SortKey> keys) { if ((keys == null) || keys.isEmpty()) { setSorter(null); return; } SortKey sortKey = SortKey.getFirstSortingKey(keys); // only crappy unsorted... if (sortKey == null) return; Sorter sorter = getSorter(); if (sorter == null) { sorter = createDefaultSorter(); } sorter.setSortKey(sortKey); // technically, we could re-use the sorter // and only reset column, comparator and direction // need to detangle from TableColumn before going there... // so for now we only change the order if we have a sorter // for the given column, create a new default sorter if not // if ((currentSorter == null) || // (currentSorter.getColumnIndex() != sortKey.getColumn())) { // currentSorter = createDefaultSorter(sortKey); // } // if (currentSorter.isAscending() != sortKey.getSortOrder().isAscending()) { // currentSorter.setAscending(sortKey.getSortOrder().isAscending()); // } setSorter(sorter); }
/** * Returns the SortOrder of the given column. * * @param columnIndex the column index in view coordinates. * @return the interactive sorter's SortOrder if matches the column or * SortOrder.UNSORTED */ public SortOrder getSortOrder(int columnIndex) { SortController sortController = getSortController(); if (sortController == null) return SortOrder.UNSORTED; SortKey sortKey = SortKey.getFirstSortKeyForColumn(sortController .getSortKeys(), convertColumnIndexToModel(columnIndex)); return sortKey != null ? sortKey.getSortOrder() : SortOrder.UNSORTED; }
public void toggleSortOrder(int column, Comparator comparator) { Sorter currentSorter = getSorter(); if ((currentSorter != null) && (currentSorter.getColumnIndex() == column)) { // JW: think about logic - need to update comparator? currentSorter.toggle(); } else { setSorter(createDefaultSorter(new SortKey(SortOrder.ASCENDING, column, comparator))); } }
TableRowSorter<TableModel> sorter = new TableRowSorter<TableModel>(getModel()) { Map<Integer, SortKey> keys = new HashMap<Integer, SortKey>(); public void toggleSortOrder(int column) { SortKey key = keys.get(column); SortOrder order = null; // Get last sort order. if (key != null) { if (key.getSortOrder() == SortOrder.DESCENDING){ order = SortOrder.ASCENDING; } else { order = SortOrder.DESCENDING; } } else { order = SortOrder.DESCENDING; } keys.put(new SortKey(column, order)); getTableModel().sort(keys); } }; setRowSorter(sorter);
/** {@inheritDoc} */ public SortOrder getSortOrder(int columnIndex) { for(int k = 0; k < this.sortKeys.size(); k++) { SortKey s = this.sortKeys.get(k); if(s.getColumn() == columnIndex) return s.getSortOrder(); } return SortOrder.UNSORTED; } }
/** {@inheritDoc} */ public void toggleSortOrder(int columnIndex, Comparator comparator) { List<SortKey> newSortKeys = new ArrayList<SortKey>(getSortKeys()); // see if we're already sorting with this column SortOrder columnSortOrder = SortOrder.ASCENDING; for(Iterator<? extends SortKey> s = newSortKeys.iterator(); s.hasNext(); ) { SortKey sortKey = s.next(); if(sortKey.getSortOrder() == SortOrder.UNSORTED) continue; if(sortKey.getColumn() == columnIndex) { columnSortOrder = (sortKey.getSortOrder() == SortOrder.ASCENDING) ? SortOrder.DESCENDING : SortOrder.ASCENDING; s.remove(); break; } } // prepare the new sort order if(!multipleColumnSort) newSortKeys.clear(); newSortKeys.add(new SortKey(columnSortOrder, columnIndex)); // kick off the sort setSortKeys(newSortKeys); }
/** * Returns the SortOrder of the given column. * * PENDING: JW - define the behaviour if the identifier is not found. This * can happen if either there's no column at all with the identifier or if * there's no column of type TableColumnExt. Currently returns * SortOrder.UNSORTED. * * @param identifier the column's identifier. * @return the interactive sorter's SortOrder if matches the column or * SortOrder.UNSORTED */ public SortOrder getSortOrder(Object identifier) { SortController sortController = getSortController(); if (sortController == null) return SortOrder.UNSORTED; TableColumnExt columnExt = getColumnExt(identifier); if (columnExt == null) return SortOrder.UNSORTED; int modelIndex = columnExt.getModelIndex(); SortKey sortKey = SortKey.getFirstSortKeyForColumn(sortController .getSortKeys(), modelIndex); return sortKey != null ? sortKey.getSortOrder() : SortOrder.UNSORTED; }
/** * Sorts the list using SortOrder. * * * Respects the JXList's sortable and comparator * properties: routes the comparator to the SortController * and does nothing if !isFilterEnabled(). * <p> * * @param sortOrder the sort order to use. If null or SortOrder.UNSORTED, * this method has the same effect as resetSortOrder(); * */ public void setSortOrder(SortOrder sortOrder) { if ((sortOrder == null) || !sortOrder.isSorted()) { resetSortOrder(); return; } SortController sortController = getSortController(); if (sortController != null) { SortKey sortKey = new SortKey(sortOrder, 0, getComparator()); sortController.setSortKeys(Collections.singletonList(sortKey)); } }
protected Icon getIcon(JTable table, int column) { SortKey sortKey = getSortKey(table, column); if (sortKey != null && table.convertColumnIndexToView( sortKey.getColumn()) == column) { switch (sortKey.getSortOrder()) { case ASCENDING: return UIManager.getIcon("Table.ascendingSortIcon"); case DESCENDING: return UIManager.getIcon("Table.descendingSortIcon"); } } return null; }
if (sortController != null) { TableColumnExt columnExt = getColumnExt(columnIndex); SortKey sortKey = new SortKey(sortOrder, convertColumnIndexToModel(columnIndex), columnExt != null ? columnExt.getComparator() : null);
while(it.hasNext()){ SortKey sortKey = it.next(); if(sortKey.getSortOrder().compareTo(SortOrder.UNSORTED)!=0 ){ index[i] = sortKey.getColumn(); i++;
if (columnExt == null) return; SortKey sortKey = new SortKey(sortOrder, columnExt.getModelIndex(), columnExt.getComparator()); sortController.setSortKeys(Collections.singletonList(sortKey));