Java SortOrder.DESCENDING属性代码示例

/**
 * 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);
	}
}
 

/** @return column sort icon or null */
private final Icon getColumnSortIcon(final JTable table, final int viewColumnIndex)
{
	if (table instanceof CTable)
	{
		final CTable cTable = (CTable)table;
		final int modelColumnIndex = table.convertColumnIndexToModel(viewColumnIndex);
		final SortOrder sortOrder = cTable.getSortOrder(modelColumnIndex);
		if (sortOrder == SortOrder.ASCENDING)
		{
			return Images.getImageIcon2("uparrow");
		}
		else if (sortOrder == SortOrder.DESCENDING)
		{
			return Images.getImageIcon2("downarrow");
		}
		else
		{
			return null;
		}
	}
	else
	{
		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());
}
 

/**
 * @inherited <p>
 */
@Override
public Object getHeaderValue() {
    Object header = super.getHeaderValue();
    Object sortOrder = getClientProperty(SORT_ORDER_KEY);
    if (SortOrder.ASCENDING == sortOrder) {
        header = header + ASCENDING_CHAR;
    } else if (SortOrder.DESCENDING == sortOrder){
        header = header + DESCENDING_CHAR;
    }
    return header;
}
 

/**
 * Returns the current sort keys of the given table encoded in a String.
 * 
 * <p>This is intended to be used together with
 * {@link setSortingForTable(JTable, String)}.</p>
 *
 * @param table
 * @return 
 */
public static String getSortingFromTable(JTable table) {
    List<? extends RowSorter.SortKey> keys = table.getRowSorter().getSortKeys();
    String result = "";
    for (RowSorter.SortKey key : keys) {
        int order = 0;
        if (key.getSortOrder() == SortOrder.ASCENDING) {
            order = 1;
        } else if (key.getSortOrder() == SortOrder.DESCENDING) {
            order = 2;
        }
        result += String.format("%s:%s;", key.getColumn(), order);
    }
    return result;
}
 

/**
 * @inherited
 * <p>
 */
@Override
public void toggleSortOrder(int column) {
    List<? extends RowSorter.SortKey> sortKeys = getSortKeys();
    if (sortKeys.size() > 0) {
        if (sortKeys.get(0).getSortOrder() == SortOrder.DESCENDING) {
            setSortKeys(null);
            return;
        }
    }
    super.toggleSortOrder(column);
}
 

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

private SortOrder getSortOrder(String sortOrder) {
    if (SortOrder.ASCENDING.toString().equals(sortOrder)) return SortOrder.ASCENDING;
    else if (SortOrder.DESCENDING.toString().equals(sortOrder)) return SortOrder.DESCENDING;
    else return SortOrder.UNSORTED;
}
 

private SortKey toggle(SortKey key) {
    if (key.getSortOrder() == SortOrder.ASCENDING) {
        return new SortKey(key.getColumn(), SortOrder.DESCENDING);
    }
    return new SortKey(key.getColumn(), SortOrder.ASCENDING);
}