import com.vaadin.client.data.DataChangeHandler;
import com.vaadin.client.data.DataSource;
import com.vaadin.client.ui.SubPartAware;
+import com.vaadin.client.ui.grid.GridHeader.HeaderRow;
import com.vaadin.client.ui.grid.renderers.ComplexRenderer;
import com.vaadin.client.ui.grid.renderers.TextRenderer;
import com.vaadin.client.ui.grid.renderers.WidgetRenderer;
protected abstract <T> SelectionModel<T> createModel();
}
+ class SortableColumnHeaderRenderer extends
+ AbstractGridColumn.SortableColumnHeaderRenderer {
+ SortableColumnHeaderRenderer(Renderer<String> cellRenderer) {
+ super(Grid.this, cellRenderer);
+ }
+ }
+
/**
* Base class for grid columns internally used by the Grid. The user should
* use {@link GridColumn} when creating new columns.
*
* FIXME Currently assumes multisorting
*/
- private class SortableColumnHeaderRenderer extends
+ static class SortableColumnHeaderRenderer extends
ComplexRenderer<String> {
+ private Grid<?> grid;
+
/**
* Delay before a long tap action is triggered. Number in
* milliseconds.
@Override
public void run() {
- SortOrder sortingOrder = getSortingOrder();
+ SortOrder sortingOrder = getSortingOrder(grid
+ .getColumnFromVisibleIndex(cell.getColumn()));
if (sortingOrder == null) {
/*
* No previous sorting, sort Ascending
* @param cellRenderer
* The actual cell renderer
*/
- public SortableColumnHeaderRenderer(Renderer<String> cellRenderer) {
+ public SortableColumnHeaderRenderer(Grid<?> grid,
+ Renderer<String> cellRenderer) {
+ this.grid = grid;
this.cellRenderer = cellRenderer;
}
* this is fixed.
*/
if (grid != null) {
- SortOrder sortingOrder = getSortingOrder();
+ GridColumn<?, ?> column = grid
+ .getColumnFromVisibleIndex(cell.getColumn());
+ SortOrder sortingOrder = getSortingOrder(column);
Element cellElement = cell.getElement();
- if (grid.getColumn(cell.getColumn()).isSortable()) {
+ if (column.isSortable()) {
if (sortingOrder != null) {
if (SortDirection.ASCENDING == sortingOrder
.getDirection()) {
}
+ protected void removeFromRow(HeaderRow row) {
+ row.setRenderer(new Renderer<String>() {
+ @Override
+ public void render(FlyweightCell cell, String data) {
+ cleanup(cell);
+ }
+ });
+ grid.refreshHeader();
+ row.setRenderer(cellRenderer);
+ grid.refreshHeader();
+ }
+
/**
* Sorts the column in a direction
*/
TableCellElement th = TableCellElement.as(cell.getElement());
// Apply primary sorting on clicked column
- GridColumn<C, T> columnInstance = getColumnInstance();
+ GridColumn<?, ?> columnInstance = grid
+ .getColumnFromVisibleIndex(cell.getColumn());
Sort sorting = Sort.by(columnInstance, direction);
// Re-apply old sorting to the sort order
if (multisort) {
for (SortOrder order : grid.getSortOrder()) {
- if (order.getColumn() != AbstractGridColumn.this) {
+ if (order.getColumn() != columnInstance) {
sorting = sorting.then(order.getColumn(),
order.getDirection());
}
grid.sort(sorting);
}
- /**
- * Resolves a GridColumn out of a AbstractGridColumn
- */
- private GridColumn<C, T> getColumnInstance() {
- for (GridColumn<?, T> column : grid.getColumns()) {
- if (column == AbstractGridColumn.this) {
- return (GridColumn<C, T>) column;
- }
- }
- return null;
- }
-
/**
* Finds the sorting order for this column
*/
- private SortOrder getSortingOrder() {
+ private SortOrder getSortingOrder(GridColumn<?, ?> column) {
for (SortOrder order : grid.getSortOrder()) {
- if (order.getColumn() == AbstractGridColumn.this) {
+ if (order.getColumn() == column) {
return order;
}
}
* Renderer for rendering the header cell value into the cell
*/
@Deprecated
- private Renderer<String> headerRenderer = new SortableColumnHeaderRenderer(
- new TextRenderer());
+ private Renderer<String> headerRenderer = new TextRenderer();
/**
* Renderer for rendering the footer cell value into the cell
throw new IllegalArgumentException("Renderer cannot be null.");
}
- this.headerRenderer = new SortableColumnHeaderRenderer(
- headerRenderer);
+ this.headerRenderer = headerRenderer;
this.footerRenderer = footerRenderer;
}
if (renderer == null) {
throw new IllegalArgumentException("Renderer cannot be null.");
}
- headerRenderer = new SortableColumnHeaderRenderer(headerRenderer);
+ this.headerRenderer = headerRenderer;
if (grid != null) {
grid.refreshHeader();
}
escalator.getFooter().setEscalatorUpdater(createFooterUpdater());
header.setGrid(this);
- header.appendRow();
+ HeaderRow defaultRow = header.appendRow();
+ header.setDefaultRow(defaultRow);
footer.setGrid(this);
if (container != null) {
cell = container.getCell(e);
if (cell != null) {
+ // FIXME getFromVisibleIndex???
GridColumn<?, T> gridColumn = columns.get(cell.getColumn());
Renderer<?> renderer;
if (container == escalator.getHeader()) {
- renderer = gridColumn.getHeaderRenderer();
+ renderer = header.getRow(cell.getRow()).getRenderer();
} else if (container == escalator.getFooter()) {
- renderer = gridColumn.getFooterRenderer();
+ renderer = footer.getRow(cell.getRow()).getRenderer();
} else {
renderer = gridColumn.getRenderer();
}
import com.vaadin.client.data.DataSource.RowHandle;
import com.vaadin.client.data.RpcDataSourceConnector.RpcDataSource;
import com.vaadin.client.ui.AbstractComponentConnector;
+import com.vaadin.client.ui.grid.GridHeader.HeaderRow;
import com.vaadin.client.ui.grid.GridStaticSection.StaticRow;
import com.vaadin.client.ui.grid.renderers.AbstractRendererConnector;
import com.vaadin.client.ui.grid.selection.AbstractRowHandleSelectionModel;
for (CellState cellState : rowState.cells) {
row.getCell(i++).setText(cellState.text);
}
+
+ if (section instanceof GridHeader && rowState.defaultRow) {
+ ((GridHeader) section).setDefaultRow((HeaderRow) row);
+ }
}
section.setVisible(state.visible);
*/
package com.vaadin.client.ui.grid;
+import com.vaadin.client.ui.grid.Grid.AbstractGridColumn.SortableColumnHeaderRenderer;
+
/**
* Represents the header section of a Grid. A header consists of a single header
* row containing a header cell for each column. Each cell has a simple textual
*/
public class HeaderRow extends GridStaticSection.StaticRow<HeaderCell> {
+ private boolean isDefault = false;
+
+ protected void setDefault(boolean isDefault) {
+ this.isDefault = isDefault;
+ }
+
+ public boolean isDefault() {
+ return isDefault;
+ }
+
@Override
protected HeaderCell createCell() {
return new HeaderCell();
public class HeaderCell extends GridStaticSection.StaticCell {
}
+ private HeaderRow defaultRow;
+
+ @Override
+ public void removeRow(int index) {
+ HeaderRow removedRow = getRow(index);
+ super.removeRow(index);
+ if (removedRow == defaultRow) {
+ setDefaultRow(null);
+ }
+ }
+
+ /**
+ * Sets the default row of this header. The default row is a special header
+ * row providing a user interface for sorting columns.
+ *
+ * @param row
+ * the new default row, or null for no default row
+ *
+ * @throws IllegalArgumentException
+ * this header does not contain the row
+ */
+ public void setDefaultRow(HeaderRow row) {
+ if (row == defaultRow) {
+ return;
+ }
+ if (row != null && !getRows().contains(row)) {
+ throw new IllegalArgumentException(
+ "Cannot set a default row that does not exist in the container");
+ }
+ if (defaultRow != null) {
+ assert defaultRow.getRenderer() instanceof SortableColumnHeaderRenderer;
+
+ // Eclipse is wrong about this warning - javac does not accept the
+ // parameterized version
+ ((Grid.SortableColumnHeaderRenderer) defaultRow.getRenderer())
+ .removeFromRow(defaultRow);
+
+ defaultRow.setDefault(false);
+ }
+ if (row != null) {
+ assert !(row.getRenderer() instanceof SortableColumnHeaderRenderer);
+
+ row.setRenderer(getGrid().new SortableColumnHeaderRenderer(row
+ .getRenderer()));
+
+ row.setDefault(true);
+ }
+ defaultRow = row;
+ refreshGrid();
+ }
+
+ /**
+ * Returns the current default row of this header. The default row is a
+ * special header row providing a user interface for sorting columns.
+ *
+ * @return the default row or null if no default row set
+ */
+ public HeaderRow getDefaultRow() {
+ return defaultRow;
+ }
+
@Override
protected HeaderRow createRow() {
return new HeaderRow();
cells.remove(index);
}
+ protected void setRenderer(Renderer<String> renderer) {
+ this.renderer = renderer;
+ }
+
protected Renderer<String> getRenderer() {
return renderer;
}
* if the row does not exist in this section
*/
public void removeRow(ROWTYPE row) {
- if (!rows.remove(row)) {
+ try {
+ removeRow(rows.indexOf(row));
+ } catch (IndexOutOfBoundsException e) {
throw new IllegalArgumentException(
"Section does not contain the given row");
}
- refreshGrid();
}
/**
*/
public Grid(final Container.Indexed datasource) {
- getState().header.rows.add(new RowState());
+ RowState headerDefaultRow = new RowState();
+ headerDefaultRow.defaultRow = true;
+ getState().header.rows.add(headerDefaultRow);
+
+ // FIXME By default there shouldn't be any footer row
getState().footer.rows.add(new RowState());
+
setColumnFootersVisible(false);
setContainerDataSource(datasource);
public static class RowState implements Serializable {
public List<CellState> cells = new ArrayList<CellState>();
+
+ public boolean defaultRow = false;
}
public List<RowState> rows = new ArrayList<RowState>();
package com.vaadin.tests.components.grid.basicfeatures;
import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import java.util.Arrays;
import java.util.List;
import org.junit.Test;
import com.vaadin.testbench.TestBenchElement;
+import com.vaadin.tests.components.grid.GridElement.GridCellElement;
public class GridHeaderTest extends GridStaticSectionTest {
assertHeaderTexts(0, 0);
}
+ @Test
+ public void testDefaultRow() throws Exception {
+ openTestURL();
+
+ selectMenuPath("Component", "Columns", "Column 0", "Sortable");
+
+ GridCellElement headerCell = getGridElement().getHeaderCell(0, 0);
+
+ headerCell.click();
+
+ assertTrue(hasClassName(headerCell, "sort-asc"));
+
+ headerCell.click();
+
+ assertFalse(hasClassName(headerCell, "sort-asc"));
+ assertTrue(hasClassName(headerCell, "sort-desc"));
+
+ selectMenuPath("Component", "Header", "Prepend row");
+ selectMenuPath("Component", "Header", "Default row", "Top");
+
+ assertFalse(hasClassName(headerCell, "sort-desc"));
+ headerCell = getGridElement().getHeaderCell(0, 0);
+ assertTrue(hasClassName(headerCell, "sort-desc"));
+
+ selectMenuPath("Component", "Header", "Default row", "Unset");
+
+ assertFalse(hasClassName(headerCell, "sort-desc"));
+ }
+
private void assertHeaderCount(int count) {
assertEquals("header count", count, getGridElement().getHeaderCount());
}
+
+ private boolean hasClassName(TestBenchElement element, String name) {
+ return Arrays.asList(element.getAttribute("class").split(" "))
+ .contains(name);
+ }
}
import com.vaadin.client.ui.grid.GridHeader.HeaderRow;
import com.vaadin.client.ui.grid.Renderer;
import com.vaadin.client.ui.grid.datasources.ListDataSource;
+import com.vaadin.client.ui.grid.datasources.ListSorter;
import com.vaadin.client.ui.grid.renderers.DateRenderer;
import com.vaadin.client.ui.grid.renderers.HtmlRenderer;
import com.vaadin.client.ui.grid.renderers.NumberRenderer;
private final Grid<List<Data>> grid;
private final List<List<Data>> data;
private final ListDataSource<List<Data>> ds;
+ private final ListSorter<List<Data>> sorter;
/**
* Our basic data object
grid.setDataSource(ds);
grid.setSelectionMode(SelectionMode.NONE);
+ sorter = new ListSorter<List<Data>>(grid);
+
// Create a bunch of grid columns
// Data source layout:
!grid.getColumn(index).isVisible());
}
}, "Component", "Columns", "Column " + i);
+ addMenuCommand("Sortable", new ScheduledCommand() {
+ @Override
+ public void execute() {
+ grid.getColumn(index).setSortable(
+ !grid.getColumn(index).isSortable());
+ }
+ }, "Component", "Columns", "Column " + i);
}
}
}
}, menuPath);
+ addMenuCommand("Top", new ScheduledCommand() {
+ @Override
+ public void execute() {
+ header.setDefaultRow(header.getRow(0));
+ }
+ }, "Component", "Header", "Default row");
+ addMenuCommand("Bottom", new ScheduledCommand() {
+ @Override
+ public void execute() {
+ header.setDefaultRow(header.getRow(header.getRowCount() - 1));
+ }
+ }, "Component", "Header", "Default row");
+ addMenuCommand("Unset", new ScheduledCommand() {
+ @Override
+ public void execute() {
+ header.setDefaultRow(null);
+ }
+ }, "Component", "Header", "Default row");
+
addMenuCommand("Prepend row", new ScheduledCommand() {
@Override
public void execute() {
projects / vaadin-framework.git / commitdiff