import java.util.logging.Logger;
import com.google.gwt.core.shared.GWT;
+import com.google.gwt.dom.client.BrowserEvents;
import com.google.gwt.dom.client.Element;
import com.google.gwt.dom.client.EventTarget;
+import com.google.gwt.dom.client.NativeEvent;
+import com.google.gwt.dom.client.TableCellElement;
import com.google.gwt.event.shared.HandlerRegistration;
import com.google.gwt.user.client.DOM;
import com.google.gwt.user.client.Event;
/**
* A data grid view that supports columns and lazy loading of data rows from a
* data source.
- *
+ *
* <h3>Columns</h3>
* <p>
* The {@link GridColumn} class defines the renderer used to render a cell in
* specific column index using {@link Grid#getColumn(int)}.
* </p>
* <p>
- *
+ *
* TODO Explain about headers/footers once the multiple header/footer api has
* been implemented
- *
+ *
* <h3>Data sources</h3>
* <p>
* TODO Explain about what a data source is and how it should be implemented.
* </p>
- *
+ *
* @param <T>
* The row type of the grid. The row type is the POJO type from where
* the data is retrieved into the column cells.
/**
* Base class for grid columns internally used by the Grid. The user should
* use {@link GridColumn} when creating new columns.
- *
+ *
* @param <C>
* the column type
- *
+ *
* @param <T>
* the row type
*/
static abstract class AbstractGridColumn<C, T> implements HasVisibility {
+ /**
+ * Renderer for columns which are sortable
+ *
+ * FIXME Currently assumes multisorting
+ *
+ * FIXME Currently all columns are assumed sortable
+ *
+ */
+ private class SortableColumnHeaderRenderer extends
+ ComplexRenderer<String> {
+
+ private Renderer<String> cellRenderer;
+
+ /**
+ * Creates column renderer with sort indicators
+ *
+ * @param cellRenderer
+ * The actual cell renderer
+ */
+ public SortableColumnHeaderRenderer(Renderer<String> cellRenderer) {
+ this.cellRenderer = cellRenderer;
+ }
+
+ @Override
+ public void render(FlyweightCell cell, String data) {
+
+ // Render cell
+ this.cellRenderer.render(cell, data);
+
+ /*
+ * FIXME This grid null check is needed since Grid.addColumns()
+ * is invoking Escalator.insertColumn() before the grid instance
+ * for the column is set resulting in the first render() being
+ * done without a grid instance. Remove the if statement when
+ * this is fixed.
+ */
+ if (grid != null) {
+ SortOrder sortingOrder = getSortingOrder();
+ Element cellElement = cell.getElement();
+ if (sortingOrder != null) {
+ int sortIndex = grid.getSortOrder().indexOf(
+ sortingOrder);
+ if (sortIndex > -1 && grid.getSortOrder().size() > 1) {
+ // Show sort order indicator if column is sorted and
+ // other sorted columns also exists.
+ cellElement.setAttribute("sort-order",
+ String.valueOf(sortIndex + 1));
+
+ } else {
+ cellElement.removeAttribute("sort-order");
+ }
+ } else {
+ cellElement.removeAttribute("sort-order");
+ cellElement.removeClassName("sort-desc");
+ cellElement.removeClassName("sort-asc");
+ }
+ }
+ }
+
+ @Override
+ public Collection<String> getConsumedEvents() {
+ return Arrays.asList(BrowserEvents.MOUSEDOWN);
+ }
+
+ @Override
+ public void onBrowserEvent(Cell cell, NativeEvent event) {
+ if (BrowserEvents.MOUSEDOWN.equals(event.getType())) {
+ event.preventDefault();
+
+ SortOrder sortingOrder = getSortingOrder();
+ if (sortingOrder == null) {
+ /*
+ * No previous sorting, sort Ascending
+ */
+ sort(cell, SortDirection.ASCENDING, event.getShiftKey());
+
+ } else {
+ // Toggle sorting
+ SortDirection direction = sortingOrder.getDirection();
+ if (direction == SortDirection.ASCENDING) {
+ sort(cell, SortDirection.DESCENDING,
+ event.getShiftKey());
+ } else {
+ sort(cell, SortDirection.ASCENDING,
+ event.getShiftKey());
+ }
+ }
+ }
+ }
+
+ /**
+ * Sorts the column in a direction
+ */
+ private void sort(Cell cell, SortDirection direction,
+ boolean multisort) {
+ TableCellElement th = TableCellElement.as(cell.getElement());
+
+ if (SortDirection.ASCENDING.equals(direction)) {
+ th.replaceClassName("sort-desc", "sort-asc");
+ } else {
+ th.replaceClassName("sort-asc", "sort-desc");
+ }
+
+ // Apply primary sorting on clicked column
+ GridColumn<C, T> columnInstance = getColumnInstance();
+ 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) {
+ sorting = sorting.then(order.getColumn(),
+ order.getDirection());
+ }
+ }
+ }
+
+ // Perform sorting
+ grid.sort(sorting);
+
+ // Update header indicators
+ grid.refreshHeader();
+ }
+
+ /**
+ * 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() {
+ for (SortOrder order : grid.getSortOrder()) {
+ if (order.getColumn() == AbstractGridColumn.this) {
+ return order;
+ }
+ }
+ return null;
+ }
+
+ }
+
/**
* The grid the column is associated with
*/
/**
* Renderer for rendering the header cell value into the cell
*/
- private Renderer<String> headerRenderer = new TextRenderer();
+ private SortableColumnHeaderRenderer headerRenderer = new SortableColumnHeaderRenderer(
+ new TextRenderer());
/**
* Renderer for rendering the footer cell value into the cell
/**
* Constructs a new column with a custom renderer.
- *
+ *
* @param renderer
* The renderer to use for rendering the cells
*/
/**
* Constructs a new column with custom renderers for rows, header and
* footer cells.
- *
+ *
* @param bodyRenderer
* The renderer to use for rendering body cells
* @param headerRenderer
throw new IllegalArgumentException("Renderer cannot be null.");
}
- this.headerRenderer = headerRenderer;
+ this.headerRenderer = new SortableColumnHeaderRenderer(
+ headerRenderer);
this.footerRenderer = footerRenderer;
}
/**
* Internally used by the grid to set itself
- *
+ *
* @param grid
*/
private void setGrid(Grid<T> grid) {
/**
* Gets text in the header of the column. By default the header caption
* is empty.
- *
+ *
* @return the text displayed in the column caption
*/
public String getHeaderCaption() {
/**
* Returns the renderer used for rendering the header cells
- *
+ *
* @return a renderer that renders header cells
*/
public Renderer<String> getHeaderRenderer() {
/**
* Sets the renderer that renders header cells. Should not be null.
- *
+ *
* @param renderer
* The renderer to use for rendering header cells.
*/
if (renderer == null) {
throw new IllegalArgumentException("Renderer cannot be null.");
}
- headerRenderer = renderer;
+ headerRenderer = new SortableColumnHeaderRenderer(headerRenderer);
if (grid != null) {
grid.refreshHeader();
}
/**
* Returns the renderer used for rendering the footer cells
- *
+ *
* @return a renderer that renders footer cells
*/
public Renderer<String> getFooterRenderer() {
/**
* Sets the renderer that renders footer cells. Should not be null.
- *
+ *
* @param renderer
* The renderer to use for rendering footer cells.
*/
/**
* Sets the text in the header of the column.
- *
+ *
* @param caption
* the text displayed in the column header
*/
/**
* Gets text in the footer of the column. By default the footer caption
* is empty.
- *
+ *
* @return The text displayed in the footer of the column
*/
public String getFooterCaption() {
/**
* Sets text in the footer of the column.
- *
+ *
* @param caption
* the text displayed in the footer of the column
*/
/**
* Is the column visible. By default all columns are visible.
- *
+ *
* @return <code>true</code> if the column is visible
*/
@Override
/**
* Sets a column as visible in the grid.
- *
+ *
* @param visible
* <code>true</code> if the column should be displayed in the
* grid
* <p>
* To support other types you will need to pass a custom renderer to the
* column via the column constructor.
- *
+ *
* @param row
* The row object that provides the cell content.
- *
+ *
* @return The cell content
*/
public abstract C getValue(T row);
* The renderer to render the cell width. By default renders the data as
* a String or adds the widget into the cell if the column type is of
* widget type.
- *
+ *
* @return The renderer to render the cell content with
*/
public Renderer<? super C> getRenderer() {
/**
* Finds the index of this column instance
- *
+ *
*/
private int findIndexOfColumn() {
return grid.findVisibleColumnIndex((GridColumn<?, T>) this);
/**
* Sets the pixel width of the column. Use a negative value for the grid
* to autosize column based on content and available space
- *
+ *
* @param pixels
* the width in pixels or negative for auto sizing
*/
/**
* Returns the pixel width of the column
- *
+ *
* @return pixel width of the column
*/
public int getWidth() {
/**
* Constructs an updater for updating a header / footer
- *
+ *
* @param rows
* The row container
* @param inverted
/**
* Gets the header/footer caption value
- *
+ *
* @param column
* The column to get the value for.
- *
+ *
* @return The value that should be rendered for the column caption
*/
public abstract String getColumnValue(GridColumn<?, T> column);
/**
* Gets the group caption value
- *
+ *
* @param group
* The group for with the caption value should be returned
* @return The value that should be rendered for the column caption
/**
* Is the row visible in the header/footer
- *
+ *
* @param row
* the row to check
- *
+ *
* @return <code>true</code> if the row should be visible
*/
public abstract boolean isRowVisible(ColumnGroupRow<T> row);
/**
* Should the first row be visible
- *
+ *
* @return <code>true</code> if the first row should be visible
*/
public abstract boolean firstRowIsVisible();
/**
* The renderer that renders the cell
- *
+ *
* @param column
* The column for which the cell should be rendered
- *
+ *
* @return renderer used for rendering
*/
public abstract Renderer<String> getRenderer(GridColumn<?, T> column);
/**
* The renderer that renders the cell for column groups
- *
+ *
* @param group
* The group that should be rendered
* @return renderer used for rendering
/**
* Creates the header updater that updates the escalator header rows from
* the column and column group rows.
- *
+ *
* @return the updater that updates the data in the escalator.
*/
private EscalatorUpdater createHeaderUpdater() {
/**
* Creates the footer updater that updates the escalator footer rows from
* the column and column group rows.
- *
+ *
* @return the updater that updates the data in the escalator.
*/
private EscalatorUpdater createFooterUpdater() {
/**
* Refreshes header or footer rows on demand
- *
+ *
* @param rows
* The row container
* @param firstRowIsVisible
/**
* Adds a column as the last column in the grid.
- *
+ *
* @param column
* the column to add
*/
/**
* Inserts a column into a specific position in the grid.
- *
+ *
* @param index
* the index where the column should be inserted into
* @param column
/**
* Removes a column from the grid.
- *
+ *
* @param column
* the column to remove
*/
/**
* Returns the amount of columns in the grid.
- *
+ *
* @return The number of columns in the grid
*/
public int getColumnCount() {
/**
* Returns a list of columns in the grid.
- *
+ *
* @return A unmodifiable list of the columns in the grid
*/
public List<GridColumn<?, T>> getColumns() {
/**
* Returns a column by its index in the grid.
- *
+ *
* @param index
* the index of the column
* @return The column in the given index
/**
* Set the column headers visible.
- *
+ *
* <p>
* A column header is a single cell header on top of each column reserved
* for a specific header for that column. The column header can be set by
* {@link GridColumn#setHeaderCaption(String)} and column headers cannot be
* merged with other column headers.
* </p>
- *
+ *
* <p>
* All column headers occupy the first header row of the grid. If you do not
* wish to show the column headers in the grid you should hide the row by
* setting visibility of the header row to <code>false</code>.
* </p>
- *
+ *
* <p>
* If you want to merge the column headers into groups you can use
* {@link ColumnGroupRow}s to group columns together and give them a common
* header. See {@link #addColumnGroupRow()} for details.
* </p>
- *
+ *
* <p>
* The header row is by default visible.
* </p>
- *
+ *
* @param visible
* <code>true</code> if header rows should be visible
*/
/**
* Are the column headers visible
- *
+ *
* @return <code>true</code> if they are visible
*/
public boolean isColumnHeadersVisible() {
/**
* Set the column footers visible.
- *
+ *
* <p>
* A column footer is a single cell footer below of each column reserved for
* a specific footer for that column. The column footer can be set by
* {@link GridColumn#setFooterCaption(String)} and column footers cannot be
* merged with other column footers.
* </p>
- *
+ *
* <p>
* All column footers occupy the first footer row of the grid. If you do not
* wish to show the column footers in the grid you should hide the row by
* setting visibility of the footer row to <code>false</code>.
* </p>
- *
+ *
* <p>
* If you want to merge the column footers into groups you can use
* {@link ColumnGroupRow}s to group columns together and give them a common
* footer. See {@link #addColumnGroupRow()} for details.
* </p>
- *
+ *
* <p>
* The footer row is by default hidden.
* </p>
- *
+ *
* @param visible
* <code>true</code> if the footer row should be visible
*/
/**
* Are the column footers visible
- *
+ *
* @return <code>true</code> if they are visible
- *
+ *
*/
public boolean isColumnFootersVisible() {
return columnFootersVisible;
/**
* Adds a new column group row to the grid.
- *
+ *
* <p>
* Column group rows are rendered in the header and footer of the grid.
* Column group rows are made up of column groups which groups together
* columns for adding a common auxiliary header or footer for the columns.
* </p>
- *
+ *
* Example usage:
- *
+ *
* <pre>
* // Add a new column group row to the grid
* ColumnGroupRow row = grid.addColumnGroupRow();
* // Set a common footer for "Column1" and "Column2"
* column12.setFooter("Column 1&2");
* </pre>
- *
+ *
* @return a column group row instance you can use to add column groups
*/
public ColumnGroupRow<T> addColumnGroupRow() {
/**
* Adds a new column group row to the grid at a specific index.
- *
+ *
* @see #addColumnGroupRow() {@link Grid#addColumnGroupRow()} for example
* usage
- *
+ *
* @param rowIndex
* the index where the column group row should be added
* @return a column group row instance you can use to add column groups
/**
* Removes a column group row
- *
+ *
* @param row
* The row to remove
*/
/**
* Get the column group rows
- *
+ *
* @return a unmodifiable list of column group rows
- *
+ *
*/
public List<ColumnGroupRow<T>> getColumnGroupRows() {
return Collections.unmodifiableList(new ArrayList<ColumnGroupRow<T>>(
/**
* Returns the column group for a row and column
- *
+ *
* @param row
* The row of the column
* @param column
* <p>
* <em>Note:</em> This method will change the widget's size in the browser
* only if {@link #getHeightMode()} returns {@link HeightMode#CSS}.
- *
+ *
* @see #setHeightMode(HeightMode)
*/
@Override
/**
* Sets the data source used by this grid.
- *
+ *
* @param dataSource
* the data source to use, not null
* @throws IllegalArgumentException
* <p>
* All columns up to and including the given column will be frozen in place
* when the grid is scrolled sideways.
- *
+ *
* @param lastFrozenColumn
* the rightmost column to freeze, or <code>null</code> to not
* have any columns frozen
* <em>Note:</em> Most usually, this method returns the very value set with
* {@link #setLastFrozenColumn(GridColumn)}. This value, however, can be
* reset to <code>null</code> if the column is removed from this grid.
- *
+ *
* @return the rightmost frozen column in the grid, or <code>null</code> if
* no columns are frozen.
*/
/**
* Scrolls to a certain row, using {@link ScrollDestination#ANY}.
- *
+ *
* @param rowIndex
* zero-based index of the row to scroll to.
* @throws IllegalArgumentException
/**
* Scrolls to a certain row, using user-specified scroll destination.
- *
+ *
* @param rowIndex
* zero-based index of the row to scroll to.
* @param destination
/**
* Scrolls to a certain row using only user-specified parameters.
- *
+ *
* @param rowIndex
* zero-based index of the row to scroll to.
* @param destination
* <p>
* If Grid is currently not in {@link HeightMode#ROW}, the given value is
* remembered, and applied once the mode is applied.
- *
+ *
* @param rows
* The height in terms of number of rows displayed in Grid's
* body. If Grid doesn't contain enough rows, white space is
* infinite}
* @throws IllegalArgumentException
* if {@code rows} is {@link Double#isNaN(double) NaN}
- *
+ *
* @see #setHeightMode(HeightMode)
*/
public void setHeightByRows(double rows) throws IllegalArgumentException {
* {@link #getHeightMode()} is {@link HeightMode#ROW}.
* <p>
* By default, it is {@value Escalator#DEFAULT_HEIGHT_BY_ROWS}.
- *
+ *
* @return the amount of rows that should be shown in Grid's body, while in
* {@link HeightMode#ROW}.
* @see #setHeightByRows(double)
* <em>Note:</em> If headers/footers are inserted or removed, the widget
* will resize itself to still display the required amount of rows in its
* body. It also takes the horizontal scrollbar into account.
- *
+ *
* @param heightMode
* the mode in to which Grid should be set
*/
* Returns the current {@link HeightMode} the Grid is in.
* <p>
* Defaults to {@link HeightMode#CSS}.
- *
+ *
* @return the current HeightMode
*/
public HeightMode getHeightMode() {
RowContainer container = escalator.findRowContainer(e);
if (container != null) {
Cell cell = container.getCell(e);
- Renderer<?> renderer = columns.get(cell.getColumn())
- .getRenderer();
- if (renderer instanceof ComplexRenderer) {
- ((ComplexRenderer<?>) renderer).onBrowserEvent(cell, event);
+ if (cell != null) {
+ GridColumn<?, T> gridColumn = columns.get(cell.getColumn());
+
+ Renderer<?> renderer;
+ if (container == escalator.getHeader()) {
+ renderer = gridColumn.getHeaderRenderer();
+ } else if (container == escalator.getFooter()) {
+ renderer = gridColumn.getFooterRenderer();
+ } else {
+ renderer = gridColumn.getRenderer();
+ }
+
+ if (renderer instanceof ComplexRenderer) {
+ ((ComplexRenderer<?>) renderer).onBrowserEvent(cell,
+ event);
+ }
}
}
}
/**
* Accesses the package private method Widget#setParent()
- *
+ *
* @param widget
* The widget to access
* @param parent
/**
* Sets the current selection model.
- *
+ *
* @param selectionModel
* a selection model implementation.
* @throws IllegalArgumentException
/**
* Gets a reference to the current selection model.
- *
+ *
* @return the currently used SelectionModel instance.
*/
public SelectionModel<T> getSelectionModel() {
* Sets current selection mode.
* <p>
* This is a shorthand method for {@link Grid#setSelectionModel}.
- *
+ *
* @param mode
* a selection mode value
* @see {@link SelectionMode}.
/**
* Test if a row is selected.
- *
+ *
* @param row
* a row object
* @return true, if the current selection model considers the provided row
* Only selection models implementing {@link SelectionModel.Single} and
* {@link SelectionModel.Multi} are supported; for anything else, an
* exception will be thrown.
- *
+ *
* @param row
* a row object
* @return <code>true</code> iff the current selection changed
* Only selection models implementing {@link SelectionModel.Single} and
* {@link SelectionModel.Multi} are supported; for anything else, an
* exception will be thrown.
- *
+ *
* @param row
* a row object
* @return <code>true</code> iff the current selection changed
* Only selection models implementing {@link SelectionModel.Single} are
* valid for this method; for anything else, use the
* {@link Grid#getSelectedRows()} method.
- *
+ *
* @return a selected row reference, or null, if no row is selected
* @throws IllegalStateException
* if the current selection model is not an instance of
/**
* Gets currently selected rows from the current selection model.
- *
+ *
* @return a non-null collection containing all currently selected rows.
*/
public Collection<T> getSelectedRows() {
/**
* Sets the current sort order using the fluid Sort API. Read the
* documentation for {@link Sort} for more information.
- *
+ *
* @param s
* a sort instance
*/
/**
* Sorts the Grid data in ascending order along one column.
- *
+ *
* @param column
* a grid column reference
*/
/**
* Sorts the Grid data along one column.
- *
+ *
* @param column
* a grid column reference
* @param direction
/**
* Sets the sort order to use. Setting this causes the Grid to re-sort
* itself.
- *
+ *
* @param order
* a sort order list. If set to null, the sort order is cleared.
*/
/**
* Get a copy of the current sort order array.
- *
+ *
* @return a copy of the current sort order array
*/
public List<SortOrder> getSortOrder() {
* Register a GWT event handler for a sorting event. This handler gets
* called whenever this Grid needs its data source to provide data sorted in
* a specific order.
- *
+ *
* @param handler
* a sort event handler
* @return the registration for the event
/**
* Missing getDataSource method. TODO: remove this and other duplicates
* after The Merge
- *
+ *
* @return a DataSource reference
*/
public DataSource<T> getDataSource() {
projects / vaadin-framework.git / commitdiff