303 lines
8.4 KiB
Java
303 lines
8.4 KiB
Java
/**
|
|
*
|
|
*/
|
|
|
|
package org.gcube.portlets.user.geoportaldataentry.client.ui.table;
|
|
|
|
import java.util.Collections;
|
|
import java.util.Comparator;
|
|
import java.util.HashMap;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
|
|
import org.gcube.portlets.user.geoportaldataentry.client.resource.CellTableResources;
|
|
|
|
import com.github.gwtbootstrap.client.ui.CellTable;
|
|
import com.google.gwt.user.cellview.client.Column;
|
|
import com.google.gwt.user.cellview.client.ColumnSortEvent;
|
|
import com.google.gwt.user.cellview.client.ColumnSortEvent.AsyncHandler;
|
|
import com.google.gwt.user.cellview.client.ColumnSortEvent.ListHandler;
|
|
import com.google.gwt.user.cellview.client.ColumnSortList.ColumnSortInfo;
|
|
import com.google.gwt.user.cellview.client.Header;
|
|
import com.google.gwt.view.client.AbstractDataProvider;
|
|
import com.google.gwt.view.client.AsyncDataProvider;
|
|
import com.google.gwt.view.client.ListDataProvider;
|
|
|
|
/**
|
|
* The Class SortedCellTable.
|
|
*
|
|
* @author Francesco Mangiacrapa at ISTI-CNR francesco.mangiacrapa@isti.cnr.it
|
|
*
|
|
* Jun 15, 2021
|
|
* @param <T> the generic type
|
|
*/
|
|
public class SortedCellTable<T> extends CellTable<T> {
|
|
|
|
/**
|
|
* To keep track of the currently sorted column
|
|
*/
|
|
private Column<T, ?> currentlySortedColumn;
|
|
/**
|
|
* Tells us which way to sort a column initially
|
|
*/
|
|
private Map<Column<T, ?>, Boolean> defaultSortOrderMap = new HashMap<Column<T, ?>, Boolean>();
|
|
/**
|
|
* Comparators associated with their columns
|
|
*/
|
|
private Map<Column<T, ?>, Comparator<T>> comparators = new HashMap<Column<T, ?>, Comparator<T>>();
|
|
/**
|
|
* Column to sort when the data provider's list is refreshed using
|
|
* {@link SortedCellTable#setList(List)}
|
|
*/
|
|
private Column<T, ?> initialSortColumn;
|
|
/**
|
|
* Data provider we will attach to this table
|
|
*/
|
|
private AbstractDataProvider<T> dataProvider;
|
|
|
|
/**
|
|
* Special column sorting handler that will allow us to do more controlled
|
|
* sorting
|
|
*/
|
|
private ColumnSortEvent.Handler columnSortHandler;
|
|
|
|
/**
|
|
* Instantiates a new sorted cell table.
|
|
*
|
|
* @param pageSize the page size
|
|
* @param dataProv the data prov
|
|
*/
|
|
public SortedCellTable(int pageSize, AbstractDataProvider<T> dataProv) {
|
|
super(pageSize, CellTableResources.INSTANCE);
|
|
this.dataProvider = dataProv;
|
|
|
|
if (this.dataProvider instanceof ListDataProvider) {
|
|
ListDataProvider<T> listDataProvider = (ListDataProvider<T>) this.dataProvider;
|
|
ListHandler<T> listSortHandler = new ListHandler<T>((listDataProvider).getList()) {
|
|
|
|
@Override
|
|
public void onColumnSort(ColumnSortEvent event) {
|
|
|
|
@SuppressWarnings("unchecked")
|
|
Column<T, ?> column = (Column<T, ?>) event.getColumn();
|
|
if (column == null) {
|
|
return;
|
|
}
|
|
if (column.equals(currentlySortedColumn)) {
|
|
// Default behavior
|
|
super.onColumnSort(event);
|
|
} else {
|
|
// Initial sort; look up which direction we need
|
|
final Comparator<T> comparator = comparators.get(column);
|
|
if (comparator == null) {
|
|
return;
|
|
}
|
|
Boolean ascending = defaultSortOrderMap.get(column);
|
|
if (ascending == null || ascending) {
|
|
// Default behavior
|
|
super.onColumnSort(event);
|
|
} else {
|
|
// Sort the column descending
|
|
Collections.sort(getList(), new Comparator<T>() {
|
|
|
|
public int compare(T o1, T o2) {
|
|
|
|
return -comparator.compare(o1, o2);
|
|
}
|
|
});
|
|
// Set the proper arrow in the header
|
|
getColumnSortList().push(new ColumnSortInfo(column, false));
|
|
}
|
|
currentlySortedColumn = column;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void setComparator(Column<T, ?> column, Comparator<T> comparator) {
|
|
|
|
comparators.put(column, comparator);
|
|
super.setComparator(column, comparator);
|
|
}
|
|
};
|
|
addColumnSortHandler(listSortHandler);
|
|
columnSortHandler = listSortHandler;
|
|
} else if (this.dataProvider instanceof AsyncDataProvider) {
|
|
//AsyncDataProvider asyncDataProvider = ((AsyncDataProvider) this.dataProvider);
|
|
//asyncDataProvider.get
|
|
AsyncHandler asyncSortHandler = new AsyncHandler(this) {
|
|
@Override
|
|
public void onColumnSort(ColumnSortEvent event) {
|
|
|
|
@SuppressWarnings("unchecked")
|
|
Column<T, ?> column = (Column<T, ?>) event.getColumn();
|
|
if (column == null) {
|
|
return;
|
|
}
|
|
if (column.equals(currentlySortedColumn)) {
|
|
// Default behavior
|
|
super.onColumnSort(event);
|
|
} else {
|
|
// Initial sort; look up which direction we need
|
|
final Comparator<T> comparator = comparators.get(column);
|
|
if (comparator == null) {
|
|
return;
|
|
}
|
|
Boolean ascending = defaultSortOrderMap.get(column);
|
|
if (ascending == null || ascending) {
|
|
// Default behavior
|
|
super.onColumnSort(event);
|
|
} else {
|
|
// Sort the column descending
|
|
Collections.sort(getVisibleItems(), new Comparator<T>() {
|
|
|
|
public int compare(T o1, T o2) {
|
|
|
|
return -comparator.compare(o1, o2);
|
|
}
|
|
});
|
|
// Set the proper arrow in the header
|
|
getColumnSortList().push(new ColumnSortInfo(column, false));
|
|
}
|
|
currentlySortedColumn = column;
|
|
}
|
|
}
|
|
};
|
|
|
|
// addColumnSortHandler(asyncSortHandler);
|
|
// columnSortHandler = asyncSortHandler;
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* Adds a column to the table and sets its sortable state.
|
|
*
|
|
* @param column the column
|
|
* @param headerName the header name
|
|
* @param sortable the sortable
|
|
*/
|
|
public void addColumn(Column<T, ?> column, String headerName, boolean sortable) {
|
|
|
|
addColumn(column, headerName);
|
|
column.setSortable(sortable);
|
|
if (sortable) {
|
|
defaultSortOrderMap.put(column, true);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Adds the column.
|
|
*
|
|
* @param column the column
|
|
* @param headerName the header name
|
|
*/
|
|
/*
|
|
* (non-Javadoc)
|
|
*
|
|
* @see
|
|
* com.google.gwt.user.cellview.client.AbstractCellTable#addColumn(com.google.
|
|
* gwt.user.cellview.client.Column, java.lang.String)
|
|
*/
|
|
public void addColumn(Column<T, ?> column, String headerName) {
|
|
|
|
super.addColumn(column, headerName);
|
|
}
|
|
|
|
/**
|
|
* Adds a column to the table and sets its sortable state.
|
|
*
|
|
* @param column the column
|
|
* @param header the header
|
|
* @param sortable the sortable
|
|
*/
|
|
public void addColumn(Column<T, ?> column, Header<?> header, boolean sortable) {
|
|
|
|
addColumn(column, header);
|
|
column.setSortable(sortable);
|
|
if (sortable) {
|
|
defaultSortOrderMap.put(column, true);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Sets the column to sort when the data list is reset using
|
|
* {@link SortedCellTable#setList(List)}.
|
|
*
|
|
* @param column the column
|
|
*/
|
|
public void setInitialSortColumn(Column<T, ?> column) {
|
|
|
|
initialSortColumn = column;
|
|
}
|
|
|
|
/**
|
|
* Set the comparator used to sort the specified column in ascending order.
|
|
*
|
|
* @param column the {@link Column}
|
|
* @param comparator the {@link Comparator} to use for the {@link Column}
|
|
*/
|
|
public void setComparator(Column<T, ?> column, Comparator<T> comparator) {
|
|
comparators.put(column, comparator);
|
|
}
|
|
|
|
/**
|
|
* Sets the sort order to use when this column is clicked and it was not
|
|
* previously sorted.
|
|
*
|
|
* @param column the column
|
|
* @param ascending the ascending
|
|
*/
|
|
public void setDefaultSortOrder(Column<T, ?> column, boolean ascending) {
|
|
|
|
defaultSortOrderMap.put(column, ascending);
|
|
}
|
|
|
|
/**
|
|
* Sets the table's data provider list and sorts the table based on the column
|
|
* given in {@link SortedCellTable#setInitialSortColumn(Column)}.
|
|
*
|
|
* @param list the new list
|
|
*/
|
|
public void setList(List<T> list) {
|
|
|
|
if (dataProvider instanceof ListDataProvider) {
|
|
List<T> myData = ((ListDataProvider) dataProvider).getList();
|
|
myData.clear();
|
|
if (list != null) {
|
|
/*
|
|
* for (T t : list) { dataProvider.getList().add(t); }
|
|
*/
|
|
myData.addAll(list);
|
|
}
|
|
// Do a first-time sort based on which column was set in
|
|
// setInitialSortColumn()
|
|
if (initialSortColumn != null) {
|
|
Collections.sort(myData, new Comparator<T>() {
|
|
|
|
@Override
|
|
public int compare(T o1, T o2) {
|
|
|
|
return (defaultSortOrderMap.get(initialSortColumn) ? 1 : -1)
|
|
* comparators.get(initialSortColumn).compare(o1, o2);
|
|
}
|
|
});
|
|
// Might as well get the little arrow on the header to make it
|
|
// official
|
|
getColumnSortList().push(new ColumnSortInfo(initialSortColumn, defaultSortOrderMap.get(initialSortColumn)));
|
|
|
|
currentlySortedColumn = initialSortColumn;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets the data provider.
|
|
*
|
|
* @return the data provider
|
|
*/
|
|
public AbstractDataProvider<T> getDataProvider() {
|
|
|
|
return dataProvider;
|
|
}
|
|
}
|