Hi,

I was kind of surprised that JFace table sorting doesn't work both ways. I'm sure that there are reasons for this I don't see (I'm not a very experienced GUI programmer), but I thought it must be easy to provide a minimal "framework" for this, and here it is. Feel free to add any comments on how to improve this!

The first class represents an InvertableSorter; it extends the ViewerSorter class:

abstract class InvertableSorter extends ViewerSorter {
	public abstract int compare(Viewer viewer, Object e1, Object e2);
 
	abstract InvertableSorter getInverseSorter();
 
	public abstract int getSortDirection();
}

The second class is the class you have to extend when implementing your sorter. All you have to do is to overwrite the compare(Viewer viewer, Object e1, Object e2) method. I expect that in many cases it's best to extend this class with your own abstract class (see example below).

public abstract class AbstractInvertableTableSorter extends InvertableSorter {
	private final InvertableSorter inverse = new InvertableSorter() {
 
		public int compare(Viewer viewer, Object e1, Object e2) {
			return (-1)*AbstractInvertableTableSorter.this
							.compare(viewer, e1, e2);
		}
 
		InvertableSorter getInverseSorter() {
			return AbstractInvertableTableSorter.this;
		}
 
		public int getSortDirection() {
			return SWT.DOWN;
		}
	};
 
	InvertableSorter getInverseSorter() {
		return inverse;
	}
 
	public int getSortDirection() {
		return SWT.UP;
	}
}

The last class, TableSortSelectionListener, does the actual work. It extends SelectionListener and takes care of event handling. It knows to which column of the table it belongs. Note that in the constructor you can select in which order the column is to be sorted initially, and if the last ordering is to be restored after another column had been selected.

public class TableSortSelectionListener implements SelectionListener {
	private final TableViewer viewer;
	private final TableColumn column;
	private final InvertableSorter sorter;
	private final boolean keepDirection;
	private InvertableSorter currentSorter;
 
	/**
	 * The constructor of this listener.
	 * 
	 * @param viewer
	 *            the tableviewer this listener belongs to
	 * @param column
	 *            the column this listener is responsible for
	 * @param sorter
	 *            the sorter this listener uses
	 * @param defaultDirection
	 *            the default sorting direction of this Listener. Possible
	 *            values are {@link SWT.UP} and {@link SWT.DOWN}
	 * @param keepDirection
	 *            if true, the listener will remember the last sorting direction
	 *            of the associated column and restore it when the column is
	 *            reselected. If false, the listener will use the default soting
	 *            direction
	 */
	public TableSortSelectionListener(TableViewer viewer, TableColumn column,
			AbstractInvertableTableSorter sorter, int defaultDirection,
			boolean keepDirection) {
		this.viewer = viewer;
		this.column = column;
		this.keepDirection = keepDirection;
		this.sorter = (defaultDirection == SWT.UP) ?
			sorter : sorter.getInverseSorter();
		this.currentSorter = this.sorter;
 
		this.column.addSelectionListener(this);
	}
 
	/**
	 * Chooses the colum of this listener for sorting of the table. Mainly used
	 * when first initialising the table.
	 */
	public void chooseColumnForSorting() {
		viewer.getTable().setSortColumn(column);
		viewer.getTable().setSortDirection(currentSorter.getSortDirection());
		viewer.setSorter(currentSorter);
	}
 
	public void widgetSelected(SelectionEvent e) {
		InvertableSorter newSorter;
		if (viewer.getTable().getSortColumn() == column) {
			newSorter = ((InvertableSorter) viewer.getSorter())
					.getInverseSorter();
		} else {
			if (keepDirection) {
				newSorter = currentSorter;
			} else {
				newSorter = sorter;
			}
		}
 
		currentSorter = newSorter;
		chooseColumnForSorting();
	}
 
	public void widgetDefaultSelected(SelectionEvent e) {
		widgetSelected(e);
	}
}

Ok, and here is the example I promised at the beginning . There's not too much to say about it, I guess...

public class TableDemo {
 
