Java SortOrder.UNSORTED属性代码示例

/**
 * RowSorter properties not touched if getControlsSorterProperties false.
 */
private void assertControlsSorterPropertiesFalse(boolean setSorter) {
    table.setAutoCreateRowSorter(false);
    SortOrder[] cycle = new SortOrder[] {SortOrder.DESCENDING, SortOrder.UNSORTED};
    table.setSortOrderCycle(cycle);
    table.setSortsOnUpdates(!table.getSortsOnUpdates());
    table.setSortable(!table.isSortable());
    if (setSorter) {
        table.setRowSorter(new TableSortController<TableModel>(table.getModel()));
        assertFalse("StringValueProvider propagated to controller", 
                table.getStringValueRegistry().equals(getSortController(table).getStringValueProvider()));
    }
    assertEquals("sortsOnUpdates propagated to controller", 
            !table.getSortsOnUpdates(), getSortController(table).getSortsOnUpdates());
    assertEquals("sortable propagated to controller",
            !table.isSortable(), getSortController(table).isSortable());
    assertFalse("sortOrderCycle propagated to controller",
            Arrays.equals(table.getSortOrderCycle(), 
                    getSortController(table).getSortOrderCycle()));
}
 

/**
 * RowSorter properties updated on getControlsSorterProperties true.
 */
private void assertControlsSorterPropertiesTrue(boolean setSorter) {
    SortOrder[] cycle = new SortOrder[] {SortOrder.DESCENDING, SortOrder.UNSORTED};
    table.setSortOrderCycle(cycle);
    table.setSortsOnUpdates(!table.getSortsOnUpdates());
    table.setSortable(!table.isSortable());
    if (setSorter) {
        table.setRowSorter(new TableSortController<TableModel>(table.getModel()));
    }
    assertEquals("sortsOnUpdates propagated to controller", 
            table.getSortsOnUpdates(), getSortController(table).getSortsOnUpdates());
    assertEquals("sortable propagated to controller",
            table.isSortable(), getSortController(table).isSortable());
    assertTrue("sortOrderCycle propagated to controller",
            Arrays.equals(table.getSortOrderCycle(), 
                    getSortController(table).getSortOrderCycle()));
    assertEquals("StringValueProvider propagated to controller", 
            table.getStringValueRegistry(), getSortController(table).getStringValueProvider());
}
 

protected final void setColumnSortOrder(final int modelColumnIndex, final SortOrder sortOrder)
{
	sortIndexes2Direction.remove(modelColumnIndex);
	if (sortOrder == SortOrder.ASCENDING)
	{
		sortIndexes2Direction.put(modelColumnIndex, true);
	}
	else if (sortOrder == SortOrder.DESCENDING)
	{
		sortIndexes2Direction.put(modelColumnIndex, false);
	}
	else if (sortOrder == SortOrder.UNSORTED)
	{
		// just removed it's fine
	}
	else
	{
		// shall not happen
	}
}
 

private static final Boolean getSortAscendingFlagOfSortOrder(final SortOrder sortOrder)
{
	if (sortOrder == null)
	{
		return null;
	}
	else if (sortOrder == SortOrder.ASCENDING)
	{
		return true;
	}
	else if (sortOrder == SortOrder.DESCENDING)
	{
		return false;
	}
	else if (sortOrder == SortOrder.UNSORTED)
	{
		return null;
	}
	else
	{
		throw new IllegalArgumentException("Unknown sortOrder: " + sortOrder);
	}
}
 

@Override
public Icon getIcon() {
	int modelCol = header.getTable().convertColumnIndexToModel(curCol);
	TableModel model = header.getTable().getModel();
	if (model instanceof ExtendedJTableSorterModel) {
		ExtendedJTableSorterModel sortModel = (ExtendedJTableSorterModel) model;
		switch (sortModel.getSortingStatus(modelCol)) {
			case ExtendedJTableSorterModel.ASCENDING:
				return UIManager.getIcon("Table.ascendingSortIcon");
			case ExtendedJTableSorterModel.DESCENDING:
				return UIManager.getIcon("Table.descendingSortIcon");
			case ExtendedJTableSorterModel.NOT_SORTED:
			default:
				return null;
		}
	} else {
		SortKey sortKey = getSortKey(header.getTable().getRowSorter(), modelCol);
		SortOrder sortOrder = sortKey != null ? sortKey.getSortOrder() : SortOrder.UNSORTED;
		switch (sortOrder) {
			case ASCENDING:
				return UIManager.getIcon("Table.ascendingSortIcon");
			case DESCENDING:
				return UIManager.getIcon("Table.descendingSortIcon");
			case UNSORTED:
			default:
				return null;
		}
	}
}
 

