import java.util.Arrays;
import java.util.Random;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Table;
import org.eclipse.swt.widgets.TableColumn;
import org.eclipse.swt.widgets.TableItem;
/*
* Created on 02.06.2004
*/
/**
* @author Administrator
*
*/
public class SortTableTest {
public static void main(String[] args) {
new SortTableTest().doIt();
}
private void doIt() {
Display display = new Display();
Shell shell = new Shell(display);
Random rnd = new Random();
//Anzahl der Zeilen
int rowCount = 100;
final Table table =
new Table(shell, SWT.MULTI | SWT.BORDER | SWT.FULL_SELECTION);
table.setSize(320, 240);
table.setLinesVisible(true);
table.setHeaderVisible(true);
//Tabellenspaltenbeschriftungen festlegen
String[] clmHeader = new String[] { "A", "B", "C", "D" };
for (int i = 0; i < clmHeader.length; i++) {
TableColumn column = new TableColumn(table, SWT.NONE);
column.setText(clmHeader[i]);
column.setWidth(50);
}
//Comperatoren bauen
final BaseComapator[][] comparables =
new BaseComapator[clmHeader.length][rowCount];
String[] textBuffer = null;
//Tabelle mit zufälligen Buchstaben füllen
//Der Comparator zum Vergleichen der Zeilen...
for (int i = 0; i < rowCount; i++) {
TableItem tableItem = new TableItem(table, SWT.NONE);
textBuffer = new String[] { "" + rnd.nextInt(rowCount), //Erste Spalte ist eine Ziffer
"" + (char) (65 + rnd.nextInt(26)),
"" + (char) (65 + rnd.nextInt(26)),
"" + (char) (65 + rnd.nextInt(26)),
};
tableItem.setText(textBuffer);
//NumberComparator auf erste Spalte setzen ...
comparables[0][i] = new NumberComparator(textBuffer, i, 0);
//StringComparator auf die übrigen Spalten ...
for (int n = 1; n < clmHeader.length; n++)
comparables[n][i] = new StringComparator(textBuffer, i, n);
}
TableColumn[] columns = table.getColumns();
//Auf jede Tabellenspalte einen Listener legen
for (int i = 0; i < columns.length; i++) {
final int _i = i;
columns[i].addListener(SWT.Selection, new Listener() {
private int colPos = -1;
private boolean sortFlag;
{
colPos = _i;
}
public void handleEvent(Event event) {
System.out.println("Mouse Clicked on " + colPos);
sortFlag = !sortFlag;
//Sort
System.out.println(sortFlag);
TableItem[] tableItems = table.getItems();
sortTable(table, tableItems, colPos, comparables, sortFlag);
}
});
}
shell.setSize(320, 240);
shell.setText("TableTest");
shell.open();
while (!shell.isDisposed())
if (!display.readAndDispatch())
display.sleep();
display.dispose();
}
/**
* Hier werden die Daten der Spalten des "original" TableItem[] in einen MyComperatorArray
* umkopiert und darauf hin wird dieser mittels der Array.sort(Object[] o) Methode sortiert.
* Da sich der MyComperator die ursprüngliche Position in der Tabelle gemerkt hat, kann
* man nun ganz einfach die entsprechenden Werte im Original Array tauschen und schon ist man fertig.
* @param tableItems
*/
protected final void sortTable(
Table table,
TableItem[] tableItems,
int colPos,
BaseComapator[][] comparables,
boolean sortFlag) {
//SortFlag bei allen richtig setzen ... leider kann ich bei inneren
//keine static Variablen anlegen ansonsten wäre das hier unnötig...
for (int i = 0; i < comparables[colPos].length; i++) {
comparables[colPos][i]._sortFlag = sortFlag;
}
Arrays.sort(comparables[colPos]);
String[] tmp;
String[] textBuffer = null;
textBuffer = new String[comparables.length];
for (int i = 0; i < comparables[colPos].length; i++) {
int rowNum = comparables[colPos][i]._oldRowNum;
tmp = comparables[colPos][i]._textBuffer;
tableItems[rowNum].setText(comparables[colPos][rowNum]._textBuffer);
tableItems[i].setText(tmp);
}
}
/**
*Basisklasse für alle weiteren Comparatoren...
*
*/
class BaseComapator implements Comparable {
String[] _textBuffer;
int _oldRowNum;
int _colPos;
boolean _sortFlag;
public BaseComapator(String[] textBuffer, int oldRowNum, int colPos){
_textBuffer = textBuffer;
_oldRowNum = oldRowNum;
_colPos = colPos;
}
/* (non-Javadoc)
* @see java.lang.Comparable#compareTo(java.lang.Object)
*/
public int compareTo(Object o) {
return 0;
}
}
/**
*
* @author Administrator
* Eigener Comparator der das Vergleichen der einzelnen Tabellenzeilen vornimmt...
*/
class StringComparator extends BaseComapator implements Comparable {
/**
* Konstruktor ...
* @param textBuffer : Der Text der Zeile
* @param rowNum : Die Zeilennr der Tabellenzeile
* @param sortFlag : Aufsteigend false, Absteigend true
* @param colPos : Die Spalte nach der Sortiert werden soll
*/
public StringComparator(String[] textBuffer, int rowNum, int colPos) {
super(textBuffer,rowNum,colPos);
}
public final int compareTo(Object arg0) {
int ret =
_textBuffer[_colPos].compareTo(
((StringComparator) arg0)._textBuffer[_colPos]);
return _sortFlag ? ret : ret * -1;
}
}
/**
* NumberComparator kümmert sich um das Vergleichen von Numerischen Werten...
*
*/
class NumberComparator extends BaseComapator implements Comparable {
int _intValue;
public NumberComparator(String[] textBuffer, int rowNum, int colPos) {
super(textBuffer,rowNum,colPos);
_intValue = Integer.parseInt(textBuffer[colPos]);
}
public final int compareTo(Object o) {
int _intValToCompare = ((NumberComparator) o)._intValue;
int ret =
_intValue < _intValToCompare
? -1
: (_intValue == _intValToCompare ? 0 : 1);
return _sortFlag ? ret : ret * -1;
}
}
}
)Die dazu notwendigen Select Statements könnte man ja dann je nach Datenbank als Parameterisierte Stored Procedures anlegen und nach den jeweiligen Anforderung nach ausführen.