	private TableDemo() {
		// create shell
		Display display = new Display();
		Shell shell = new Shell(display, SWT.SHELL_TRIM);
		shell.setLayout(new FillLayout());
		shell.setText("TableDemo");
 
		// set up table layout
		TableViewer viewer = new TableViewer(shell);
		TableLayout layout = new TableLayout();
		layout.addColumnData(new ColumnWeightData(50, 100, true));
		layout.addColumnData(new ColumnWeightData(50, 100, true));
		viewer.getTable().setLayout(layout);
		viewer.getTable().setLinesVisible(true);
		viewer.getTable().setHeaderVisible(true);
 
		// create columns. The 1st coumn will initially be the sorting column.
		// It will be sorted SWT.DOWN, and it will remember its last sorting order.
		// The 2nd column will initially be sorted SWT.UP, and it will reset to
		// that initial sorting order when being reselected.
		TableDemo.createTableColumn(viewer, "Column 1", "Column 1 tooltip",
				new TextSorter(), SWT.DOWN, true).chooseColumnForSorting();
		TableDemo.createTableColumn(viewer, "Column 2", "Column 2 tooltip",
				new NumberSorter(), SWT.UP, false);
 
		// set providers
		viewer.setContentProvider(new TableDemoContentProvider());
		viewer.setLabelProvider(new TableDemoLableProvider());
 
		// create and set data of demo
		Set<Data> set = new HashSet<Data>();
		set.add(new Data("a", 1));
		set.add(new Data("b", 2));
		set.add(new Data("c", 3));
		viewer.setInput(set);
 
		// pack everything
		viewer.getTable().pack();
		shell.pack();
 
		// open shell
		shell.open();
		while (!shell.isDisposed()) {
			if (!display.readAndDispatch())
				display.sleep();
		}
		display.dispose();
	}
 
	// convenience method
	public static TableSortSelectionListener createTableColumn(
			TableViewer viewer, String text, String tooltip,
			AbstractInvertableTableSorter sorter, int initialDirection,
			boolean keepDirection) {
		TableColumn column = new TableColumn(viewer.getTable(), SWT.LEFT);
		column.setText(text);
		column.setToolTipText(tooltip);
		return new TableSortSelectionListener(viewer, column, sorter,
				initialDirection, keepDirection);
	}
 
	public static void main(String[] args) {
		new TableDemo();
	}
 
	private class Data {
		String text;
		int number;
 
		private Data(String text, int number) {
			this.text = text;
			this.number = number;
		}
	}
 
	private class TableDemoContentProvider implements
			IStructuredContentProvider {
		public Object[] getElements(Object inputElement) {
			return ((Set) inputElement).toArray();
		}
 
		public void dispose() {
		}
 
		public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
		}
	}
 
	private class TableDemoLableProvider implements ITableLabelProvider {
		public Image getColumnImage(Object element, int columnIndex) {
			return null;
		}
 
		public String getColumnText(Object element, int columnIndex) {
			Data data = (Data) element;
			String columnText;
			switch (columnIndex) {
			case 0:
				columnText = data.text;
				break;
			case 1:
				columnText = StringConverter.asString(data.number);
				break;
			default:
				columnText = "not set";
			}
			return columnText;
		}
 
		public void addListener(ILabelProviderListener listener) {
		}
 
		public void dispose() {
		}
 
		public boolean isLabelProperty(Object element, String property) {
			return false;
		}
 
		public void removeListener(ILabelProviderListener listener) {
		}
	}
 
	// convenience class which avoids casting in subclasses
	private abstract class AbstractDemoSorter extends
			AbstractInvertableTableSorter {
 
		public int compare(Viewer viewer, Object e1, Object e2) {
			return compare((Data) e1, (Data) e2);
		}
 
		public abstract int compare(Data d1, Data d2);
	}
 
	private class TextSorter extends AbstractDemoSorter {
 
		public int compare(Data d1, Data d2) {
			return Collator.getInstance().compare(d1.text, d2.text);
		}
	}
 
	private class NumberSorter extends AbstractDemoSorter {
 
		public int compare(Data d1, Data d2) {
			return Util.compare(d1.number, d2.number);
		}
	}
}

As I said in the beginning: Feel free to add any comments on how to improve this! I'm really looking forward to learn...

Bye,
Christian

public void chooseColumnForSorting() {

   viewer.getTable().setSortColumn(column);

viewer.getTable().setSortDirection(currentSorter.getSortDirection());

   viewer.getControl().setRedraw(false);

   viewer.setSorter(currentSorter);

   viewer.getControl().setRedraw(true);

}