private SortKey toggle(final SortKey key) {
  switch (key.getSortOrder()) {
    case ASCENDING: {
      return new SortKey(key.getColumn(), SortOrder.DESCENDING);
    }
    case DESCENDING: {
      return new SortKey(key.getColumn(), SortOrder.UNSORTED);
    }
    case UNSORTED: {
      return new SortKey(key.getColumn(), SortOrder.ASCENDING);
    }
  }
  throw new UnreachableCodeReachedException();
}
 

private void
rowSorterChanged() {
	List<? extends SortKey> list = getRowSorter().getSortKeys();
	if(list.isEmpty()) return;
	SortKey k = list.get(0);
	int i = k.getColumn() + 1;
	if(k.getSortOrder() == SortOrder.UNSORTED) return;
	if(k.getSortOrder() == SortOrder.DESCENDING) i *= -1;
	preferences().setIntProperty(tablePrefix + "sortOrder", i);
}
 

/**
 * Setting table's sortable property updates controller.
 */
@Test
public void testSortOrderCycle() {
    JXList list = new JXList(true);
    SortOrder[] cycle = new SortOrder[] {SortOrder.DESCENDING, SortOrder.UNSORTED};
    PropertyChangeReport report = new PropertyChangeReport(list);
    list.setSortOrderCycle(cycle);
    TestUtils.assertPropertyChangeEvent(report, "sortOrderCycle", 
                DefaultSortController.getDefaultSortOrderCycle(), list.getSortOrderCycle());
}
 

/**
 * Setting table's sortable property updates controller.
 */
@Test
public void testSortOrderCycleNotification() {
    SortOrder[] cycle = new SortOrder[] {SortOrder.DESCENDING, SortOrder.UNSORTED};
    PropertyChangeReport report = new PropertyChangeReport(table);
    table.setSortOrderCycle(cycle);
    TestUtils.assertPropertyChangeEvent(report, "sortOrderCycle", 
                DefaultSortController.getDefaultSortOrderCycle(), table.getSortOrderCycle());
}
 

public void setComparator(Comparator<?> comparator) {
    // <snip> JXList sorting
    //  configure the comparator to use in sorting
    list.setComparator(comparator);
    if (list.getSortOrder() != SortOrder.UNSORTED) {
        // PENDING missing refresh api?
        ((DefaultSortController<?>) list.getRowSorter()).sort();
    }
    // </snip>
}
 

public final SortOrder getSortOrder(final int modelColumnIndex)
{
	final List<? extends SortKey> sortKeys = getSortKeys();
	for (final SortKey sortKey : sortKeys)
	{
		if (sortKey.getColumn() == modelColumnIndex)
		{
			return sortKey.getSortOrder();
		}
	}
	return SortOrder.UNSORTED;
}
 

private static final SortOrder getSortOrderOfBooleanAscendingFlag(final Boolean isSortAscending)
{
	if (isSortAscending == null)
	{
		return SortOrder.UNSORTED;
	}
	else if (isSortAscending)
	{
		return SortOrder.ASCENDING;
	}
	else
	{
		return SortOrder.DESCENDING;
	}
}
 

SortOrder getSortOrder() {
    RowSorter.SortKey key = getSortKey();
    return key == null ? SortOrder.UNSORTED : key.getSortOrder();
}
 

private boolean isUnsorted() {
    List<? extends SortKey> keys = getSortKeys();
    int keySize = keys.size();
    return (keySize == 0 || keys.get(0).getSortOrder() ==
            SortOrder.UNSORTED);
}
 

@SuppressWarnings("unchecked")
private int compare(int model1, int model2) {
    int column;
    SortOrder sortOrder;
    Object v1, v2;
    int result;

    for (int counter = 0; counter < cachedSortKeys.length; counter++) {
        column = cachedSortKeys[counter].getColumn();
        sortOrder = cachedSortKeys[counter].getSortOrder();
        if (sortOrder == SortOrder.UNSORTED) {
            result = model1 - model2;
        } else {
            // v1 != null && v2 != null
            if (useToString[column]) {
                v1 = getModelWrapper().getStringValueAt(model1, column);
                v2 = getModelWrapper().getStringValueAt(model2, column);
            } else {
                v1 = getModelWrapper().getValueAt(model1, column);
                v2 = getModelWrapper().getValueAt(model2, column);
            }
            // Treat nulls as < then non-null
            if (v1 == null) {
                if (v2 == null) {
                    result = 0;
                } else {
                    result = -1;
                }
            } else if (v2 == null) {
                result = 1;
            } else {
                result = sortComparators[counter].compare(v1, v2);
            }
            if (sortOrder == SortOrder.DESCENDING) {
                result *= -1;
            }
        }
        if (result != 0) {
            return result;
        }
    }
    // If we get here, they're equal. Fallback to model order.
    return model1 - model2;
}