From 1c1506ef0447b1d979a6adb4d812ae9858f00b67 Mon Sep 17 00:00:00 2001 From: John Ahlroos Date: Tue, 29 Oct 2013 13:44:49 +0200 Subject: Base grid component and column API (#12829, #12830) Change-Id: I6c4eae8a4369e9452dd56e764633cecfe9bf553a --- .../tests/server/component/grid/GridColumns.java | 207 +++++++++++++++++++++ 1 file changed, 207 insertions(+) create mode 100644 server/tests/src/com/vaadin/tests/server/component/grid/GridColumns.java (limited to 'server/tests') diff --git a/server/tests/src/com/vaadin/tests/server/component/grid/GridColumns.java b/server/tests/src/com/vaadin/tests/server/component/grid/GridColumns.java new file mode 100644 index 0000000000..5989d537b4 --- /dev/null +++ b/server/tests/src/com/vaadin/tests/server/component/grid/GridColumns.java @@ -0,0 +1,207 @@ +/* + * Copyright 2000-2013 Vaadin Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.vaadin.tests.server.component.grid; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.fail; + +import java.lang.reflect.Field; +import java.lang.reflect.Method; + +import org.junit.Before; +import org.junit.Test; + +import com.vaadin.data.util.IndexedContainer; +import com.vaadin.server.KeyMapper; +import com.vaadin.shared.ui.grid.GridColumnState; +import com.vaadin.shared.ui.grid.GridState; +import com.vaadin.ui.components.grid.Grid; +import com.vaadin.ui.components.grid.GridColumn; + +public class GridColumns { + + private Grid grid; + + private GridState state; + + private Method getStateMethod; + + private Field columnIdGeneratorField; + + private KeyMapper columnIdMapper; + + @Before + public void setup() throws Exception { + IndexedContainer ds = new IndexedContainer(); + for (int c = 0; c < 10; c++) { + ds.addContainerProperty("column" + c, String.class, ""); + } + grid = new Grid(ds); + + getStateMethod = Grid.class.getDeclaredMethod("getState"); + getStateMethod.setAccessible(true); + + state = (GridState) getStateMethod.invoke(grid); + + columnIdGeneratorField = Grid.class.getDeclaredField("columnKeys"); + columnIdGeneratorField.setAccessible(true); + + columnIdMapper = (KeyMapper) columnIdGeneratorField.get(grid); + } + + @Test + public void testColumnGeneration() throws Exception { + + for (Object propertyId : grid.getContainerDatasource() + .getContainerPropertyIds()) { + + // All property ids should get a column + GridColumn column = grid.getColumn(propertyId); + assertNotNull(column); + + // Property id should be the column header by default + assertEquals(propertyId.toString(), column.getHeaderCaption()); + } + } + + @Test + public void testModifyingColumnProperties() throws Exception { + + // Modify first column + GridColumn column = grid.getColumn("column1"); + assertNotNull(column); + + column.setFooterCaption("CustomFooter"); + assertEquals("CustomFooter", column.getFooterCaption()); + assertEquals(column.getFooterCaption(), + getColumnState("column1").footer); + + column.setHeaderCaption("CustomHeader"); + assertEquals("CustomHeader", column.getHeaderCaption()); + assertEquals(column.getHeaderCaption(), + getColumnState("column1").header); + + column.setVisible(false); + assertFalse(column.isVisible()); + assertFalse(getColumnState("column1").visible); + + column.setVisible(true); + assertTrue(column.isVisible()); + assertTrue(getColumnState("column1").visible); + + column.setWidth(100); + assertEquals(100, column.getWidth()); + assertEquals(column.getWidth(), getColumnState("column1").width); + + column.setWidth(-1); + assertEquals(-1, column.getWidth()); + assertEquals(-1, getColumnState("column1").width); + } + + @Test + public void testRemovingColumn() throws Exception { + + GridColumn column = grid.getColumn("column1"); + assertNotNull(column); + + // Remove column + grid.getContainerDatasource().removeContainerProperty("column1"); + + try { + column.setHeaderCaption("asd"); + fail("Succeeded in modifying a detached column"); + } catch (IllegalStateException ise) { + // Detached state should throw exception + } + + try { + column.setFooterCaption("asd"); + fail("Succeeded in modifying a detached column"); + } catch (IllegalStateException ise) { + // Detached state should throw exception + } + + try { + column.setVisible(false); + fail("Succeeded in modifying a detached column"); + } catch (IllegalStateException ise) { + // Detached state should throw exception + } + + try { + column.setWidth(123); + fail("Succeeded in modifying a detached column"); + } catch (IllegalStateException ise) { + // Detached state should throw exception + } + + assertNull(grid.getColumn("column1")); + assertNull(getColumnState("column1")); + } + + @Test + public void testAddingColumn() { + grid.getContainerDatasource().addContainerProperty("columnX", + String.class, ""); + GridColumn column = grid.getColumn("columnX"); + assertNotNull(column); + } + + @Test + public void testHeaderVisiblility() { + + assertTrue(grid.isHeaderVisible()); + assertTrue(state.headerVisible); + + grid.setHeaderVisible(false); + assertFalse(grid.isHeaderVisible()); + assertFalse(state.headerVisible); + + grid.setHeaderVisible(true); + assertTrue(grid.isHeaderVisible()); + assertTrue(state.headerVisible); + } + + @Test + public void testFooterVisibility() { + + assertTrue(grid.isFooterVisible()); + assertTrue(state.footerVisible); + + grid.setFooterVisible(false); + assertFalse(grid.isFooterVisible()); + assertFalse(state.footerVisible); + + grid.setFooterVisible(true); + assertTrue(grid.isFooterVisible()); + assertTrue(state.footerVisible); + } + + private GridColumnState getColumnState(Object propertyId) { + String columnId = columnIdMapper.key(propertyId); + for (GridColumnState columnState : state.columns) { + if (columnState.id.equals(columnId)) { + return columnState; + } + } + return null; + } + +} -- cgit v1.2.3 From 4caa2f5b6e26ade52a4fba66a0a020b79f9008ea Mon Sep 17 00:00:00 2001 From: John Ahlroos Date: Wed, 6 Nov 2013 10:35:03 +0200 Subject: Multiple headers and footer rows #3153 Change-Id: Iadb0d8b051d0f0ef1303e0d7d740cf476cd81971 --- .../src/com/vaadin/client/ui/grid/ColumnGroup.java | 117 +++++ .../com/vaadin/client/ui/grid/ColumnGroupRow.java | 188 ++++++++ client/src/com/vaadin/client/ui/grid/Grid.java | 482 +++++++++++++++++---- .../com/vaadin/client/ui/grid/GridConnector.java | 92 +++- .../com/vaadin/ui/components/grid/ColumnGroup.java | 141 ++++++ .../vaadin/ui/components/grid/ColumnGroupRow.java | 255 +++++++++++ server/src/com/vaadin/ui/components/grid/Grid.java | 134 +++++- .../com/vaadin/ui/components/grid/GridColumn.java | 15 +- .../tests/server/component/grid/GridColumns.java | 92 +++- .../vaadin/shared/ui/grid/ColumnGroupRowState.java | 46 ++ .../vaadin/shared/ui/grid/ColumnGroupState.java | 45 ++ .../com/vaadin/shared/ui/grid/GridColumnState.java | 6 - .../src/com/vaadin/shared/ui/grid/GridState.java | 12 +- .../tests/components/grid/GridBasicFeatures.java | 149 +++++-- .../tests/components/grid/GridColumnGroups.java | 111 +++++ 15 files changed, 1679 insertions(+), 206 deletions(-) create mode 100644 client/src/com/vaadin/client/ui/grid/ColumnGroup.java create mode 100644 client/src/com/vaadin/client/ui/grid/ColumnGroupRow.java create mode 100644 server/src/com/vaadin/ui/components/grid/ColumnGroup.java create mode 100644 server/src/com/vaadin/ui/components/grid/ColumnGroupRow.java create mode 100644 shared/src/com/vaadin/shared/ui/grid/ColumnGroupRowState.java create mode 100644 shared/src/com/vaadin/shared/ui/grid/ColumnGroupState.java create mode 100644 uitest/src/com/vaadin/tests/components/grid/GridColumnGroups.java (limited to 'server/tests') diff --git a/client/src/com/vaadin/client/ui/grid/ColumnGroup.java b/client/src/com/vaadin/client/ui/grid/ColumnGroup.java new file mode 100644 index 0000000000..c37068def7 --- /dev/null +++ b/client/src/com/vaadin/client/ui/grid/ColumnGroup.java @@ -0,0 +1,117 @@ +/* + * Copyright 2000-2013 Vaadin Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ + +package com.vaadin.client.ui.grid; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; +import java.util.List; + +/** + * Column groups are used to group columns together for adding common auxiliary + * headers and footers. Columns groups are added to {@link ColumnGroupRow + * ColumnGroupRows}. + * + * @since 7.2 + * @author Vaadin Ltd + */ +public class ColumnGroup { + + /** + * The text shown in the header + */ + private String header; + + /** + * The text shown in the footer + */ + private String footer; + + /** + * The columns included in the group when also accounting for subgroup + * columns + */ + private final List columns; + + /** + * The grid associated with the column group + */ + private final Grid grid; + + /** + * Constructs a new column group + */ + ColumnGroup(Grid grid, Collection columns) { + if (columns == null) { + throw new IllegalArgumentException( + "columns cannot be null. Pass an empty list instead."); + } + this.grid = grid; + this.columns = Collections.unmodifiableList(new ArrayList( + columns)); + } + + /** + * Gets the header text. + * + * @return the header text + */ + public String getHeaderCaption() { + return header; + } + + /** + * Sets the text shown in the header. + * + * @param header + * the header to set + */ + public void setHeaderCaption(String header) { + this.header = header; + grid.refreshHeader(); + } + + /** + * Gets the text shown in the footer. + * + * @return the text in the footer + */ + public String getFooterCaption() { + return footer; + } + + /** + * Sets the text displayed in the footer. + * + * @param footer + * the footer to set + */ + public void setFooterCaption(String footer) { + this.footer = footer; + grid.refreshFooter(); + } + + /** + * Returns all column in this group. It includes the subgroups columns as + * well. + * + * @return unmodifiable list of columns + */ + public List getColumns() { + return columns; + } +} diff --git a/client/src/com/vaadin/client/ui/grid/ColumnGroupRow.java b/client/src/com/vaadin/client/ui/grid/ColumnGroupRow.java new file mode 100644 index 0000000000..6bbc9bc9eb --- /dev/null +++ b/client/src/com/vaadin/client/ui/grid/ColumnGroupRow.java @@ -0,0 +1,188 @@ +/* + * Copyright 2000-2013 Vaadin Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ + +package com.vaadin.client.ui.grid; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; +import java.util.HashSet; +import java.util.List; +import java.util.Set; + +/** + * A column group row represents an auxiliary header or footer row added to the + * grid. A column group row includes column groups that group columns together. + * + * @since 7.2 + * @author Vaadin Ltd + */ +public class ColumnGroupRow { + + /** + * The column groups in this row + */ + private List groups = new ArrayList(); + + /** + * The grid associated with the column row + */ + private final Grid grid; + + /** + * Is the header shown + */ + public boolean headerVisible = true; + + /** + * Is the footer shown + */ + public boolean footerVisible = false; + + /** + * Constructs a new column group row + * + * @param grid + * Grid associated with this column + * + */ + ColumnGroupRow(Grid grid) { + this.grid = grid; + } + + /** + * Add a new group to the row by using column instances. + * + * @param columns + * The columns that should belong to the group + * @return a column group representing the collection of columns added to + * the group. + */ + public ColumnGroup addGroup(GridColumn... columns) { + + for (GridColumn column : columns) { + if (isColumnGrouped(column)) { + throw new IllegalArgumentException("Column " + + String.valueOf(column.getHeaderCaption()) + + " already belongs to another group."); + } + } + + ColumnGroup group = new ColumnGroup(grid, Arrays.asList(columns)); + groups.add(group); + grid.refreshHeader(); + grid.refreshFooter(); + return group; + } + + /** + * Add a new group to the row by using other already greated groups + * + * @param groups + * The subgroups of the group. + * @return a column group representing the collection of columns added to + * the group. + * + */ + public ColumnGroup addGroup(ColumnGroup... groups) { + assert groups != null : "groups cannot be null"; + + Set columns = new HashSet(); + for (ColumnGroup group : groups) { + columns.addAll(group.getColumns()); + } + + ColumnGroup group = new ColumnGroup(grid, columns); + this.groups.add(group); + grid.refreshHeader(); + grid.refreshFooter(); + return group; + } + + /** + * Removes a group from the row. + * + * @param group + * The group to remove + */ + public void removeGroup(ColumnGroup group) { + groups.remove(group); + grid.refreshHeader(); + grid.refreshFooter(); + } + + /** + * Get the groups in the row + * + * @return unmodifiable list of groups in this row + */ + public List getGroups() { + return Collections.unmodifiableList(groups); + } + + /** + * Is the header visible for the row. + * + * @return true if header is visible + */ + public boolean isHeaderVisible() { + return headerVisible; + } + + /** + * Sets the header visible for the row. + * + * @param visible + * should the header be shown + */ + public void setHeaderVisible(boolean visible) { + headerVisible = visible; + grid.refreshHeader(); + } + + /** + * Is the footer visible for the row. + * + * @return true if footer is visible + */ + public boolean isFooterVisible() { + return footerVisible; + } + + /** + * Sets the footer visible for the row. + * + * @param visible + * should the footer be shown + */ + public void setFooterVisible(boolean visible) { + footerVisible = visible; + grid.refreshFooter(); + } + + /** + * Iterates all the column groups and checks if the columns alread has been + * added to a group. + */ + private boolean isColumnGrouped(GridColumn column) { + for (ColumnGroup group : groups) { + if (group.getColumns().contains(column)) { + return true; + } + } + return false; + } +} diff --git a/client/src/com/vaadin/client/ui/grid/Grid.java b/client/src/com/vaadin/client/ui/grid/Grid.java index 3c4e2d6e13..67f14301f0 100644 --- a/client/src/com/vaadin/client/ui/grid/Grid.java +++ b/client/src/com/vaadin/client/ui/grid/Grid.java @@ -55,7 +55,7 @@ import com.vaadin.shared.util.SharedUtil; public class Grid extends Composite { /** - * Escalator used internally by the grid to render the rows + * Escalator used internally by grid to render the rows */ private Escalator escalator = GWT.create(Escalator.class); @@ -65,8 +65,23 @@ public class Grid extends Composite { private final List> columns = new ArrayList>(); /** - * Base class for grid columns internally used by the Grid. You should use - * {@link GridColumn} when creating new columns. + * The column groups rows added to the grid + */ + private final List columnGroupRows = new ArrayList(); + + /** + * Are the headers for the columns visible + */ + private boolean columnHeadersVisible = false; + + /** + * Are the footers for the columns visible + */ + private boolean columnFootersVisible = false; + + /** + * Base class for grid columns internally used by the Grid. The user should + * use {@link GridColumn} when creating new columns. * * @param * the row type @@ -74,24 +89,24 @@ public class Grid extends Composite { public static abstract class AbstractGridColumn { /** - * Grid associated with the column + * The grid the column is associated with */ private Grid grid; /** - * Text displayed in the column header + * Should the column be visible in the grid */ - private String header; + private boolean visible; /** - * Text displayed in the column footer + * The text displayed in the header of the column */ - private String footer; + private String header; /** - * Is the column visible + * Text displayed in the column footer */ - private boolean visible; + private String footer; /** * Internally used by the grid to set itself @@ -125,14 +140,15 @@ public class Grid extends Composite { * the text displayed in the column header */ public void setHeaderCaption(String caption) { - if (SharedUtil.equals(caption, this.header)) { + if (SharedUtil.equals(caption, header)) { return; } - this.header = caption; + header = caption; if (grid != null) { grid.refreshHeader(); + } } @@ -153,11 +169,11 @@ public class Grid extends Composite { * the text displayed in the footer of the column */ public void setFooterCaption(String caption) { - if (SharedUtil.equals(caption, this.footer)) { + if (SharedUtil.equals(caption, footer)) { return; } - this.footer = caption; + footer = caption; if (grid != null) { grid.refreshFooter(); @@ -177,7 +193,8 @@ public class Grid extends Composite { * Sets a column as visible in the grid. * * @param visible - * Set to true to show the column in the grid + * true if the column should be displayed in the + * grid */ public void setVisible(boolean visible) { if (this.visible == visible) { @@ -206,8 +223,9 @@ public class Grid extends Composite { * Returns the text that should be displayed in the cell. * * @param row - * the row object that provides the cell content - * @return The cell content of the row + * The row object that provides the cell content. + * + * @return The cell content */ public abstract String getValue(T row); @@ -220,6 +238,122 @@ public class Grid extends Composite { } } + /** + * Base class for header / footer escalator updater + */ + protected abstract class HeaderFooterEscalatorUpdater implements + EscalatorUpdater { + + /** + * The row container which contains the header or footer rows + */ + private RowContainer rows; + + /** + * Should the index be counted from 0-> or 0<- + */ + private boolean inverted; + + /** + * Constructs an updater for updating a header / footer + * + * @param rows + * The row container + * @param inverted + * Should index counting be inverted + */ + public HeaderFooterEscalatorUpdater(RowContainer rows, boolean inverted) { + this.rows = rows; + this.inverted = inverted; + } + + /** + * Gets the header/footer caption value + * + * @return The value that should be rendered for the column caption + */ + public abstract String getColumnValue(GridColumn 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 + */ + public abstract String getGroupValue(ColumnGroup group); + + /** + * Is the row visible in the header/footer + * + * @return true if the row should be visible + */ + public abstract boolean isRowVisible(ColumnGroupRow row); + + /** + * Should the first row be visible + * + * @return true if the first row should be visible + */ + public abstract boolean firstRowIsVisible(); + + @Override + public void updateCells(Row row, List cellsToUpdate) { + + int rowIndex; + if (inverted) { + rowIndex = rows.getRowCount() - row.getRow() - 1; + } else { + rowIndex = row.getRow(); + } + + if (firstRowIsVisible() && rowIndex == 0) { + // column headers + for (Cell cell : cellsToUpdate) { + int columnIndex = cell.getColumn(); + GridColumn column = columns.get(columnIndex); + cell.getElement().setInnerText(getColumnValue(column)); + } + + } else if (columnGroupRows.size() > 0) { + // Adjust for headers + if (firstRowIsVisible()) { + rowIndex--; + } + + // Adjust for previous invisible header rows + ColumnGroupRow groupRow = null; + for (int i = 0, realIndex = 0; i < columnGroupRows.size(); i++) { + groupRow = columnGroupRows.get(i); + if (isRowVisible(groupRow)) { + if (realIndex == rowIndex) { + rowIndex = realIndex; + break; + } + realIndex++; + } + } + + assert groupRow != null; + + for (Cell cell : cellsToUpdate) { + int columnIndex = cell.getColumn(); + GridColumn column = columns.get(columnIndex); + ColumnGroup group = getGroupForColumn(groupRow, column); + + if (group != null) { + // FIXME Should merge the group cells when escalator + // supports it + cell.getElement().setInnerText(getGroupValue(group)); + } else { + // Cells are reused + cell.getElement().setInnerHTML(null); + } + } + } + } + } + /** * Creates a new instance. */ @@ -229,6 +363,9 @@ public class Grid extends Composite { escalator.getHeader().setEscalatorUpdater(createHeaderUpdater()); escalator.getBody().setEscalatorUpdater(createBodyUpdater()); escalator.getFooter().setEscalatorUpdater(createFooterUpdater()); + + refreshHeader(); + refreshFooter(); } /** @@ -238,18 +375,26 @@ public class Grid extends Composite { * @return the updater that updates the data in the escalator. */ private EscalatorUpdater createHeaderUpdater() { - return new EscalatorUpdater() { + return new HeaderFooterEscalatorUpdater(escalator.getHeader(), true) { @Override - public void updateCells(Row row, List cellsToUpdate) { - if (isHeaderVisible()) { - for (Cell cell : cellsToUpdate) { - AbstractGridColumn column = columns.get(cell - .getColumn()); - cell.getElement().setInnerText( - column.getHeaderCaption()); - } - } + public boolean isRowVisible(ColumnGroupRow row) { + return row.isHeaderVisible(); + } + + @Override + public String getGroupValue(ColumnGroup group) { + return group.getHeaderCaption(); + } + + @Override + public String getColumnValue(GridColumn column) { + return column.getHeaderCaption(); + } + + @Override + public boolean firstRowIsVisible() { + return isColumnHeadersVisible(); } }; } @@ -275,40 +420,80 @@ public class Grid extends Composite { * @return the updater that updates the data in the escalator. */ private EscalatorUpdater createFooterUpdater() { - return new EscalatorUpdater() { + return new HeaderFooterEscalatorUpdater(escalator.getFooter(), false) { @Override - public void updateCells(Row row, List cellsToUpdate) { - if (isFooterVisible()) { - for (Cell cell : cellsToUpdate) { - AbstractGridColumn column = columns.get(cell - .getColumn()); - cell.getElement().setInnerText( - column.getFooterCaption()); - } - } + public boolean isRowVisible(ColumnGroupRow row) { + return row.isFooterVisible(); + } + + @Override + public String getGroupValue(ColumnGroup group) { + return group.getFooterCaption(); + } + + @Override + public String getColumnValue(GridColumn column) { + return column.getFooterCaption(); + } + + @Override + public boolean firstRowIsVisible() { + return isColumnFootersVisible(); } }; } /** - * Refreshes all header rows. + * Refreshes header or footer rows on demand + * + * @param rows + * The row container + * @param firstRowIsVisible + * is the first row visible + * @param isHeader + * true if we refreshing the header, else assumed + * the footer */ - private void refreshHeader() { - RowContainer header = escalator.getHeader(); - if (isHeaderVisible() && header.getRowCount() > 0) { - header.refreshRows(0, header.getRowCount()); + private void refreshRowContainer(RowContainer rows, + boolean firstRowIsVisible, boolean isHeader) { + + // Count needed rows + int totalRows = firstRowIsVisible ? 1 : 0; + for (ColumnGroupRow row : columnGroupRows) { + if (isHeader ? row.isHeaderVisible() : row.isFooterVisible()) { + totalRows++; + } + } + + // Add or Remove rows on demand + int rowDiff = totalRows - rows.getRowCount(); + if (rowDiff > 0) { + rows.insertRows(0, rowDiff); + } else if (rowDiff < 0) { + rows.removeRows(0, -rowDiff); + } + + // Refresh all the rows + if (rows.getRowCount() > 0) { + rows.refreshRows(0, rows.getRowCount()); } } /** - * Refreshes all footer rows. + * Refreshes all header rows */ - private void refreshFooter() { - RowContainer footer = escalator.getFooter(); - if (isFooterVisible() && footer.getRowCount() > 0) { - footer.refreshRows(0, footer.getRowCount()); - } + void refreshHeader() { + refreshRowContainer(escalator.getHeader(), isColumnHeadersVisible(), + true); + } + + /** + * Refreshes all footer rows + */ + void refreshFooter() { + refreshRowContainer(escalator.getFooter(), isColumnFootersVisible(), + false); } /** @@ -388,71 +573,200 @@ public class Grid extends Composite { * if the column index does not exist in the grid */ public GridColumn getColumn(int index) throws IllegalArgumentException { - try { - return columns.get(index); - } catch (ArrayIndexOutOfBoundsException aioobe) { - throw new IllegalStateException("Column not found.", aioobe); + if (index < 0 || index >= columns.size()) { + throw new IllegalStateException("Column not found."); } + return columns.get(index); } /** - * Sets the header row visible. + * Set the column headers visible. + * + *

+ * 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. + *

+ * + *

+ * 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 false. + *

+ * + *

+ * 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. + *

+ * + *

+ * The header row is by default visible. + *

* * @param visible - * true if header rows should be visible + * true if header rows should be visible */ - public void setHeaderVisible(boolean visible) { - if (visible == isHeaderVisible()) { + public void setColumnHeadersVisible(boolean visible) { + if (visible == isColumnHeadersVisible()) { return; } - - RowContainer header = escalator.getHeader(); - - // TODO Should support multiple headers - if (visible) { - header.insertRows(0, 1); - } else { - header.removeRows(0, 1); - } + columnHeadersVisible = visible; + refreshHeader(); } /** - * Are the header row(s) visible? + * Are the column headers visible * - * @return true if the header is visible + * @return true if they are visible */ - public boolean isHeaderVisible() { - return escalator.getHeader().getRowCount() > 0; + public boolean isColumnHeadersVisible() { + return columnHeadersVisible; } /** - * Sets the footer row(s) visible. + * Set the column footers visible. + * + *

+ * 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. + *

+ * + *

+ * 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 false. + *

+ * + *

+ * 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. + *

+ * + *

+ * The footer row is by default hidden. + *

* * @param visible - * true if header rows should be visible + * true if the footer row should be visible */ - public void setFooterVisible(boolean visible) { - if (visible == isFooterVisible()) { + public void setColumnFootersVisible(boolean visible) { + if (visible == isColumnFootersVisible()) { return; } + this.columnFootersVisible = visible; + refreshFooter(); + } - RowContainer footer = escalator.getFooter(); + /** + * Are the column footers visible + * + * @return true if they are visible + * + */ + public boolean isColumnFootersVisible() { + return columnFootersVisible; + } - // TODO Should support multiple footers - if (visible) { - footer.insertRows(0, 1); - } else { - footer.removeRows(0, 1); - } + /** + * Adds a new column group row to the grid. + * + *

+ * 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. + *

+ * + * Example usage: + * + * 
+     * // Add a new column group row to the grid
+     * ColumnGroupRow row = grid.addColumnGroupRow();
+     * 
+     * // Group "Column1" and "Column2" together to form a header in the row
+     * ColumnGroup column12 = row.addGroup("Column1", "Column2");
+     * 
+     * // Set a common header for "Column1" and "Column2"
+     * column12.setHeader("Column 1&2");
+     * 
+     * // Set a common footer for "Column1" and "Column2"
+     * column12.setFooter("Column 1&2");
+     *
+ * + * @return a column group row instance you can use to add column groups + */ + public ColumnGroupRow addColumnGroupRow() { + ColumnGroupRow row = new ColumnGroupRow(this); + columnGroupRows.add(row); + refreshHeader(); + refreshFooter(); + return row; + } + + /** + * 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 + */ + public ColumnGroupRow addColumnGroupRow(int rowIndex) { + ColumnGroupRow row = new ColumnGroupRow(this); + columnGroupRows.add(rowIndex, row); + refreshHeader(); + refreshFooter(); + return row; } /** - * Are the footer row(s) visible? + * Removes a column group row * - * @return true if the footer is visible + * @param row + * The row to remove */ - public boolean isFooterVisible() { - return escalator.getFooter().getRowCount() > 0; + public void removeColumnGroupRow(ColumnGroupRow row) { + columnGroupRows.remove(row); + refreshHeader(); + refreshFooter(); + } + + /** + * Get the column group rows + * + * @return a unmodifiable list of column group rows + * + */ + public List getColumnGroupRows() { + return Collections.unmodifiableList(new ArrayList( + columnGroupRows)); + } + + /** + * Returns the column group for a row and column + * + * @param row + * The row of the column + * @param column + * the column to get the group for + * @return A column group for the row and column or null if not + * found. + */ + private static ColumnGroup getGroupForColumn(ColumnGroupRow row, + GridColumn column) { + for (ColumnGroup group : row.getGroups()) { + List columns = group.getColumns(); + if (columns.contains(column)) { + return group; + } + } + return null; } @Override diff --git a/client/src/com/vaadin/client/ui/grid/GridConnector.java b/client/src/com/vaadin/client/ui/grid/GridConnector.java index c48c9936bc..32907e1e29 100644 --- a/client/src/com/vaadin/client/ui/grid/GridConnector.java +++ b/client/src/com/vaadin/client/ui/grid/GridConnector.java @@ -16,15 +16,19 @@ package com.vaadin.client.ui.grid; +import java.util.ArrayList; import java.util.HashMap; import java.util.HashSet; import java.util.Iterator; +import java.util.List; import java.util.Map; import java.util.Set; import com.vaadin.client.communication.StateChangeEvent; import com.vaadin.client.ui.AbstractComponentConnector; import com.vaadin.shared.ui.Connect; +import com.vaadin.shared.ui.grid.ColumnGroupRowState; +import com.vaadin.shared.ui.grid.ColumnGroupState; import com.vaadin.shared.ui.grid.GridColumnState; import com.vaadin.shared.ui.grid.GridState; @@ -38,6 +42,10 @@ import com.vaadin.shared.ui.grid.GridState; @Connect(com.vaadin.ui.components.grid.Grid.class) public class GridConnector extends AbstractComponentConnector { + /** + * Custom implementation of the custom grid column using a String[] to + * represent the cell value + */ private class CustomGridColumn extends GridColumn { @Override @@ -47,7 +55,9 @@ public class GridConnector extends AbstractComponentConnector { } } - // Maps a generated column id -> A grid column instance + /** + * Maps a generated column id to a grid column instance + */ private Map columnIdToColumn = new HashMap(); @Override @@ -71,16 +81,6 @@ public class GridConnector extends AbstractComponentConnector { public void onStateChanged(StateChangeEvent stateChangeEvent) { super.onStateChanged(stateChangeEvent); - // Header - if (stateChangeEvent.hasPropertyChanged("headerVisible")) { - getWidget().setHeaderVisible(getState().headerVisible); - } - - // Footer - if (stateChangeEvent.hasPropertyChanged("footerVisible")) { - getWidget().setFooterVisible(getState().footerVisible); - } - // Column updates if (stateChangeEvent.hasPropertyChanged("columns")) { @@ -92,7 +92,7 @@ public class GridConnector extends AbstractComponentConnector { // Add new columns for (int columnIndex = currentColumns; columnIndex < totalColumns; columnIndex++) { - addColumnFromStateChangeEvent(columnIndex, stateChangeEvent); + addColumnFromStateChangeEvent(columnIndex); } // Update old columns @@ -100,9 +100,26 @@ public class GridConnector extends AbstractComponentConnector { // FIXME Currently updating all column header / footers when a // change in made in one column. When the framework supports // quering a specific item in a list then it should do so here. - updateColumnFromStateChangeEvent(columnIndex, stateChangeEvent); + updateColumnFromStateChangeEvent(columnIndex); } } + + // Header + if (stateChangeEvent.hasPropertyChanged("columnHeadersVisible")) { + getWidget() + .setColumnHeadersVisible(getState().columnHeadersVisible); + } + + // Footer + if (stateChangeEvent.hasPropertyChanged("columnFootersVisible")) { + getWidget() + .setColumnFootersVisible(getState().columnFootersVisible); + } + + // Column row groups + if (stateChangeEvent.hasPropertyChanged("columnGroupRows")) { + updateColumnGroupsFromStateChangeEvent(); + } } /** @@ -110,12 +127,8 @@ public class GridConnector extends AbstractComponentConnector { * * @param columnIndex * The index of the column to update - * @param stateChangeEvent - * The state change event that contains the changes for the - * column */ - private void updateColumnFromStateChangeEvent(int columnIndex, - StateChangeEvent stateChangeEvent) { + private void updateColumnFromStateChangeEvent(int columnIndex) { GridColumn column = getWidget().getColumn(columnIndex); GridColumnState columnState = getState().columns.get(columnIndex); updateColumnFromState(column, columnState); @@ -126,30 +139,30 @@ public class GridConnector extends AbstractComponentConnector { * * @param columnIndex * The index of the column, according to how it - * @param stateChangeEvent */ - private void addColumnFromStateChangeEvent(int columnIndex, - StateChangeEvent stateChangeEvent) { + private void addColumnFromStateChangeEvent(int columnIndex) { GridColumnState state = getState().columns.get(columnIndex); CustomGridColumn column = new CustomGridColumn(); updateColumnFromState(column, state); + columnIdToColumn.put(state.id, column); + getWidget().addColumn(column, columnIndex); } /** - * Updates fields in column from a {@link GridColumnState} DTO + * Updates the column values from a state * * @param column * The column to update * @param state - * The state to update from + * The state to get the data from */ private static void updateColumnFromState(GridColumn column, GridColumnState state) { + column.setVisible(state.visible); column.setHeaderCaption(state.header); column.setFooterCaption(state.footer); - column.setVisible(state.visible); } /** @@ -176,4 +189,35 @@ public class GridConnector extends AbstractComponentConnector { } } } + + /** + * Updates the column groups from a state change + */ + private void updateColumnGroupsFromStateChangeEvent() { + + // FIXME When something changes the header/footer rows will be + // re-created. At some point we should optimize this so partial updates + // can be made on the header/footer. + for (ColumnGroupRow row : getWidget().getColumnGroupRows()) { + getWidget().removeColumnGroupRow(row); + } + + for (ColumnGroupRowState rowState : getState().columnGroupRows) { + ColumnGroupRow row = getWidget().addColumnGroupRow(); + row.setFooterVisible(rowState.footerVisible); + row.setHeaderVisible(rowState.headerVisible); + + for (ColumnGroupState groupState : rowState.groups) { + List columns = new ArrayList(); + for (String columnId : groupState.columns) { + CustomGridColumn column = columnIdToColumn.get(columnId); + columns.add(column); + } + ColumnGroup group = row.addGroup(columns + .toArray(new GridColumn[columns.size()])); + group.setFooterCaption(groupState.footer); + group.setHeaderCaption(groupState.header); + } + } + } } diff --git a/server/src/com/vaadin/ui/components/grid/ColumnGroup.java b/server/src/com/vaadin/ui/components/grid/ColumnGroup.java new file mode 100644 index 0000000000..0ab1f61a46 --- /dev/null +++ b/server/src/com/vaadin/ui/components/grid/ColumnGroup.java @@ -0,0 +1,141 @@ +/* + * Copyright 2000-2013 Vaadin Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ + +package com.vaadin.ui.components.grid; + +import java.io.Serializable; +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; + +import com.vaadin.shared.ui.grid.ColumnGroupState; + +/** + * Column groups are used to group columns together for adding common auxiliary + * headers and footers. Columns groups are added to {@link ColumnGroupRow}'s. + * + * @since 7.2 + * @author Vaadin Ltd + */ +public class ColumnGroup implements Serializable { + + /** + * List of property ids belonging to this group + */ + private List columns; + + /** + * The grid the column group is associated with + */ + private final Grid grid; + + /** + * The common state between the server and the client + */ + private final ColumnGroupState state; + + /** + * Constructs a new column group + * + * @param grid + * the grid the column group is associated with + * @param state + * the state representing the data of the grid. Sent to the + * client + * @param propertyIds + * the property ids of the columns that belongs to the group + * @param groups + * the sub groups who should be included in this group + * + */ + ColumnGroup(Grid grid, ColumnGroupState state, List propertyIds) { + if (propertyIds == null) { + throw new IllegalArgumentException( + "propertyIds cannot be null. Use empty list instead."); + } + + this.state = state; + columns = Collections.unmodifiableList(new ArrayList( + propertyIds)); + this.grid = grid; + } + + /** + * Sets the text displayed in the header of the column group. + * + * @param header + * the text displayed in the header of the column + */ + public void setHeaderCaption(String header) { + state.header = header; + grid.markAsDirty(); + } + + /** + * Sets the text displayed in the header of the column group. + * + * @return the text displayed in the header of the column + */ + public String getHeaderCaption() { + return state.header; + } + + /** + * Sets the text displayed in the footer of the column group. + * + * @param footer + * the text displayed in the footer of the column + */ + public void setFooterCaption(String footer) { + state.footer = footer; + grid.markAsDirty(); + } + + /** + * The text displayed in the footer of the column group. + * + * @return the text displayed in the footer of the column + */ + public String getFooterCaption() { + return state.footer; + } + + /** + * Is a property id in this group or in some sub group of this group. + * + * @param propertyId + * the property id to check for + * @return true if the property id is included in this group. + */ + public boolean isColumnInGroup(Object propertyId) { + if (columns.contains(propertyId)) { + return true; + } + return false; + } + + /** + * Returns a list of property ids where all also the child groups property + * ids are included. + * + * @return a unmodifiable list with all the columns in the group. Includes + * any subgroup columns as well. + */ + public List getColumns() { + return columns; + } + +} diff --git a/server/src/com/vaadin/ui/components/grid/ColumnGroupRow.java b/server/src/com/vaadin/ui/components/grid/ColumnGroupRow.java new file mode 100644 index 0000000000..326d2826f5 --- /dev/null +++ b/server/src/com/vaadin/ui/components/grid/ColumnGroupRow.java @@ -0,0 +1,255 @@ +/* + * Copyright 2000-2013 Vaadin Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ + +package com.vaadin.ui.components.grid; + +import java.io.Serializable; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; +import java.util.List; + +import com.vaadin.server.KeyMapper; +import com.vaadin.shared.ui.grid.ColumnGroupRowState; +import com.vaadin.shared.ui.grid.ColumnGroupState; + +/** + * A column group row represents an auxiliary header or footer row added to the + * grid. A column group row includes column groups that group columns together. + * + * @since 7.2 + * @author Vaadin Ltd + */ +public class ColumnGroupRow implements Serializable { + + /** + * The common state shared between the client and server + */ + private final ColumnGroupRowState state; + + /** + * The column groups in this row + */ + private List groups = new ArrayList(); + + /** + * Grid that the group row belongs to + */ + private final Grid grid; + + /** + * The column keys used to identify the column on the client side + */ + private final KeyMapper columnKeys; + + /** + * Constructs a new column group + * + * @param grid + * The grid that the column group is associated to + * @param state + * The shared state which contains the data shared between server + * and client + * @param columnKeys + * The column key mapper for converting property ids to client + * side column identifiers + */ + ColumnGroupRow(Grid grid, ColumnGroupRowState state, + KeyMapper columnKeys) { + this.grid = grid; + this.columnKeys = columnKeys; + this.state = state; + } + + /** + * Gets the shared state for the column group row. Used internally to send + * the group row to the client. + * + * @return The current state of the row + */ + ColumnGroupRowState getState() { + return state; + } + + /** + * Add a new group to the row by using property ids for the columns. + * + * @param propertyIds + * The property ids of the columns that should be included in the + * group. A column can only belong in group on a row at a time. + * @return a column group representing the collection of columns added to + * the group + */ + public ColumnGroup addGroup(Object... propertyIds) { + assert propertyIds != null : "propertyIds cannot be null."; + + for (Object propertyId : propertyIds) { + if (hasColumnBeenGrouped(propertyId)) { + throw new IllegalArgumentException("Column " + + String.valueOf(propertyId) + + " already belongs to another group."); + } + } + + ColumnGroupState state = new ColumnGroupState(); + for (Object propertyId : propertyIds) { + assert propertyId != null : "null items in columns array not supported."; + state.columns.add(columnKeys.key(propertyId)); + } + this.state.groups.add(state); + + ColumnGroup group = new ColumnGroup(grid, state, + Arrays.asList(propertyIds)); + groups.add(group); + + grid.markAsDirty(); + return group; + } + + /** + * Add a new group to the row by using column instances. + * + * @param columns + * the columns that should belong to the group + * @return a column group representing the collection of columns added to + * the group + */ + public ColumnGroup addGroup(GridColumn... columns) { + assert columns != null : "columns cannot be null"; + + List propertyIds = new ArrayList(); + for (GridColumn column : columns) { + assert column != null : "null items in columns array not supported."; + + String columnId = column.getState().id; + Object propertyId = grid.getPropertyIdByColumnId(columnId); + propertyIds.add(propertyId); + } + return addGroup(propertyIds.toArray()); + } + + /** + * Add a new group to the row by using other already greated groups + * + * @param groups + * the subgroups of the group + * @return a column group representing the collection of columns added to + * the group + * + */ + public ColumnGroup addGroup(ColumnGroup... groups) { + assert groups != null : "groups cannot be null"; + + // Gather all groups columns into one list + List propertyIds = new ArrayList(); + for (ColumnGroup group : groups) { + propertyIds.addAll(group.getColumns()); + } + + ColumnGroupState state = new ColumnGroupState(); + ColumnGroup group = new ColumnGroup(grid, state, propertyIds); + this.groups.add(group); + + // Update state + for (Object propertyId : group.getColumns()) { + state.columns.add(columnKeys.key(propertyId)); + } + this.state.groups.add(state); + + grid.markAsDirty(); + return group; + } + + /** + * Removes a group from the row. Does not remove the group from subgroups, + * to remove it from the subgroup invoke removeGroup on the subgroup. + * + * @param group + * the group to remove + */ + public void removeGroup(ColumnGroup group) { + int index = groups.indexOf(group); + groups.remove(index); + state.groups.remove(index); + grid.markAsDirty(); + } + + /** + * Get the groups in the row. + * + * @return unmodifiable list of groups in this row + */ + public List getGroups() { + return Collections.unmodifiableList(groups); + } + + /** + * Checks if a property id has been added to a group in this row. + * + * @param propertyId + * the property id to check for + * @return true if the column is included in a group + */ + private boolean hasColumnBeenGrouped(Object propertyId) { + for (ColumnGroup group : groups) { + if (group.isColumnInGroup(propertyId)) { + return true; + } + } + return false; + } + + /** + * Is the header visible for the row. + * + * @return true if header is visible + */ + public boolean isHeaderVisible() { + return state.headerVisible; + } + + /** + * Sets the header visible for the row. + * + * @param visible + * should the header be shown + */ + public void setHeaderVisible(boolean visible) { + state.headerVisible = visible; + grid.markAsDirty(); + } + + /** + * Is the footer visible for the row. + * + * @return true if footer is visible + */ + public boolean isFooterVisible() { + return state.footerVisible; + } + + /** + * Sets the footer visible for the row. + * + * @param visible + * should the footer be shown + */ + public void setFooterVisible(boolean visible) { + state.footerVisible = visible; + grid.markAsDirty(); + } + +} diff --git a/server/src/com/vaadin/ui/components/grid/Grid.java b/server/src/com/vaadin/ui/components/grid/Grid.java index 25ac796d47..2b19043d93 100644 --- a/server/src/com/vaadin/ui/components/grid/Grid.java +++ b/server/src/com/vaadin/ui/components/grid/Grid.java @@ -16,7 +16,9 @@ package com.vaadin.ui.components.grid; +import java.util.ArrayList; import java.util.Collection; +import java.util.Collections; import java.util.HashMap; import java.util.HashSet; import java.util.LinkedList; @@ -28,6 +30,7 @@ import com.vaadin.data.Container.PropertySetChangeEvent; import com.vaadin.data.Container.PropertySetChangeListener; import com.vaadin.data.Container.PropertySetChangeNotifier; import com.vaadin.server.KeyMapper; +import com.vaadin.shared.ui.grid.ColumnGroupRowState; import com.vaadin.shared.ui.grid.GridColumnState; import com.vaadin.shared.ui.grid.GridState; import com.vaadin.ui.AbstractComponent; @@ -52,18 +55,26 @@ import com.vaadin.ui.AbstractComponent; */ public class Grid extends AbstractComponent { + /** + * The data source attached to the grid + */ private Container.Indexed datasource; /** - * Property id -> Column instance mapping + * Property id to column instance mapping */ private final Map columns = new HashMap(); /** - * Key generator for column server->client communication + * Key generator for column server-to-client communication */ private final KeyMapper columnKeys = new KeyMapper(); + /** + * The column groups added to the grid + */ + private final List columnGroupRows = new ArrayList(); + /** * Property listener for listening to changes in data source properties. */ @@ -144,11 +155,11 @@ public class Grid extends AbstractComponent { if (!columns.containsKey(propertyId)) { GridColumn column = appendColumn(propertyId); - // By default use property id as column caption + // Add by default property id as column header column.setHeaderCaption(String.valueOf(propertyId)); - } } + } /** @@ -177,27 +188,27 @@ public class Grid extends AbstractComponent { * @param visible * true if the header rows should be visible */ - public void setHeaderVisible(boolean visible) { - getState().headerVisible = visible; + public void setColumnHeadersVisible(boolean visible) { + getState().columnHeadersVisible = visible; } /** * Are the header rows visible? * - * @return true if the header is visible + * @return true if the headers of the columns are visible */ - public boolean isHeaderVisible() { - return getState(false).headerVisible; + public boolean isColumnHeadersVisible() { + return getState(false).columnHeadersVisible; } /** * Sets the footer rows visible. * * @param visible - * true if the header rows should be visible + * true if the footer rows should be visible */ - public void setFooterVisible(boolean visible) { - getState().footerVisible = visible; + public void setColumnFootersVisible(boolean visible) { + getState().columnFootersVisible = visible; } /** @@ -205,25 +216,110 @@ public class Grid extends AbstractComponent { * * @return true if the footer rows should be visible */ - public boolean isFooterVisible() { - return getState(false).footerVisible; + public boolean isColumnFootersVisible() { + return getState(false).columnFootersVisible; + } + + /** + *

+ * Adds a new column group to the grid. + * + *

+ * 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. + *

+ *

+ * + *

+ * Example usage: + * + * 

+     * // Add a new column group row to the grid
+     * ColumnGroupRow row = grid.addColumnGroupRow();
+     * 
+     * // Group "Column1" and "Column2" together to form a header in the row
+     * ColumnGroup column12 = row.addGroup("Column1", "Column2");
+     * 
+     * // Set a common header for "Column1" and "Column2"
+     * column12.setHeader("Column 1&2");
+     *
+ * + *

+ * + * @return a column group instance you can use to add column groups + */ + public ColumnGroupRow addColumnGroupRow() { + ColumnGroupRowState state = new ColumnGroupRowState(); + ColumnGroupRow row = new ColumnGroupRow(this, state, columnKeys); + columnGroupRows.add(row); + getState().columnGroupRows.add(state); + return row; + } + + /** + * Adds a new column group to the grid at a specific index + * + * @param rowIndex + * the index of the row + * @return a column group instance you can use to add column groups + */ + public ColumnGroupRow addColumnGroupRow(int rowIndex) { + ColumnGroupRowState state = new ColumnGroupRowState(); + ColumnGroupRow row = new ColumnGroupRow(this, state, columnKeys); + columnGroupRows.add(rowIndex, row); + getState().columnGroupRows.add(rowIndex, state); + return row; + } + + /** + * Removes a column group. + * + * @param row + * the row to remove + */ + public void removeColumnGroupRow(ColumnGroupRow row) { + columnGroupRows.remove(row); + getState().columnGroupRows.remove(row.getState()); + } + + /** + * Gets the column group rows. + * + * @return an unmodifiable list of column group rows + */ + public List getColumnGroupRows() { + return Collections.unmodifiableList(new ArrayList( + columnGroupRows)); } /** * Used internally by the {@link Grid} to get a {@link GridColumn} by * referencing its generated state id. Also used by {@link GridColumn} to - * verify if it has been detached from the {@link Grid} + * verify if it has been detached from the {@link Grid}. * * @param columnId - * The client id generated for the column when the column is + * the client id generated for the column when the column is * added to the grid - * @return The column with the id or null if not found + * @return the column with the id or null if not found */ GridColumn getColumnByColumnId(String columnId) { - Object propertyId = columnKeys.get(columnId); + Object propertyId = getPropertyIdByColumnId(columnId); return getColumn(propertyId); } + /** + * Used internally by the {@link Grid} to get a property id by referencing + * the columns generated state id. + * + * @param columnId + * The state id of the column + * @return The column instance or null if not found + */ + Object getPropertyIdByColumnId(String columnId) { + return columnKeys.get(columnId); + } + @Override protected GridState getState() { return (GridState) super.getState(); @@ -241,7 +337,7 @@ public class Grid extends AbstractComponent { * @param datasourcePropertyId * The property id of a property in the datasource */ - protected GridColumn appendColumn(Object datasourcePropertyId) { + private GridColumn appendColumn(Object datasourcePropertyId) { if (datasourcePropertyId == null) { throw new IllegalArgumentException("Property id cannot be null"); } diff --git a/server/src/com/vaadin/ui/components/grid/GridColumn.java b/server/src/com/vaadin/ui/components/grid/GridColumn.java index 505919b3cf..dde0669238 100644 --- a/server/src/com/vaadin/ui/components/grid/GridColumn.java +++ b/server/src/com/vaadin/ui/components/grid/GridColumn.java @@ -16,6 +16,8 @@ package com.vaadin.ui.components.grid; +import java.io.Serializable; + import com.vaadin.shared.ui.grid.GridColumnState; /** @@ -25,10 +27,10 @@ import com.vaadin.shared.ui.grid.GridColumnState; * @since 7.2 * @author Vaadin Ltd */ -public class GridColumn { +public class GridColumn implements Serializable { /** - * The shared state of the column + * The state of the column shared to the client */ private final GridColumnState state; @@ -138,9 +140,16 @@ public class GridColumn { * the new pixel width of the column * @throws IllegalStateException * if the column is no longer attached to any grid + * @throws IllegalArgumentException + * thrown if pixel width is less than zero */ - public void setWidth(int pixelWidth) throws IllegalStateException { + public void setWidth(int pixelWidth) throws IllegalStateException, + IllegalArgumentException { checkColumnIsAttached(); + if (pixelWidth < 0) { + throw new IllegalArgumentException( + "Pixel width should be greated than 0"); + } state.width = pixelWidth; grid.markAsDirty(); } diff --git a/server/tests/src/com/vaadin/tests/server/component/grid/GridColumns.java b/server/tests/src/com/vaadin/tests/server/component/grid/GridColumns.java index 5989d537b4..85864160a8 100644 --- a/server/tests/src/com/vaadin/tests/server/component/grid/GridColumns.java +++ b/server/tests/src/com/vaadin/tests/server/component/grid/GridColumns.java @@ -32,6 +32,8 @@ import com.vaadin.data.util.IndexedContainer; import com.vaadin.server.KeyMapper; import com.vaadin.shared.ui.grid.GridColumnState; import com.vaadin.shared.ui.grid.GridState; +import com.vaadin.ui.components.grid.ColumnGroup; +import com.vaadin.ui.components.grid.ColumnGroupRow; import com.vaadin.ui.components.grid.Grid; import com.vaadin.ui.components.grid.GridColumn; @@ -110,9 +112,15 @@ public class GridColumns { assertEquals(100, column.getWidth()); assertEquals(column.getWidth(), getColumnState("column1").width); - column.setWidth(-1); - assertEquals(-1, column.getWidth()); - assertEquals(-1, getColumnState("column1").width); + try { + column.setWidth(-1); + fail("Setting width to -1 should throw exception"); + } catch (IllegalArgumentException iae) { + + } + + assertEquals(100, column.getWidth()); + assertEquals(100, getColumnState("column1").width); } @Test @@ -126,6 +134,7 @@ public class GridColumns { try { column.setHeaderCaption("asd"); + fail("Succeeded in modifying a detached column"); } catch (IllegalStateException ise) { // Detached state should throw exception @@ -157,7 +166,7 @@ public class GridColumns { } @Test - public void testAddingColumn() { + public void testAddingColumn() throws Exception { grid.getContainerDatasource().addContainerProperty("columnX", String.class, ""); GridColumn column = grid.getColumn("columnX"); @@ -165,33 +174,72 @@ public class GridColumns { } @Test - public void testHeaderVisiblility() { + public void testHeaderVisiblility() throws Exception { - assertTrue(grid.isHeaderVisible()); - assertTrue(state.headerVisible); + assertTrue(grid.isColumnHeadersVisible()); + assertTrue(state.columnHeadersVisible); - grid.setHeaderVisible(false); - assertFalse(grid.isHeaderVisible()); - assertFalse(state.headerVisible); + grid.setColumnHeadersVisible(false); + assertFalse(grid.isColumnHeadersVisible()); + assertFalse(state.columnHeadersVisible); - grid.setHeaderVisible(true); - assertTrue(grid.isHeaderVisible()); - assertTrue(state.headerVisible); + grid.setColumnHeadersVisible(true); + assertTrue(grid.isColumnHeadersVisible()); + assertTrue(state.columnHeadersVisible); } @Test - public void testFooterVisibility() { + public void testFooterVisibility() throws Exception { + + assertFalse(grid.isColumnFootersVisible()); + assertFalse(state.columnFootersVisible); - assertTrue(grid.isFooterVisible()); - assertTrue(state.footerVisible); + grid.setColumnFootersVisible(false); + assertFalse(grid.isColumnFootersVisible()); + assertFalse(state.columnFootersVisible); - grid.setFooterVisible(false); - assertFalse(grid.isFooterVisible()); - assertFalse(state.footerVisible); + grid.setColumnFootersVisible(true); + assertTrue(grid.isColumnFootersVisible()); + assertTrue(state.columnFootersVisible); + } - grid.setFooterVisible(true); - assertTrue(grid.isFooterVisible()); - assertTrue(state.footerVisible); + @Test + public void testColumnGroups() throws Exception { + + // Add a new row + ColumnGroupRow row = grid.addColumnGroupRow(); + assertTrue(state.columnGroupRows.size() == 1); + + // Add a group by property id + ColumnGroup columns12 = row.addGroup("column1", "column2"); + assertTrue(state.columnGroupRows.get(0).groups.size() == 1); + + // Set header of column + columns12.setHeaderCaption("Column12"); + assertEquals("Column12", + state.columnGroupRows.get(0).groups.get(0).header); + + // Set footer of column + columns12.setFooterCaption("Footer12"); + assertEquals("Footer12", + state.columnGroupRows.get(0).groups.get(0).footer); + + // Add another group by column instance + ColumnGroup columns34 = row.addGroup(grid.getColumn("column3"), + grid.getColumn("column4")); + assertTrue(state.columnGroupRows.get(0).groups.size() == 2); + + // add another group row + ColumnGroupRow row2 = grid.addColumnGroupRow(); + assertTrue(state.columnGroupRows.size() == 2); + + // add a group by combining the two previous groups + ColumnGroup columns1234 = row2.addGroup(columns12, columns34); + assertTrue(columns1234.getColumns().size() == 4); + + // Insert a group as the second group + ColumnGroupRow newRow2 = grid.addColumnGroupRow(1); + assertTrue(state.columnGroupRows.size() == 3); } private GridColumnState getColumnState(Object propertyId) { diff --git a/shared/src/com/vaadin/shared/ui/grid/ColumnGroupRowState.java b/shared/src/com/vaadin/shared/ui/grid/ColumnGroupRowState.java new file mode 100644 index 0000000000..a8e0f87457 --- /dev/null +++ b/shared/src/com/vaadin/shared/ui/grid/ColumnGroupRowState.java @@ -0,0 +1,46 @@ +/* + * Copyright 2000-2013 Vaadin Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ + +package com.vaadin.shared.ui.grid; + +import java.io.Serializable; +import java.util.ArrayList; +import java.util.List; + +/** + * The column group row data shared between the server and client + * + * @since 7.2 + * @author Vaadin Ltd + */ +public class ColumnGroupRowState implements Serializable { + + /** + * The groups that has been added to the row + */ + public List groups = new ArrayList(); + + /** + * Is the header shown + */ + public boolean headerVisible = true; + + /** + * Is the footer shown + */ + public boolean footerVisible = false; + +} diff --git a/shared/src/com/vaadin/shared/ui/grid/ColumnGroupState.java b/shared/src/com/vaadin/shared/ui/grid/ColumnGroupState.java new file mode 100644 index 0000000000..3992b6611f --- /dev/null +++ b/shared/src/com/vaadin/shared/ui/grid/ColumnGroupState.java @@ -0,0 +1,45 @@ +/* + * Copyright 2000-2013 Vaadin Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ + +package com.vaadin.shared.ui.grid; + +import java.io.Serializable; +import java.util.ArrayList; +import java.util.List; + +/** + * The column group data shared between the server and the client + * + * @since 7.2 + * @author Vaadin Ltd + */ +public class ColumnGroupState implements Serializable { + + /** + * The columns that is included in the group + */ + public List columns = new ArrayList(); + + /** + * The header text of the group + */ + public String header; + + /** + * The footer text of the group + */ + public String footer; +} diff --git a/shared/src/com/vaadin/shared/ui/grid/GridColumnState.java b/shared/src/com/vaadin/shared/ui/grid/GridColumnState.java index 391eb2a65c..0301c5ead2 100644 --- a/shared/src/com/vaadin/shared/ui/grid/GridColumnState.java +++ b/shared/src/com/vaadin/shared/ui/grid/GridColumnState.java @@ -34,17 +34,11 @@ public class GridColumnState implements Serializable { /** * Header caption for the column - * - * FIXME Only single header currently supported. Should support many - * headers. */ public String header; /** * Footer caption for the column - * - * FIXME Only single footer currently supported. Should support many - * footers. */ public String footer; diff --git a/shared/src/com/vaadin/shared/ui/grid/GridState.java b/shared/src/com/vaadin/shared/ui/grid/GridState.java index e1e0fff354..d1167f3d4f 100644 --- a/shared/src/com/vaadin/shared/ui/grid/GridState.java +++ b/shared/src/com/vaadin/shared/ui/grid/GridState.java @@ -40,13 +40,17 @@ public class GridState extends AbstractComponentState { public List columns = new ArrayList(); /** - * Are the header row(s) visible. By default they are visible. + * Is the column header row visible */ - public boolean headerVisible = true; + public boolean columnHeadersVisible = true; /** - * Are the footer row(s) visible. By default they are visible. + * Is the column footer row visible */ - public boolean footerVisible = true; + public boolean columnFootersVisible = false; + /** + * The column groups added to the grid + */ + public List columnGroupRows = new ArrayList(); } diff --git a/uitest/src/com/vaadin/tests/components/grid/GridBasicFeatures.java b/uitest/src/com/vaadin/tests/components/grid/GridBasicFeatures.java index 5b3d742f19..bd3e96f84a 100644 --- a/uitest/src/com/vaadin/tests/components/grid/GridBasicFeatures.java +++ b/uitest/src/com/vaadin/tests/components/grid/GridBasicFeatures.java @@ -19,6 +19,8 @@ import java.util.ArrayList; import com.vaadin.data.util.IndexedContainer; import com.vaadin.tests.components.AbstractComponentTest; +import com.vaadin.ui.components.grid.ColumnGroup; +import com.vaadin.ui.components.grid.ColumnGroupRow; import com.vaadin.ui.components.grid.Grid; import com.vaadin.ui.components.grid.GridColumn; @@ -32,6 +34,8 @@ public class GridBasicFeatures extends AbstractComponentTest { private final int COLUMNS = 10; + private int columnGroupRows = 0; + @Override protected Grid constructComponent() { @@ -42,20 +46,51 @@ public class GridBasicFeatures extends AbstractComponentTest { ds.addContainerProperty("Column" + col, String.class, ""); } + // Create grid Grid grid = new Grid(ds); - // Headers and footers + // Add footer values (header values are automatically created) for (int col = 0; col < COLUMNS; col++) { - GridColumn column = grid.getColumn("Column" + col); - column.setHeaderCaption("Column " + col); - column.setFooterCaption("Footer " + col); + grid.getColumn("Column" + col).setFooterCaption("Footer " + col); } createColumnActions(); + createHeaderActions(); + + createFooterActions(); + + createColumnGroupActions(); + return grid; } + protected void createHeaderActions() { + createCategory("Headers", null); + + createBooleanAction("Visible", "Headers", true, + new Command() { + + @Override + public void execute(Grid grid, Boolean value, Object data) { + grid.setColumnHeadersVisible(value); + } + }); + } + + protected void createFooterActions() { + createCategory("Footers", null); + + createBooleanAction("Visible", "Footers", false, + new Command() { + + @Override + public void execute(Grid grid, Boolean value, Object data) { + grid.setColumnFootersVisible(value); + } + }); + } + protected void createColumnActions() { createCategory("Columns", null); @@ -77,46 +112,6 @@ public class GridBasicFeatures extends AbstractComponentTest { } }, c); - createBooleanAction("Footer", "Column" + c, true, - new Command() { - - @Override - public void execute(Grid grid, Boolean value, - Object columnIndex) { - Object propertyId = (new ArrayList(grid - .getContainerDatasource() - .getContainerPropertyIds()) - .get((Integer) columnIndex)); - GridColumn column = grid.getColumn(propertyId); - String footer = column.getFooterCaption(); - if (footer == null) { - column.setFooterCaption("Footer " + columnIndex); - } else { - column.setFooterCaption(null); - } - } - }, c); - - createBooleanAction("Header", "Column" + c, true, - new Command() { - - @Override - public void execute(Grid grid, Boolean value, - Object columnIndex) { - Object propertyId = (new ArrayList(grid - .getContainerDatasource() - .getContainerPropertyIds()) - .get((Integer) columnIndex)); - GridColumn column = grid.getColumn(propertyId); - String header = column.getHeaderCaption(); - if (header == null) { - column.setHeaderCaption("Column " + columnIndex); - } else { - column.setHeaderCaption(null); - } - } - }, c); - createClickAction("Remove", "Column" + c, new Command() { @@ -131,6 +126,72 @@ public class GridBasicFeatures extends AbstractComponentTest { } + protected void createColumnGroupActions() { + createCategory("Column groups", null); + + createClickAction("Add group row", "Column groups", + new Command() { + + @Override + public void execute(Grid grid, String value, Object data) { + final ColumnGroupRow row = grid.addColumnGroupRow(); + columnGroupRows++; + createCategory("Column group row " + columnGroupRows, + "Column groups"); + + createBooleanAction("Header Visible", + "Column group row " + columnGroupRows, true, + new Command() { + + @Override + public void execute(Grid grid, + Boolean value, Object columnIndex) { + row.setHeaderVisible(value); + } + }, row); + + createBooleanAction("Footer Visible", + "Column group row " + columnGroupRows, false, + new Command() { + + @Override + public void execute(Grid grid, + Boolean value, Object columnIndex) { + row.setFooterVisible(value); + } + }, row); + + for (int i = 0; i < COLUMNS; i += 2) { + final int columnIndex = i; + createClickAction("Group Column " + columnIndex + + " & " + (columnIndex + 1), + "Column group row " + columnGroupRows, + new Command() { + + @Override + public void execute(Grid c, + Integer value, Object data) { + final ColumnGroup group = row + .addGroup( + "Column" + value, + "Column" + + (value + 1)); + + group.setHeaderCaption("Column " + + value + " & " + + (value + 1)); + + group.setFooterCaption("Column " + + value + " & " + + (value + 1)); + } + }, i, row); + } + } + }, null, null); + + } + @Override protected Integer getTicketNumber() { return 12829; diff --git a/uitest/src/com/vaadin/tests/components/grid/GridColumnGroups.java b/uitest/src/com/vaadin/tests/components/grid/GridColumnGroups.java new file mode 100644 index 0000000000..66e7651f76 --- /dev/null +++ b/uitest/src/com/vaadin/tests/components/grid/GridColumnGroups.java @@ -0,0 +1,111 @@ +/* + * Copyright 2000-2013 Vaadin Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ + +/** + * + */ +package com.vaadin.tests.components.grid; + +import com.vaadin.data.util.IndexedContainer; +import com.vaadin.server.VaadinRequest; +import com.vaadin.tests.components.AbstractTestUI; +import com.vaadin.ui.components.grid.ColumnGroup; +import com.vaadin.ui.components.grid.ColumnGroupRow; +import com.vaadin.ui.components.grid.Grid; +import com.vaadin.ui.components.grid.GridColumn; + +/** + * + * @since + * @author Vaadin Ltd + */ +public class GridColumnGroups extends AbstractTestUI { + + private final int COLUMNS = 4; + + @Override + protected void setup(VaadinRequest request) { + + // Setup grid + IndexedContainer ds = new IndexedContainer(); + for (int col = 0; col < COLUMNS; col++) { + ds.addContainerProperty("Column" + col, String.class, ""); + } + Grid grid = new Grid(ds); + addComponent(grid); + + /*- + * --------------------------------------------- + * | Header 1 | <- Auxiliary row 2 + * |-------------------------------------------| + * | Header 2 | Header 3 | <- Auxiliary row 1 + * |-------------------------------------------| + * | Column 1 | Column 2 | Column 3 | Column 4 | <- Column headers + * --------------------------------------------| + * | ... | ... | ... | ... | + * | ... | ... | ... | ... | + * --------------------------------------------| + * | Column 1 | Column 2 | Column 3 | Column 4 | <- Column footers + * --------------------------------------------| + * | Footer 2 | Footer 3 | <- Auxiliary row 1 + * --------------------------------------------| + * | Footer 1 | <- Auxiliary row 2 + * --------------------------------------------- + -*/ + + // Set column footers (headers are generated automatically) + grid.setColumnFootersVisible(true); + for (Object propertyId : ds.getContainerPropertyIds()) { + GridColumn column = grid.getColumn(propertyId); + column.setFooterCaption(String.valueOf(propertyId)); + } + + // First auxiliary row + ColumnGroupRow auxRow1 = grid.addColumnGroupRow(); + + // Using property id to create a column group + ColumnGroup columns12 = auxRow1.addGroup("Column0", "Column1"); + columns12.setHeaderCaption("Header 2"); + columns12.setFooterCaption("Footer 2"); + + // Using grid columns to create a column group + GridColumn column3 = grid.getColumn("Column2"); + GridColumn column4 = grid.getColumn("Column3"); + ColumnGroup columns34 = auxRow1.addGroup(column3, column4); + columns34.setHeaderCaption("Header 3"); + columns34.setFooterCaption("Footer 3"); + + // Second auxiliary row + ColumnGroupRow auxRow2 = grid.addColumnGroupRow(); + + // Using previous groups to create a column group + ColumnGroup columns1234 = auxRow2.addGroup(columns12, columns34); + columns1234.setHeaderCaption("Header 1"); + columns1234.setFooterCaption("Footer 1"); + + } + + @Override + protected String getTestDescription() { + return "Grid should support headers and footer groups"; + } + + @Override + protected Integer getTicketNumber() { + return 12894; + } + +} -- cgit v1.2.3 From cff79054fb76f472eaf3d53d4da27fff6d1a95f7 Mon Sep 17 00:00:00 2001 From: Henrik Paul Date: Sun, 24 Nov 2013 16:38:16 +0200 Subject: Add server-side API for column freezing (#3087) Change-Id: I4704ab2bd2b1af31b4586e26cf89f03d97f136a4 --- client/src/com/vaadin/client/ui/grid/Grid.java | 60 ++++++++++++++++ .../com/vaadin/client/ui/grid/GridConnector.java | 12 ++++ server/src/com/vaadin/ui/components/grid/Grid.java | 82 ++++++++++++++++++++++ .../com/vaadin/ui/components/grid/GridColumn.java | 12 ++++ .../tests/server/component/grid/GridColumns.java | 14 ++++ .../src/com/vaadin/shared/ui/grid/GridState.java | 8 +++ .../tests/components/grid/GridBasicFeatures.java | 9 +++ 7 files changed, 197 insertions(+) (limited to 'server/tests') diff --git a/client/src/com/vaadin/client/ui/grid/Grid.java b/client/src/com/vaadin/client/ui/grid/Grid.java index d76424ae31..90c8b60474 100644 --- a/client/src/com/vaadin/client/ui/grid/Grid.java +++ b/client/src/com/vaadin/client/ui/grid/Grid.java @@ -83,6 +83,8 @@ public class Grid extends Composite { */ private boolean columnFootersVisible = false; + private GridColumn lastFrozenColumn; + /** * Base class for grid columns internally used by the Grid. The user should * use {@link GridColumn} when creating new columns. @@ -560,6 +562,12 @@ public class Grid extends Composite { ColumnConfiguration conf = escalator.getColumnConfiguration(); conf.insertColumns(index, 1); + + if (lastFrozenColumn != null + && ((AbstractGridColumn) lastFrozenColumn) + .findIndexOfColumn() < index) { + refreshFrozenColumns(); + } } /** @@ -578,6 +586,12 @@ public class Grid extends Composite { ColumnConfiguration conf = escalator.getColumnConfiguration(); conf.removeColumns(columnIndex, 1); + + if (column.equals(lastFrozenColumn)) { + setLastFrozenColumn(null); + } else { + refreshFrozenColumns(); + } } /** @@ -861,4 +875,50 @@ public class Grid extends Composite { escalator.getBody().insertRows(0, estimatedSize); } } + + /** + * Sets the rightmost frozen column in the grid. + *

+ * 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 null to not + * have any columns frozen + * @throws IllegalArgumentException + * if {@code lastFrozenColumn} is not a column from this grid + */ + public void setLastFrozenColumn(GridColumn lastFrozenColumn) { + this.lastFrozenColumn = lastFrozenColumn; + refreshFrozenColumns(); + } + + private void refreshFrozenColumns() { + final int frozenCount; + if (lastFrozenColumn != null) { + frozenCount = columns.indexOf(lastFrozenColumn) + 1; + if (frozenCount == 0) { + throw new IllegalArgumentException( + "The given column isn't attached to this grid"); + } + } else { + frozenCount = 0; + } + + escalator.getColumnConfiguration().setFrozenColumnCount(frozenCount); + } + + /** + * Gets the rightmost frozen column in the grid. + *

+ * Note: Most usually, this method returns the very value set with + * {@link #setLastFrozenColumn(GridColumn)}. This value, however, can be + * reset to null if the column is removed from this grid. + * + * @return the rightmost frozen column in the grid, or null if + * no columns are frozen. + */ + public GridColumn getLastFrozenColumn() { + return lastFrozenColumn; + } } diff --git a/client/src/com/vaadin/client/ui/grid/GridConnector.java b/client/src/com/vaadin/client/ui/grid/GridConnector.java index 896a9998fb..befbc5a50b 100644 --- a/client/src/com/vaadin/client/ui/grid/GridConnector.java +++ b/client/src/com/vaadin/client/ui/grid/GridConnector.java @@ -125,6 +125,18 @@ public class GridConnector extends AbstractComponentConnector { if (stateChangeEvent.hasPropertyChanged("columnGroupRows")) { updateColumnGroupsFromStateChangeEvent(); } + + if (stateChangeEvent.hasPropertyChanged("lastFrozenColumnId")) { + String frozenColId = getState().lastFrozenColumnId; + if (frozenColId != null) { + CustomGridColumn column = columnIdToColumn.get(frozenColId); + assert column != null : "Column to be frozen could not be found (id:" + + frozenColId + ")"; + getWidget().setLastFrozenColumn(column); + } else { + getWidget().setLastFrozenColumn(null); + } + } } /** diff --git a/server/src/com/vaadin/ui/components/grid/Grid.java b/server/src/com/vaadin/ui/components/grid/Grid.java index 79cc05e1a0..1fb0692104 100644 --- a/server/src/com/vaadin/ui/components/grid/Grid.java +++ b/server/src/com/vaadin/ui/components/grid/Grid.java @@ -105,6 +105,12 @@ public class Grid extends AbstractComponent { appendColumn(propertyId); } } + + Object frozenPropertyId = columnKeys + .get(getState(false).lastFrozenColumnId); + if (!columns.containsKey(frozenPropertyId)) { + setLastFrozenPropertyId(null); + } } }; @@ -158,6 +164,7 @@ public class Grid extends AbstractComponent { } getState().columns.clear(); + setLastFrozenPropertyId(null); // Add columns for (Object propertyId : datasource.getContainerPropertyIds()) { @@ -362,4 +369,79 @@ public class Grid extends AbstractComponent { return column; } + + /** + * Sets (or unsets) the rightmost frozen column in the grid. + *

+ * 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 null to not + * have any columns frozen + * @throws IllegalArgumentException + * if {@code lastFrozenColumn} is not a column from this grid + */ + void setLastFrozenColumn(GridColumn lastFrozenColumn) { + /* + * TODO: If and when Grid supports column reordering or insertion of + * columns before other columns, make sure to mention that adding + * columns before lastFrozenColumn will change the frozen column count + */ + + if (lastFrozenColumn == null) { + getState().lastFrozenColumnId = null; + } else if (columns.containsValue(lastFrozenColumn)) { + getState().lastFrozenColumnId = lastFrozenColumn.getState().id; + } else { + throw new IllegalArgumentException( + "The given column isn't attached to this grid"); + } + } + + /** + * Sets (or unsets) the rightmost frozen column in the grid. + *

+ * All columns up to and including the indicated property will be frozen in + * place when the grid is scrolled sideways. + *

+ * Note: If the container used by this grid supports a propertyId + * null, it can never be defined as the last frozen column, as + * a null parameter will always reset the frozen columns in + * Grid. + * + * @param propertyId + * the property id corresponding to the column that should be the + * last frozen column, or null to not have any + * columns frozen. + * @throws IllegalArgumentException + * if {@code lastFrozenColumn} is not a column from this grid + */ + public void setLastFrozenPropertyId(Object propertyId) { + final GridColumn column; + if (propertyId == null) { + column = null; + } else { + column = getColumn(propertyId); + if (column == null) { + throw new IllegalArgumentException( + "property id does not exist."); + } + } + setLastFrozenColumn(column); + } + + /** + * Gets the rightmost frozen column in the grid. + *

+ * Note: Most often, this method returns the very value set with + * {@link #setLastFrozenPropertyId(Object)}. This value, however, can be + * reset to null if the column is detached from this grid. + * + * @return the rightmost frozen column in the grid, or null if + * no columns are frozen. + */ + public Object getLastFrozenPropertyId() { + return columnKeys.get(getState().lastFrozenColumnId); + } } diff --git a/server/src/com/vaadin/ui/components/grid/GridColumn.java b/server/src/com/vaadin/ui/components/grid/GridColumn.java index dde0669238..8dae9428e5 100644 --- a/server/src/com/vaadin/ui/components/grid/GridColumn.java +++ b/server/src/com/vaadin/ui/components/grid/GridColumn.java @@ -192,4 +192,16 @@ public class GridColumn implements Serializable { throw new IllegalStateException("Column no longer exists."); } } + + /** + * Sets this column as the last frozen column in its grid. + * + * @throws IllegalArgumentException + * if the column is no longer attached to any grid + * @see Grid#setLastFrozenColumn(GridColumn) + */ + public void setLastFrozenColumn() { + checkColumnIsAttached(); + grid.setLastFrozenColumn(this); + } } diff --git a/server/tests/src/com/vaadin/tests/server/component/grid/GridColumns.java b/server/tests/src/com/vaadin/tests/server/component/grid/GridColumns.java index 85864160a8..c129db0264 100644 --- a/server/tests/src/com/vaadin/tests/server/component/grid/GridColumns.java +++ b/server/tests/src/com/vaadin/tests/server/component/grid/GridColumns.java @@ -242,6 +242,20 @@ public class GridColumns { assertTrue(state.columnGroupRows.size() == 3); } + @Test + public void testFrozenColumnByPropertyId() { + assertNull("Grid should not start with a frozen column", + grid.getLastFrozenPropertyId()); + + Object propertyId = grid.getContainerDatasource() + .getContainerPropertyIds().iterator().next(); + grid.setLastFrozenPropertyId(propertyId); + assertEquals(propertyId, grid.getLastFrozenPropertyId()); + + grid.getContainerDatasource().removeContainerProperty(propertyId); + assertNull(grid.getLastFrozenPropertyId()); + } + private GridColumnState getColumnState(Object propertyId) { String columnId = columnIdMapper.key(propertyId); for (GridColumnState columnState : state.columns) { diff --git a/shared/src/com/vaadin/shared/ui/grid/GridState.java b/shared/src/com/vaadin/shared/ui/grid/GridState.java index d1167f3d4f..93e602a539 100644 --- a/shared/src/com/vaadin/shared/ui/grid/GridState.java +++ b/shared/src/com/vaadin/shared/ui/grid/GridState.java @@ -53,4 +53,12 @@ public class GridState extends AbstractComponentState { * The column groups added to the grid */ public List columnGroupRows = new ArrayList(); + + /** + * The id for the last frozen column. + * + * @see GridColumnState#id + */ + public String lastFrozenColumnId = null; + } diff --git a/uitest/src/com/vaadin/tests/components/grid/GridBasicFeatures.java b/uitest/src/com/vaadin/tests/components/grid/GridBasicFeatures.java index 7bf5d65e8b..afc9f91e68 100644 --- a/uitest/src/com/vaadin/tests/components/grid/GridBasicFeatures.java +++ b/uitest/src/com/vaadin/tests/components/grid/GridBasicFeatures.java @@ -133,6 +133,15 @@ public class GridBasicFeatures extends AbstractComponentTest { } }, null, c); + createClickAction("Freeze", "Column" + c, + new Command() { + + @Override + public void execute(Grid grid, String value, Object data) { + grid.setLastFrozenPropertyId("Column" + data); + } + }, null, c); + } } -- cgit v1.2.3 From a512c349efed5caf6ad4b0ed585a7bc1f912d5f2 Mon Sep 17 00:00:00 2001 From: John Ahlroos Date: Mon, 25 Nov 2013 13:32:54 +0200 Subject: Added JUnit tests for column groups #3153 Change-Id: I49c6fb59454a0aba3d2399c40a9b6b8c00667a71 --- .../server/component/grid/GridColumnGroups.java | 211 +++++++++++++++++++++ .../tests/server/component/grid/GridColumns.java | 41 ---- 2 files changed, 211 insertions(+), 41 deletions(-) create mode 100644 server/tests/src/com/vaadin/tests/server/component/grid/GridColumnGroups.java (limited to 'server/tests') diff --git a/server/tests/src/com/vaadin/tests/server/component/grid/GridColumnGroups.java b/server/tests/src/com/vaadin/tests/server/component/grid/GridColumnGroups.java new file mode 100644 index 0000000000..cf1ee14437 --- /dev/null +++ b/server/tests/src/com/vaadin/tests/server/component/grid/GridColumnGroups.java @@ -0,0 +1,211 @@ +/* + * Copyright 2000-2013 Vaadin Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.vaadin.tests.server.component.grid; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertTrue; + +import java.lang.reflect.Field; +import java.lang.reflect.Method; +import java.util.List; + +import org.junit.Before; +import org.junit.Test; + +import com.vaadin.data.util.IndexedContainer; +import com.vaadin.server.KeyMapper; +import com.vaadin.shared.ui.grid.GridState; +import com.vaadin.ui.components.grid.ColumnGroup; +import com.vaadin.ui.components.grid.ColumnGroupRow; +import com.vaadin.ui.components.grid.Grid; + +/** + * + * @since + * @author Vaadin Ltd + */ +public class GridColumnGroups { + + private Grid grid; + + private GridState state; + + private Method getStateMethod; + + private Field columnIdGeneratorField; + + private KeyMapper columnIdMapper; + + @Before + public void setup() throws Exception { + IndexedContainer ds = new IndexedContainer(); + for (int c = 0; c < 10; c++) { + ds.addContainerProperty("column" + c, String.class, ""); + } + grid = new Grid(ds); + + getStateMethod = Grid.class.getDeclaredMethod("getState"); + getStateMethod.setAccessible(true); + + state = (GridState) getStateMethod.invoke(grid); + + columnIdGeneratorField = Grid.class.getDeclaredField("columnKeys"); + columnIdGeneratorField.setAccessible(true); + + columnIdMapper = (KeyMapper) columnIdGeneratorField.get(grid); + } + + @Test + public void testColumnGroupRows() throws Exception { + + // No column group rows by default + List rows = grid.getColumnGroupRows(); + assertEquals(0, rows.size()); + + // Add some rows + ColumnGroupRow row1 = grid.addColumnGroupRow(); + ColumnGroupRow row3 = grid.addColumnGroupRow(); + ColumnGroupRow row2 = grid.addColumnGroupRow(1); + + rows = grid.getColumnGroupRows(); + assertEquals(3, rows.size()); + assertEquals(row1, rows.get(0)); + assertEquals(row2, rows.get(1)); + assertEquals(row3, rows.get(2)); + + // Header should be visible by default, footer should not + assertTrue(row1.isHeaderVisible()); + assertFalse(row1.isFooterVisible()); + + row1.setHeaderVisible(false); + assertFalse(row1.isHeaderVisible()); + row1.setHeaderVisible(true); + assertTrue(row1.isHeaderVisible()); + + row1.setFooterVisible(true); + assertTrue(row1.isFooterVisible()); + row1.setFooterVisible(false); + assertFalse(row1.isFooterVisible()); + + row1.setHeaderVisible(true); + row1.setFooterVisible(true); + assertTrue(row1.isHeaderVisible()); + assertTrue(row1.isFooterVisible()); + + row1.setHeaderVisible(false); + row1.setFooterVisible(false); + assertFalse(row1.isHeaderVisible()); + assertFalse(row1.isFooterVisible()); + } + + @Test + public void testColumnGroupsInState() throws Exception { + + // Add a new row + ColumnGroupRow row = grid.addColumnGroupRow(); + assertTrue(state.columnGroupRows.size() == 1); + + // Add a group by property id + ColumnGroup columns12 = row.addGroup("column1", "column2"); + assertTrue(state.columnGroupRows.get(0).groups.size() == 1); + + // Set header of column + columns12.setHeaderCaption("Column12"); + assertEquals("Column12", + state.columnGroupRows.get(0).groups.get(0).header); + + // Set footer of column + columns12.setFooterCaption("Footer12"); + assertEquals("Footer12", + state.columnGroupRows.get(0).groups.get(0).footer); + + // Add another group by column instance + ColumnGroup columns34 = row.addGroup(grid.getColumn("column3"), + grid.getColumn("column4")); + assertTrue(state.columnGroupRows.get(0).groups.size() == 2); + + // add another group row + ColumnGroupRow row2 = grid.addColumnGroupRow(); + assertTrue(state.columnGroupRows.size() == 2); + + // add a group by combining the two previous groups + ColumnGroup columns1234 = row2.addGroup(columns12, columns34); + assertTrue(columns1234.getColumns().size() == 4); + + // Insert a group as the second group + ColumnGroupRow newRow2 = grid.addColumnGroupRow(1); + assertTrue(state.columnGroupRows.size() == 3); + } + + @Test + public void testAddingColumnGroups() throws Exception { + + ColumnGroupRow row = grid.addColumnGroupRow(); + + // By property id + ColumnGroup columns01 = row.addGroup("column0", "column1"); + assertEquals(2, columns01.getColumns().size()); + assertEquals("column0", columns01.getColumns().get(0)); + assertTrue(columns01.isColumnInGroup("column0")); + assertEquals("column1", columns01.getColumns().get(1)); + assertTrue(columns01.isColumnInGroup("column1")); + + // By grid column + ColumnGroup columns23 = row.addGroup(grid.getColumn("column2"), + grid.getColumn("column3")); + assertEquals(2, columns23.getColumns().size()); + assertEquals("column2", columns23.getColumns().get(0)); + assertTrue(columns23.isColumnInGroup("column2")); + assertEquals("column3", columns23.getColumns().get(1)); + assertTrue(columns23.isColumnInGroup("column3")); + + // Combine groups + ColumnGroupRow row2 = grid.addColumnGroupRow(); + ColumnGroup columns0123 = row2.addGroup(columns01, columns23); + assertEquals(4, columns0123.getColumns().size()); + assertEquals("column0", columns0123.getColumns().get(0)); + assertTrue(columns0123.isColumnInGroup("column0")); + assertEquals("column1", columns0123.getColumns().get(1)); + assertTrue(columns0123.isColumnInGroup("column1")); + assertEquals("column2", columns0123.getColumns().get(2)); + assertTrue(columns0123.isColumnInGroup("column2")); + assertEquals("column3", columns0123.getColumns().get(3)); + assertTrue(columns0123.isColumnInGroup("column3")); + } + + @Test + public void testColumnGroupHeadersAndFooters() throws Exception { + + ColumnGroupRow row = grid.addColumnGroupRow(); + ColumnGroup group = row.addGroup("column1", "column2"); + + // Header + assertNull(group.getHeaderCaption()); + group.setHeaderCaption("My header"); + assertEquals("My header", group.getHeaderCaption()); + group.setHeaderCaption(null); + assertNull(group.getHeaderCaption()); + + // Footer + assertNull(group.getFooterCaption()); + group.setFooterCaption("My footer"); + assertEquals("My footer", group.getFooterCaption()); + group.setFooterCaption(null); + assertNull(group.getFooterCaption()); + } +} diff --git a/server/tests/src/com/vaadin/tests/server/component/grid/GridColumns.java b/server/tests/src/com/vaadin/tests/server/component/grid/GridColumns.java index c129db0264..da07611b48 100644 --- a/server/tests/src/com/vaadin/tests/server/component/grid/GridColumns.java +++ b/server/tests/src/com/vaadin/tests/server/component/grid/GridColumns.java @@ -32,8 +32,6 @@ import com.vaadin.data.util.IndexedContainer; import com.vaadin.server.KeyMapper; import com.vaadin.shared.ui.grid.GridColumnState; import com.vaadin.shared.ui.grid.GridState; -import com.vaadin.ui.components.grid.ColumnGroup; -import com.vaadin.ui.components.grid.ColumnGroupRow; import com.vaadin.ui.components.grid.Grid; import com.vaadin.ui.components.grid.GridColumn; @@ -203,45 +201,6 @@ public class GridColumns { assertTrue(state.columnFootersVisible); } - @Test - public void testColumnGroups() throws Exception { - - // Add a new row - ColumnGroupRow row = grid.addColumnGroupRow(); - assertTrue(state.columnGroupRows.size() == 1); - - // Add a group by property id - ColumnGroup columns12 = row.addGroup("column1", "column2"); - assertTrue(state.columnGroupRows.get(0).groups.size() == 1); - - // Set header of column - columns12.setHeaderCaption("Column12"); - assertEquals("Column12", - state.columnGroupRows.get(0).groups.get(0).header); - - // Set footer of column - columns12.setFooterCaption("Footer12"); - assertEquals("Footer12", - state.columnGroupRows.get(0).groups.get(0).footer); - - // Add another group by column instance - ColumnGroup columns34 = row.addGroup(grid.getColumn("column3"), - grid.getColumn("column4")); - assertTrue(state.columnGroupRows.get(0).groups.size() == 2); - - // add another group row - ColumnGroupRow row2 = grid.addColumnGroupRow(); - assertTrue(state.columnGroupRows.size() == 2); - - // add a group by combining the two previous groups - ColumnGroup columns1234 = row2.addGroup(columns12, columns34); - assertTrue(columns1234.getColumns().size() == 4); - - // Insert a group as the second group - ColumnGroupRow newRow2 = grid.addColumnGroupRow(1); - assertTrue(state.columnGroupRows.size() == 3); - } - @Test public void testFrozenColumnByPropertyId() { assertNull("Grid should not start with a frozen column", -- cgit v1.2.3 From 076aa0e6201db1fe9345e256266cb9227384e290 Mon Sep 17 00:00:00 2001 From: John Ahlroos Date: Mon, 25 Nov 2013 13:51:17 +0200 Subject: Ensure setting value on detached column group throws exception #3153 Change-Id: I4cef3424dfe846ab814fcf70c5cda4a305cbdf1c --- .../com/vaadin/ui/components/grid/ColumnGroup.java | 26 +++++++++++++++++++++- .../vaadin/ui/components/grid/ColumnGroupRow.java | 4 ++-- .../server/component/grid/GridColumnGroups.java | 25 +++++++++++++++++++++ 3 files changed, 52 insertions(+), 3 deletions(-) (limited to 'server/tests') diff --git a/server/src/com/vaadin/ui/components/grid/ColumnGroup.java b/server/src/com/vaadin/ui/components/grid/ColumnGroup.java index 0ab1f61a46..6b14ef81d4 100644 --- a/server/src/com/vaadin/ui/components/grid/ColumnGroup.java +++ b/server/src/com/vaadin/ui/components/grid/ColumnGroup.java @@ -42,6 +42,11 @@ public class ColumnGroup implements Serializable { */ private final Grid grid; + /** + * The column group row the column group is attached to + */ + private final ColumnGroupRow row; + /** * The common state between the server and the client */ @@ -61,13 +66,15 @@ public class ColumnGroup implements Serializable { * the sub groups who should be included in this group * */ - ColumnGroup(Grid grid, ColumnGroupState state, List propertyIds) { + ColumnGroup(Grid grid, ColumnGroupRow row, ColumnGroupState state, + List propertyIds) { if (propertyIds == null) { throw new IllegalArgumentException( "propertyIds cannot be null. Use empty list instead."); } this.state = state; + this.row = row; columns = Collections.unmodifiableList(new ArrayList( propertyIds)); this.grid = grid; @@ -80,6 +87,7 @@ public class ColumnGroup implements Serializable { * the text displayed in the header of the column */ public void setHeaderCaption(String header) { + checkGroupIsAttached(); state.header = header; grid.markAsDirty(); } @@ -90,6 +98,7 @@ public class ColumnGroup implements Serializable { * @return the text displayed in the header of the column */ public String getHeaderCaption() { + checkGroupIsAttached(); return state.header; } @@ -100,6 +109,7 @@ public class ColumnGroup implements Serializable { * the text displayed in the footer of the column */ public void setFooterCaption(String footer) { + checkGroupIsAttached(); state.footer = footer; grid.markAsDirty(); } @@ -110,6 +120,7 @@ public class ColumnGroup implements Serializable { * @return the text displayed in the footer of the column */ public String getFooterCaption() { + checkGroupIsAttached(); return state.footer; } @@ -138,4 +149,17 @@ public class ColumnGroup implements Serializable { return columns; } + /** + * Checks if column group is attached to a row and throws an + * {@link IllegalStateException} if it is not. + * + * @throws IllegalStateException + * if the column is no longer attached to any grid + */ + protected void checkGroupIsAttached() throws IllegalStateException { + if (!row.getState().groups.contains(state)) { + throw new IllegalStateException( + "Column Group has been removed from the row."); + } + } } diff --git a/server/src/com/vaadin/ui/components/grid/ColumnGroupRow.java b/server/src/com/vaadin/ui/components/grid/ColumnGroupRow.java index 326d2826f5..e82e24abec 100644 --- a/server/src/com/vaadin/ui/components/grid/ColumnGroupRow.java +++ b/server/src/com/vaadin/ui/components/grid/ColumnGroupRow.java @@ -111,7 +111,7 @@ public class ColumnGroupRow implements Serializable { } this.state.groups.add(state); - ColumnGroup group = new ColumnGroup(grid, state, + ColumnGroup group = new ColumnGroup(grid, this, state, Arrays.asList(propertyIds)); groups.add(group); @@ -160,7 +160,7 @@ public class ColumnGroupRow implements Serializable { } ColumnGroupState state = new ColumnGroupState(); - ColumnGroup group = new ColumnGroup(grid, state, propertyIds); + ColumnGroup group = new ColumnGroup(grid, this, state, propertyIds); this.groups.add(group); // Update state diff --git a/server/tests/src/com/vaadin/tests/server/component/grid/GridColumnGroups.java b/server/tests/src/com/vaadin/tests/server/component/grid/GridColumnGroups.java index cf1ee14437..11dc48f7d5 100644 --- a/server/tests/src/com/vaadin/tests/server/component/grid/GridColumnGroups.java +++ b/server/tests/src/com/vaadin/tests/server/component/grid/GridColumnGroups.java @@ -19,6 +19,7 @@ import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertNull; import static org.junit.Assert.assertTrue; +import static org.junit.Assert.fail; import java.lang.reflect.Field; import java.lang.reflect.Method; @@ -208,4 +209,28 @@ public class GridColumnGroups { group.setFooterCaption(null); assertNull(group.getFooterCaption()); } + + @Test + public void testColumnGroupDetachment() throws Exception { + + ColumnGroupRow row = grid.addColumnGroupRow(); + ColumnGroup group = row.addGroup("column1", "column2"); + + // Remove group + row.removeGroup(group); + + try { + group.setHeaderCaption("Header"); + fail("Should throw exception for setting header caption on detached group"); + } catch (IllegalStateException ise) { + + } + + try { + group.setFooterCaption("Footer"); + fail("Should throw exception for setting footer caption on detached group"); + } catch (IllegalStateException ise) { + + } + } } -- cgit v1.2.3 From eb75c09574249687d9ea3899791c8daa3fcec314 Mon Sep 17 00:00:00 2001 From: John Ahlroos Date: Tue, 10 Dec 2013 16:35:50 +0200 Subject: Validate column group boundaries #12907 Change-Id: I5078d97c5a6bc92f59d0d04eca2a2cfc27c973b4 --- .../com/vaadin/client/ui/grid/ColumnGroupRow.java | 57 ++++++++++++++++++++- .../vaadin/ui/components/grid/ColumnGroupRow.java | 58 ++++++++++++++++++++-- .../server/component/grid/GridColumnGroups.java | 29 +++++++++++ 3 files changed, 137 insertions(+), 7 deletions(-) (limited to 'server/tests') diff --git a/client/src/com/vaadin/client/ui/grid/ColumnGroupRow.java b/client/src/com/vaadin/client/ui/grid/ColumnGroupRow.java index 113e0b34c6..0ced616f3f 100644 --- a/client/src/com/vaadin/client/ui/grid/ColumnGroupRow.java +++ b/client/src/com/vaadin/client/ui/grid/ColumnGroupRow.java @@ -18,6 +18,7 @@ package com.vaadin.client.ui.grid; import java.util.ArrayList; import java.util.Arrays; +import java.util.Collection; import java.util.Collections; import java.util.HashSet; import java.util.List; @@ -73,7 +74,8 @@ public class ColumnGroupRow { * @return a column group representing the collection of columns added to * the group. */ - public ColumnGroup addGroup(GridColumn... columns) { + public ColumnGroup addGroup(GridColumn... columns) + throws IllegalArgumentException { for (GridColumn column : columns) { if (isColumnGrouped(column)) { @@ -83,6 +85,8 @@ public class ColumnGroupRow { } } + validateNewGroupProperties(Arrays.asList(columns)); + ColumnGroup group = new ColumnGroup(grid, Arrays.asList(columns)); groups.add(group); grid.refreshHeader(); @@ -90,6 +94,52 @@ public class ColumnGroupRow { return group; } + private void validateNewGroupProperties(Collection> columns) { + + int rowIndex = grid.getColumnGroupRows().indexOf(this); + int parentRowIndex = rowIndex - 1; + + // Get the parent row of this row. + ColumnGroupRow parentRow = null; + if (parentRowIndex > -1) { + parentRow = grid.getColumnGroupRows().get(parentRowIndex); + } + + if (parentRow == null) { + // A parentless row is always valid and is usually the first row + // added to the grid + return; + } + + for (GridColumn column : columns) { + if (parentRow.hasColumnBeenGrouped(column)) { + /* + * If a property has been grouped in the parent row then all of + * the properties in the parent group also needs to be included + * in the child group for the groups to be valid + */ + ColumnGroup parentGroup = parentRow.getGroupForColumn(column); + if (!columns.containsAll(parentGroup.getColumns())) { + throw new IllegalArgumentException( + "Grouped properties overlaps previous grouping bounderies"); + } + } + } + } + + private boolean hasColumnBeenGrouped(GridColumn column) { + return getGroupForColumn(column) != null; + } + + private ColumnGroup getGroupForColumn(GridColumn column) { + for (ColumnGroup group : groups) { + if (group.getColumns().contains(column)) { + return group; + } + } + return null; + } + /** * Add a new group to the row by using other already greated groups * @@ -99,7 +149,8 @@ public class ColumnGroupRow { * the group. * */ - public ColumnGroup addGroup(ColumnGroup... groups) { + public ColumnGroup addGroup(ColumnGroup... groups) + throws IllegalArgumentException { assert groups != null : "groups cannot be null"; Set> columns = new HashSet>(); @@ -107,6 +158,8 @@ public class ColumnGroupRow { columns.addAll(group.getColumns()); } + validateNewGroupProperties(columns); + ColumnGroup group = new ColumnGroup(grid, columns); this.groups.add(group); grid.refreshHeader(); diff --git a/server/src/com/vaadin/ui/components/grid/ColumnGroupRow.java b/server/src/com/vaadin/ui/components/grid/ColumnGroupRow.java index e82e24abec..b90b4df2c5 100644 --- a/server/src/com/vaadin/ui/components/grid/ColumnGroupRow.java +++ b/server/src/com/vaadin/ui/components/grid/ColumnGroupRow.java @@ -93,7 +93,8 @@ public class ColumnGroupRow implements Serializable { * @return a column group representing the collection of columns added to * the group */ - public ColumnGroup addGroup(Object... propertyIds) { + public ColumnGroup addGroup(Object... propertyIds) + throws IllegalArgumentException { assert propertyIds != null : "propertyIds cannot be null."; for (Object propertyId : propertyIds) { @@ -104,6 +105,8 @@ public class ColumnGroupRow implements Serializable { } } + validateNewGroupProperties(Arrays.asList(propertyIds)); + ColumnGroupState state = new ColumnGroupState(); for (Object propertyId : propertyIds) { assert propertyId != null : "null items in columns array not supported."; @@ -119,6 +122,43 @@ public class ColumnGroupRow implements Serializable { return group; } + private void validateNewGroupProperties(List propertyIds) + throws IllegalArgumentException { + + /* + * Validate parent grouping + */ + int rowIndex = grid.getColumnGroupRows().indexOf(this); + int parentRowIndex = rowIndex - 1; + + // Get the parent row of this row. + ColumnGroupRow parentRow = null; + if (parentRowIndex > -1) { + parentRow = grid.getColumnGroupRows().get(parentRowIndex); + } + + if (parentRow == null) { + // A parentless row is always valid and is usually the first row + // added to the grid + return; + } + + for (Object id : propertyIds) { + if (parentRow.hasColumnBeenGrouped(id)) { + /* + * If a property has been grouped in the parent row then all of + * the properties in the parent group also needs to be included + * in the child group for the groups to be valid + */ + ColumnGroup parentGroup = parentRow.getGroupForProperty(id); + if (!propertyIds.containsAll(parentGroup.getColumns())) { + throw new IllegalArgumentException( + "Grouped properties overlaps previous grouping bounderies"); + } + } + } + } + /** * Add a new group to the row by using column instances. * @@ -127,7 +167,8 @@ public class ColumnGroupRow implements Serializable { * @return a column group representing the collection of columns added to * the group */ - public ColumnGroup addGroup(GridColumn... columns) { + public ColumnGroup addGroup(GridColumn... columns) + throws IllegalArgumentException { assert columns != null : "columns cannot be null"; List propertyIds = new ArrayList(); @@ -150,7 +191,8 @@ public class ColumnGroupRow implements Serializable { * the group * */ - public ColumnGroup addGroup(ColumnGroup... groups) { + public ColumnGroup addGroup(ColumnGroup... groups) + throws IllegalArgumentException { assert groups != null : "groups cannot be null"; // Gather all groups columns into one list @@ -159,6 +201,8 @@ public class ColumnGroupRow implements Serializable { propertyIds.addAll(group.getColumns()); } + validateNewGroupProperties(propertyIds); + ColumnGroupState state = new ColumnGroupState(); ColumnGroup group = new ColumnGroup(grid, this, state, propertyIds); this.groups.add(group); @@ -204,12 +248,16 @@ public class ColumnGroupRow implements Serializable { * @return true if the column is included in a group */ private boolean hasColumnBeenGrouped(Object propertyId) { + return getGroupForProperty(propertyId) != null; + } + + private ColumnGroup getGroupForProperty(Object propertyId) { for (ColumnGroup group : groups) { if (group.isColumnInGroup(propertyId)) { - return true; + return group; } } - return false; + return null; } /** diff --git a/server/tests/src/com/vaadin/tests/server/component/grid/GridColumnGroups.java b/server/tests/src/com/vaadin/tests/server/component/grid/GridColumnGroups.java index 11dc48f7d5..4350bf1a7b 100644 --- a/server/tests/src/com/vaadin/tests/server/component/grid/GridColumnGroups.java +++ b/server/tests/src/com/vaadin/tests/server/component/grid/GridColumnGroups.java @@ -233,4 +233,33 @@ public class GridColumnGroups { } } + + @Test + public void testColumnGroupLimits() throws Exception { + + ColumnGroupRow row = grid.addColumnGroupRow(); + row.addGroup("column1", "column2"); + row.addGroup("column3", "column4"); + + try { + row.addGroup("column2", "column3"); + fail("Adding a group with already grouped properties should throw exception"); + } catch (IllegalArgumentException iae) { + + } + + ColumnGroupRow row2 = grid.addColumnGroupRow(); + + try { + row2.addGroup("column2", "column3"); + fail("Adding a group that breaks previous grouping boundaries should throw exception"); + } catch (IllegalArgumentException iae) { + + } + + // This however should not throw an exception as it spans completely + // over the parent rows groups + row2.addGroup("column1", "column2", "column3", "column4"); + + } } -- cgit v1.2.3