* update the class names of the element, add inline styles and freely
* modify the contents.
* <p>
- * Avoid modifying the dimensions or positioning of the cell element.
+ * Avoid modifying the dimensions, positioning or colspan of the cell
+ * element.
*
* @return The root element for this cell. Never <code>null</code>.
*/
public Element getElement();
+
+ /**
+ * Sets the column span of the cell.
+ * <p>
+ * This will overwrite any possible "colspan" attribute in the current
+ * element (i.e. the object returned by {@link #getElement()}). This will
+ * also handle internal bookkeeping, skip the rendering of any affected
+ * adjacent cells, and make sure that the current cell's dimensions are
+ * handled correctly.
+ *
+ * @param numberOfCells
+ * the number of cells to span to the right, or <code>1</code> to
+ * unset any column spans
+ * @throws IllegalArgumentException
+ * if <code>numberOfCells < 1</code>
+ */
+ public void setColSpan(int numberOfCells) throws IllegalArgumentException;
}
\ No newline at end of file
}
private static final int ROW_HEIGHT_PX = 20;
- private static final int COLUMN_WIDTH_PX = 100;
+ static final int COLUMN_WIDTH_PX = 100;
/** An inner class that handles all logic related to scrolling. */
private class Scroller extends JsniWorkaround {
// this needs to be after the scroll position adjustment above.
scroller.recalculateScrollbarsForVirtualViewport();
+ /*
+ * Because we might remove columns where affected by colspans, it's
+ * easiest to simply redraw everything when columns are modified.
+ *
+ * Yes, this is a TODO [[optimize]].
+ */
+ if (getRowCount() > 0
+ && getColumnConfiguration().getColumnCount() > 0) {
+ refreshRows(0, getRowCount());
+ }
}
protected void paintInsertColumns(final int offset,
final int numberOfColumns, boolean frozen) {
final NodeList<Node> childNodes = root.getChildNodes();
- final int topVisualRowLogicalIndex = getTopVisualRowLogicalIndex();
for (int row = 0; row < childNodes.getLength(); row++) {
final Element tr = getTrByVisualIndex(row);
cellElem, referenceCell);
}
- refreshRow(tr, topVisualRowLogicalIndex + row);
-
/*
* TODO [[optimize]] [[colwidth]]: When this method is updated
* to measure things instead of using hardcoded values, it would
.setScrollPos((int) (scroller.lastScrollLeft + numberOfColumns
* COLUMN_WIDTH_PX));
}
+
+ /*
+ * Because we might insert columns where affected by colspans, it's
+ * easiest to simply redraw everything when columns are modified.
+ *
+ * Yes, this is a TODO [[optimize]].
+ */
+ if (getRowCount() > 0
+ && getColumnConfiguration().getColumnCount() > 1) {
+ refreshRows(0, getRowCount());
+ }
}
public void setColumnFrozen(int column, boolean frozen) {
private Range convertToVisual(final Range logicalRange) {
if (logicalRange.isEmpty()) {
return logicalRange;
+ } else if (visualRowOrder.isEmpty()) {
+ // empty range
+ return Range.withLength(0, 0);
}
/*
package com.vaadin.client.ui.grid;
-import java.util.List;
/**
* A functional interface that allows client code to define how a certain row in
/** An {@link EscalatorUpdater} that doesn't render anything. */
public static final EscalatorUpdater NULL = new EscalatorUpdater() {
@Override
- public void updateCells(final Row row, final List<Cell> cellsToUpdate) {
+ public void updateCells(final Row row,
+ final Iterable<Cell> cellsToUpdate) {
// NOOP
}
};
* You should neither store nor reuse the reference to the list,
* nor to the individual cells
*/
- public void updateCells(Row row, List<Cell> cellsToUpdate);
+ public void updateCells(Row row, Iterable<Cell> cellsToUpdate);
}
*/
package com.vaadin.client.ui.grid;
+import java.util.List;
+
+import com.google.gwt.dom.client.Style.Display;
+import com.google.gwt.dom.client.Style.Unit;
import com.google.gwt.user.client.Element;
+import com.vaadin.client.ui.grid.FlyweightRow.CellIterator;
/**
* An internal implementation of the {@link Cell} interface.
* @see FlyweightRow#removeCells(int, int)
*/
class FlyweightCell implements Cell {
+ private static final String COLSPAN_ATTR = "colSpan";
+
private final int column;
private final FlyweightRow row;
+ private CellIterator currentIterator = null;
public FlyweightCell(final FlyweightRow row, final int column) {
this.row = row;
@Override
public int getRow() {
+ assertSetup();
return row.getRow();
}
@Override
public int getColumn() {
+ assertSetup();
return column;
}
return (Element) row.getElement().getChild(column);
}
+ void setup(final CellIterator cellIterator) {
+ currentIterator = cellIterator;
+
+ final Element e = getElement();
+ e.setPropertyInt(COLSPAN_ATTR, 1);
+ e.getStyle().setWidth(Escalator.COLUMN_WIDTH_PX, Unit.PX);
+ e.getStyle().clearDisplay();
+ }
+
+ /**
+ * Tear down the state of the Cell.
+ * <p>
+ * This is an internal check method, to prevent retrieving uninitialized
+ * data by calling {@link #getRow()}, {@link #getColumn()} or
+ * {@link #getElement()} at an improper time.
+ * <p>
+ * This should only be used with asserts ("
+ * <code>assert flyweightCell.teardown()</code> ") so that the code is never
+ * run when asserts aren't enabled.
+ *
+ * @return always <code>true</code>
+ * @see FlyweightRow#teardown()
+ */
+ boolean teardown() {
+ currentIterator = null;
+ return true;
+ }
+
+ /**
+ * Asserts that the flyweight cell has properly been set up before trying to
+ * access any of its data.
+ */
+ private void assertSetup() {
+ assert currentIterator != null : "FlyweightCell was not properly "
+ + "initialized. This is either a bug in Grid/Escalator "
+ + "or a Cell reference has been stored and reused "
+ + "inappropriately.";
+ }
+
+ @Override
+ public void setColSpan(final int numberOfCells) {
+ /*-
+ * This will default to 1 if unset, as per DOM specifications:
+ * http://www.w3.org/TR/html5/tabular-data.html#attributes-common-to-td-and-th-elements
+ */
+ final int prevColSpan = getElement().getPropertyInt(COLSPAN_ATTR);
+ if (numberOfCells == 1 && prevColSpan == 1) {
+ return;
+ }
+
+ getElement().setPropertyInt(COLSPAN_ATTR, numberOfCells);
+ adjustCellWidthForSpan(numberOfCells);
+ hideOrRevealAdjacentCellElements(numberOfCells, prevColSpan);
+ currentIterator.setSkipNext(numberOfCells - 1);
+ }
+
+ private void adjustCellWidthForSpan(final int numberOfCells) {
+ final List<FlyweightCell> cellsToTheRight = currentIterator
+ .rawPeekNext(numberOfCells - 1);
+ final int widthsOfColumnsToTheRight = cellsToTheRight.size()
+ * Escalator.COLUMN_WIDTH_PX;
+ final int selfWidth = Escalator.COLUMN_WIDTH_PX;
+ getElement().getStyle().setWidth(selfWidth + widthsOfColumnsToTheRight,
+ Unit.PX);
+ }
+
+ private void hideOrRevealAdjacentCellElements(final int numberOfCells,
+ final int prevColSpan) {
+ final int affectedCellsNumber = Math.max(prevColSpan, numberOfCells);
+ final List<FlyweightCell> affectedCells = currentIterator
+ .rawPeekNext(affectedCellsNumber - 1);
+ if (prevColSpan < numberOfCells) {
+ for (int i = 0; i < affectedCells.size(); i++) {
+ affectedCells.get(prevColSpan + i - 1).getElement().getStyle()
+ .setDisplay(Display.NONE);
+ }
+ } else if (prevColSpan > numberOfCells) {
+ for (int i = 0; i < affectedCells.size(); i++) {
+ affectedCells.get(numberOfCells + i - 1).getElement()
+ .getStyle().clearDisplay();
+ }
+ }
+ }
}
package com.vaadin.client.ui.grid;
import java.util.ArrayList;
-import java.util.Collections;
+import java.util.Collection;
+import java.util.Iterator;
import java.util.List;
import com.google.gwt.dom.client.Node;
* @see Escalator.AbstractRowContainer#refreshRow(Node, int)
*/
class FlyweightRow implements Row {
+
+ static class CellIterator implements Iterator<Cell> {
+ /** A defensive copy of the cells in the current row. */
+ private final ArrayList<FlyweightCell> cells;
+ private int cursor = 0;
+ private int skipNext = 0;
+
+ public CellIterator(final Collection<FlyweightCell> cells) {
+ this.cells = new ArrayList<FlyweightCell>(cells);
+ }
+
+ @Override
+ public boolean hasNext() {
+ return cursor + skipNext < cells.size();
+ }
+
+ @Override
+ public FlyweightCell next() {
+ // if we needed to skip some cells since the last invocation.
+ for (int i = 0; i < skipNext; i++) {
+ cells.remove(cursor);
+ }
+ skipNext = 0;
+
+ final FlyweightCell cell = cells.get(cursor++);
+ cell.setup(this);
+ return cell;
+ }
+
+ @Override
+ public void remove() {
+ throw new UnsupportedOperationException(
+ "Cannot remove cells via iterator");
+ }
+
+ /**
+ * Sets the number of cells to skip when {@link #next()} is called the
+ * next time. Cell hiding is also handled eagerly in this method.
+ *
+ * @param colspan
+ * the number of cells to skip on next invocation of
+ * {@link #next()}
+ */
+ public void setSkipNext(final int colspan) {
+ assert colspan > 0 : "Number of cells didn't make sense: "
+ + colspan;
+ skipNext = colspan;
+ }
+
+ /**
+ * Gets the next <code>n</code> cells in the iterator, ignoring any
+ * possibly spanned cells.
+ *
+ * @param n
+ * the number of next cells to retrieve
+ * @return A list of next <code>n</code> cells, or less if there aren't
+ * enough cells to retrieve
+ */
+ public List<FlyweightCell> rawPeekNext(final int n) {
+ final int from = Math.min(cursor, cells.size());
+ final int to = Math.min(cursor + n, cells.size());
+ return cells.subList(from, to);
+ }
+ }
+
private static final int BLANK = Integer.MIN_VALUE;
private int row;
private Element element;
private final Escalator escalator;
- private final List<Cell> cells = new ArrayList<Cell>();
+ private final List<FlyweightCell> cells = new ArrayList<FlyweightCell>();
public FlyweightRow(final Escalator escalator) {
this.escalator = escalator;
boolean teardown() {
element = null;
row = BLANK;
+ for (final FlyweightCell cell : cells) {
+ assert cell.teardown();
+ }
return true;
}
* @see #setup(Element, int)
* @see #teardown()
*/
- List<Cell> getCells() {
+ Iterable<Cell> getCells() {
assertSetup();
- return Collections.unmodifiableList(cells);
+ return new Iterable<Cell>() {
+ @Override
+ public Iterator<Cell> iterator() {
+ return new CellIterator(cells);
+ }
+ };
}
/**
public abstract boolean firstRowIsVisible();
@Override
- public void updateCells(Row row, List<Cell> cellsToUpdate) {
+ public void updateCells(Row row, Iterable<Cell> cellsToUpdate) {
int rowIndex;
if (inverted) {
return new EscalatorUpdater() {
@Override
- public void updateCells(Row row, List<Cell> cellsToUpdate) {
+ public void updateCells(Row row, Iterable<Cell> cellsToUpdate) {
int rowIndex = row.getRow();
if (dataSource == null) {
setCellsLoading(cellsToUpdate);
}
}
- private void setCellsLoading(List<Cell> cellsToUpdate) {
+ private void setCellsLoading(Iterable<Cell> cellsToUpdate) {
for (Cell cell : cellsToUpdate) {
cell.getElement().setInnerText("...");
}
return new EscalatorUpdater() {
@Override
public void updateCells(final Row row,
- final List<Cell> cellsToUpdate) {
+ final Iterable<Cell> cellsToUpdate) {
for (final Cell cell : cellsToUpdate) {
+ if (cell.getColumn() % 3 == 0) {
+ cell.setColSpan(2);
+ }
+
final Integer columnName = columns
.get(cell.getColumn());
cell.getElement().setInnerText("Header " + columnName);
return new EscalatorUpdater() {
@Override
public void updateCells(final Row row,
- final List<Cell> cellsToUpdate) {
+ final Iterable<Cell> cellsToUpdate) {
for (final Cell cell : cellsToUpdate) {
+ if (cell.getColumn() % 3 == 1) {
+ cell.setColSpan(2);
+ }
+
final Integer columnName = columns
.get(cell.getColumn());
cell.getElement().setInnerText("Footer " + columnName);
"Row " + cell.getRow() + ": " + cellInfo);
}
+ if (cell.getColumn() % 3 == cell.getRow() % 3) {
+ cell.setColSpan(3);
+ }
+
final double c = i * .1;
final int r = (int) ((Math.cos(c) + 1) * 128);
final int g = (int) ((Math.cos(c / Math.PI) + 1) * 128);
@Override
public void updateCells(final Row row,
- final List<Cell> cellsToUpdate) {
+ final Iterable<Cell> cellsToUpdate) {
for (final Cell cell : cellsToUpdate) {
renderCell(cell);
}
projects / vaadin-framework.git / commitdiff