* GWT is unable to handle some method calls to Java methods in inner-classes * from within JSNI blocks. Having that inner class extend a non-inner-class (or * implement such an interface), makes it possible for JSNI to indirectly refer * to the inner class, by invoking methods and fields in the non-inner-class * API. * * @see Escalator.Scroller */ abstract class JsniWorkaround { /** * A JavaScript function that handles the scroll DOM event, and passes it on * to Java code. * * @see #createScrollListenerFunction(Escalator) * @see Escalator.Scroller#onScroll() */ protected final JavaScriptObject scrollListenerFunction; /** * A JavaScript function that handles the mousewheel DOM event, and passes * it on to Java code. * * @see #createMousewheelListenerFunction(Escalator) * @see Escalator.Scroller#onScroll() */ protected final JavaScriptObject mousewheelListenerFunction; /** * A JavaScript function that handles the touch start DOM event, and passes * it on to Java code. * * @see TouchHandlerBundle#touchStart(Escalator.JsniUtil.TouchHandlerBundle.CustomTouchEvent) */ protected JavaScriptObject touchStartFunction; /** * A JavaScript function that handles the touch move DOM event, and passes * it on to Java code. * * @see TouchHandlerBundle#touchMove(Escalator.JsniUtil.TouchHandlerBundle.CustomTouchEvent) */ protected JavaScriptObject touchMoveFunction; /** * A JavaScript function that handles the touch end and cancel DOM events, * and passes them on to Java code. * * @see TouchHandlerBundle#touchEnd(Escalator.JsniUtil.TouchHandlerBundle.CustomTouchEvent) */ protected JavaScriptObject touchEndFunction; protected TouchHandlerBundle touchHandlerBundle; protected JsniWorkaround(final Escalator escalator) { scrollListenerFunction = createScrollListenerFunction(escalator); mousewheelListenerFunction = createMousewheelListenerFunction( escalator); touchHandlerBundle = new TouchHandlerBundle(escalator); touchStartFunction = touchHandlerBundle.getTouchStartHandler(); touchMoveFunction = touchHandlerBundle.getTouchMoveHandler(); touchEndFunction = touchHandlerBundle.getTouchEndHandler(); } /** * A method that constructs the JavaScript function that will be stored into * {@link #scrollListenerFunction}. * * @param esc * a reference to the current instance of {@link Escalator} * @see Escalator.Scroller#onScroll() */ protected abstract JavaScriptObject createScrollListenerFunction( Escalator esc); /** * A method that constructs the JavaScript function that will be stored into * {@link #mousewheelListenerFunction}. * * @param esc * a reference to the current instance of {@link Escalator} * @see Escalator.Scroller#onScroll() */ protected abstract JavaScriptObject createMousewheelListenerFunction( Escalator esc); } /** * A low-level table-like widget that features a scrolling virtual viewport and * lazily generated rows. * * @since 7.4 * @author Vaadin Ltd */ public class Escalator extends Widget implements RequiresResize, DeferredWorker, SubPartAware { // todo comments legend /* * [[optimize]]: There's an opportunity to rewrite the code in such a way * that it _might_ perform better (remember to measure, implement, * re-measure) */ /* * [[mpixscroll]]: This code will require alterations that are relevant for * supporting the scrolling through more pixels than some browsers normally * would support. (i.e. when we support more than "a million" pixels in the * escalator DOM). NOTE: these bits can most often also be identified by * searching for code that call scrollElem.getScrollTop();. */ /* * [[spacer]]: Code that is important to make spacers work. */ /** * A utility class that contains utility methods that are usually called * from JSNI. *
* The methods are moved in this class to minimize the amount of JSNI code * as much as feasible. */ static class JsniUtil { public static class TouchHandlerBundle { public static final String POINTER_EVENT_TYPE_TOUCH = "touch"; public static final int SIGNIFICANT_MOVE_THRESHOLD = 3; /** * A JavaScriptObject overlay for the * JavaScript * TouchEvent object. *
* This needs to be used in the touch event handlers, since GWT's
* {@link com.google.gwt.event.dom.client.TouchEvent TouchEvent}
* can't be cast from the JSNI call, and the
* {@link com.google.gwt.dom.client.NativeEvent NativeEvent} isn't
* properly populated with the correct values.
*/
private static final class CustomTouchEvent
extends JavaScriptObject {
protected CustomTouchEvent() {
}
public native NativeEvent getNativeEvent()
/*-{
return this;
}-*/;
public native int getPageX()
/*-{
return this.targetTouches[0].pageX;
}-*/;
public native int getPageY()
/*-{
return this.targetTouches[0].pageY;
}-*/;
public native String getPointerType()
/*-{
return this.pointerType;
}-*/;
}
private final Escalator escalator;
public TouchHandlerBundle(final Escalator escalator) {
this.escalator = escalator;
}
public native JavaScriptObject getTouchStartHandler()
/*-{
// we need to store "this", since it won't be preserved on call.
var self = this;
return $entry(function (e) {
self.@com.vaadin.client.widgets.Escalator.JsniUtil.TouchHandlerBundle::touchStart(*)(e);
});
}-*/;
public native JavaScriptObject getTouchMoveHandler()
/*-{
// we need to store "this", since it won't be preserved on call.
var self = this;
return $entry(function (e) {
self.@com.vaadin.client.widgets.Escalator.JsniUtil.TouchHandlerBundle::touchMove(*)(e);
});
}-*/;
public native JavaScriptObject getTouchEndHandler()
/*-{
// we need to store "this", since it won't be preserved on call.
var self = this;
return $entry(function (e) {
self.@com.vaadin.client.widgets.Escalator.JsniUtil.TouchHandlerBundle::touchEnd(*)(e);
});
}-*/;
// Duration of the inertial scrolling simulation. Devices with
// larger screens take longer durations.
private static final int DURATION = Window.getClientHeight();
// multiply scroll velocity with repeated touching
private int acceleration = 1;
private boolean touching = false;
// Two movement objects for storing status and processing touches
private Movement yMov, xMov;
// true if moved significantly since touch start
private boolean movedSignificantly = false;
private double touchStartTime;
final double MIN_VEL = 0.6, MAX_VEL = 4, F_VEL = 1500, F_ACC = 0.7,
F_AXIS = 1;
// The object to deal with one direction scrolling
private class Movement {
final List
* The following WAI-ARIA attributes are added through this class:
*
*
* Usually {@code "th"} or {@code "td"}.
*
* Note: To actually create such an element, use
* {@link #createCellElement(double)} instead.
*
* @return the tag name for the element to represent cells as
* @see #createCellElement(double)
*/
protected abstract String getCellElementTagName();
/**
* Gets the role attribute of an element to represent a cell in a row.
*
* Usually {@link AriaGridRole#GRIDCELL} except for a cell in the
* header.
*
* @return the role attribute for the element to represent cells
*
* @since 8.2
*/
protected AriaGridRole getCellElementRole() {
return AriaGridRole.GRIDCELL;
}
/**
* Gets the role attribute of an element to represent a row in a grid.
*
* Usually {@link AriaGridRole#ROW} except for a row in the header.
*
* @return the role attribute for the element to represent rows
*
* @since 8.2
*/
protected AriaGridRole getRowElementRole() {
return AriaGridRole.ROW;
}
@Override
public EscalatorUpdater getEscalatorUpdater() {
return updater;
}
/**
* {@inheritDoc}
*
* Implementation detail: This method does no DOM modifications
* (i.e. is very cheap to call) if there is no data for rows or columns
* when this method is called.
*
* @see #hasColumnAndRowData()
*/
@Override
public void setEscalatorUpdater(
final EscalatorUpdater escalatorUpdater) {
if (escalatorUpdater == null) {
throw new IllegalArgumentException(
"escalator updater cannot be null");
}
updater = escalatorUpdater;
if (hasColumnAndRowData() && getRowCount() > 0) {
refreshRows(0, getRowCount());
}
}
/**
* {@inheritDoc}
*
* Implementation detail: This method does no DOM modifications
* (i.e. is very cheap to call) if there are no rows in the DOM when
* this method is called.
*
* @see #hasSomethingInDom()
*/
@Override
public void removeRows(final int index, final int numberOfRows) {
assertArgumentsAreValidAndWithinRange(index, numberOfRows);
rows -= numberOfRows;
ariaGridHelper.removeRows(numberOfRows);
if (!isAttached()) {
return;
}
if (hasSomethingInDom()) {
paintRemoveRows(index, numberOfRows);
}
}
/**
* Removes those row elements from the DOM that correspond to the given
* range of logical indices. This may be fewer than {@code numberOfRows}
* , even zero, if not all the removed rows are actually visible.
*
* The implementation must call
* {@link #paintRemoveRow(TableRowElement, int)} for each row that is
* removed from the DOM.
*
* @param index
* the logical index of the first removed row
* @param numberOfRows
* number of logical rows to remove
*/
protected abstract void paintRemoveRows(final int index,
final int numberOfRows);
/**
* Removes a row element from the DOM, invoking
* {@link #getEscalatorUpdater()}
* {@link EscalatorUpdater#preDetach(Row, Iterable) preDetach} and
* {@link EscalatorUpdater#postDetach(Row, Iterable) postDetach} before
* and after removing the row, respectively.
*
* This method must be called for each removed DOM row by any
* {@link #paintRemoveRows(int, int)} implementation.
*
* @param tr
* the row element to remove.
* @param logicalRowIndex
* logical index of the row that is to be removed
*/
protected void paintRemoveRow(final TableRowElement tr,
final int logicalRowIndex) {
flyweightRow.setup(tr, logicalRowIndex,
columnConfiguration.getCalculatedColumnWidths());
getEscalatorUpdater().preDetach(flyweightRow,
flyweightRow.getCells());
tr.removeFromParent();
getEscalatorUpdater().postDetach(flyweightRow,
flyweightRow.getCells());
/*
* the "assert" guarantees that this code is run only during
* development/debugging.
*/
assert flyweightRow.teardown();
}
protected void assertArgumentsAreValidAndWithinRange(final int index,
final int numberOfRows)
throws IllegalArgumentException, IndexOutOfBoundsException {
if (numberOfRows < 1) {
throw new IllegalArgumentException(
"Number of rows must be 1 or greater (was "
+ numberOfRows + ")");
}
if (index < 0 || index + numberOfRows > getRowCount()) {
throw new IndexOutOfBoundsException("The given " + "row range ("
+ index + ".." + (index + numberOfRows)
+ ") was outside of the current number of rows ("
+ getRowCount() + ")");
}
}
@Override
public int getRowCount() {
return rows;
}
/**
* This method calculates the current row count directly from the DOM.
*
* While Escalator is stable, this value should equal to
* {@link #getRowCount()}, but while row counts are being updated, these
* two values might differ for a short while.
*
* Any extra content, such as spacers for the body, should not be
* included in this count.
*
* @since 7.5.0
*
* @return the actual DOM count of rows
*/
public abstract int getDomRowCount();
/**
* {@inheritDoc}
*
* Implementation detail: This method does no DOM modifications
* (i.e. is very cheap to call) if there is no data for columns when
* this method is called.
*
* @see #hasColumnAndRowData()
*/
@Override
public void insertRows(final int index, final int numberOfRows) {
if (index < 0 || index > getRowCount()) {
throw new IndexOutOfBoundsException("The given index (" + index
+ ") was outside of the current number of rows (0.."
+ getRowCount() + ")");
}
if (numberOfRows < 1) {
throw new IllegalArgumentException(
"Number of rows must be 1 or greater (was "
+ numberOfRows + ")");
}
rows += numberOfRows;
ariaGridHelper.addRows(numberOfRows);
/*
* only add items in the DOM if the widget itself is attached to the
* DOM. We can't calculate sizes otherwise.
*/
if (isAttached()) {
paintInsertRows(index, numberOfRows);
/*
* We are inserting the first rows in this container. We
* potentially need to set the widths for the cells for the
* first time.
*/
if (rows == numberOfRows) {
Scheduler.get().scheduleFinally(() -> {
if (initialColumnSizesCalculated) {
return;
}
initialColumnSizesCalculated = true;
Map
* Implementation detail: This method does no DOM modifications
* (i.e. is very cheap to call) if there is no data for columns when
* this method is called.
*
* @see #hasColumnAndRowData()
*/
@Override
// overridden because of JavaDoc
public void refreshRows(final int index, final int numberOfRows) {
Range rowRange = Range.withLength(index, numberOfRows);
Range colRange = Range.withLength(0,
getColumnConfiguration().getColumnCount());
refreshCells(rowRange, colRange);
}
protected abstract void refreshCells(Range logicalRowRange,
Range colRange);
void refreshRow(TableRowElement tr, int logicalRowIndex) {
refreshRow(tr, logicalRowIndex, Range.withLength(0,
getColumnConfiguration().getColumnCount()));
}
void refreshRow(final TableRowElement tr, final int logicalRowIndex,
Range colRange) {
flyweightRow.setup(tr, logicalRowIndex,
columnConfiguration.getCalculatedColumnWidths());
Iterable
* Precondition: The row must be already attached to the DOM and the
* FlyweightCell instances corresponding to the new columns added to
* {@code flyweightRow}.
*
* @param tr
* the row in which to insert the cells
* @param logicalRowIndex
* the index of the row
* @param offset
* the index of the first cell
* @param numberOfCells
* the number of cells to insert
*/
private void paintInsertCells(final TableRowElement tr,
int logicalRowIndex, final int offset,
final int numberOfCells) {
assert root.isOrHasChild(
tr) : "The row must be attached to the document";
flyweightRow.setup(tr, logicalRowIndex,
columnConfiguration.getCalculatedColumnWidths());
Iterable
* In practice, this applies for all header and footer rows. For body
* rows, it applies for all rows except spacer rows.
*
* @since 7.5.0
*
* @param tr
* the row element to check whether it, or any of its its
* descendants can be frozen
* @return
* Note: In contrast to {@link #reapplyColumnWidths()}, this
* method only modifies the width of the {@code
*
* Make sure that the displayed rows with a default height are updated
* in height and top position.
*
* Note:This implementation should not call
* {@link Escalator#recalculateElementSizes()} - it is done by the
* discretion of the caller of this method.
*/
protected abstract void reapplyDefaultRowHeights();
protected void reapplyRowHeight(final TableRowElement tr,
final double heightPx) {
assert heightPx >= 0 : "Height must not be negative";
Element cellElem = tr.getFirstChildElement();
while (cellElem != null) {
cellElem.getStyle().setHeight(heightPx, Unit.PX);
cellElem = cellElem.getNextSiblingElement();
}
/*
* no need to apply height to tr-element, it'll be resized
* implicitly.
*/
}
protected void setRowPosition(final TableRowElement tr, final int x,
final double y) {
positions.set(tr, x, y);
}
/**
* Returns the assigned top position for the given element.
*
* Note: This method does not calculate what a row's top
* position should be. It just returns an assigned value, correct or
* not.
*
* @param tr
* the table row element to measure
* @return the current top position for {@code tr}
* @see BodyRowContainerImpl#getRowTop(int)
*/
protected double getRowTop(final TableRowElement tr) {
return positions.getTop(tr);
}
protected void removeRowPosition(TableRowElement tr) {
positions.remove(tr);
}
/**
* Triggers delayed auto-detection of default row height if it hasn't
* been set by that point and the Escalator is both attached and
* displayed.
*/
public void autodetectRowHeightLater() {
autodetectingRowHeightLater = true;
Scheduler.get().scheduleFinally(() -> {
if (defaultRowHeightShouldBeAutodetected && isAttached()
&& WidgetUtil.isDisplayed(getElement())) {
autodetectRowHeightNow();
defaultRowHeightShouldBeAutodetected = false;
}
autodetectingRowHeightLater = false;
});
}
@Override
public boolean isAutodetectingRowHeightLater() {
return autodetectingRowHeightLater;
}
private void fireRowHeightChangedEventFinally() {
if (!rowHeightChangedEventFired) {
rowHeightChangedEventFired = true;
Scheduler.get().scheduleFinally(() -> {
fireEvent(new RowHeightChangedEvent());
rowHeightChangedEventFired = false;
});
}
}
/**
* Auto-detect row height immediately, if possible. If Escalator isn't
* attached and displayed yet, auto-detecting cannot be performed
* correctly. In such cases auto-detecting is left to wait for these
* conditions to change, and will be performed when they do.
*/
public void autodetectRowHeightNow() {
if (!isAttached() || !WidgetUtil.isDisplayed(getElement())) {
// Run again when attached and displayed
defaultRowHeightShouldBeAutodetected = true;
return;
}
final double oldRowHeight = defaultRowHeight;
final Element detectionTr = DOM.createTR();
detectionTr.setClassName(getStylePrimaryName() + "-row");
final Element cellElem = DOM.createElement(getCellElementTagName());
cellElem.setClassName(getStylePrimaryName() + "-cell");
cellElem.setInnerText("Ij");
detectionTr.appendChild(cellElem);
root.appendChild(detectionTr);
double boundingHeight = getBoundingHeight(cellElem);
defaultRowHeight = Math.max(1.0d, boundingHeight);
root.removeChild(detectionTr);
if (root.hasChildNodes()) {
reapplyDefaultRowHeights();
applyHeightByRows();
}
if (oldRowHeight != defaultRowHeight) {
fireRowHeightChangedEventFinally();
}
}
@Override
public Cell getCell(final Element element) {
if (element == null) {
throw new IllegalArgumentException("Element cannot be null");
}
/*
* Ensure that element is not root nor the direct descendant of root
* (a row or spacer) and ensure the element is inside the dom
* hierarchy of the root element. If not, return null.
*/
if (root == element || element.getParentElement() == root
|| !root.isOrHasChild(element)) {
return null;
}
/*
* Ensure element is the cell element by iterating up the DOM
* hierarchy until reaching cell element.
*/
Element cellElementCandidate = element;
while (cellElementCandidate.getParentElement()
.getParentElement() != root) {
cellElementCandidate = cellElementCandidate.getParentElement();
}
final TableCellElement cellElement = TableCellElement
.as(cellElementCandidate);
// Find dom column
int domColumnIndex = -1;
for (Element e = cellElement; e != null; e = e
.getPreviousSiblingElement()) {
domColumnIndex++;
}
// Find dom row
int domRowIndex = -1;
for (Element e = cellElement.getParentElement(); e != null; e = e
.getPreviousSiblingElement()) {
domRowIndex++;
}
return new Cell(domRowIndex, domColumnIndex, cellElement);
}
double measureCellWidth(TableCellElement cell, boolean withContent) {
/*
* To get the actual width of the contents, we need to get the cell
* content without any hardcoded height or width.
*
* But we don't want to modify the existing column, because that
* might trigger some unnecessary listeners and whatnot. So,
* instead, we make a deep clone of that cell, but without any
* explicit dimensions, and measure that instead.
*/
TableCellElement cellClone = TableCellElement
.as((Element) cell.cloneNode(withContent));
cellClone.getStyle().clearHeight();
cellClone.getStyle().clearWidth();
cell.getParentElement().insertBefore(cellClone, cell);
double requiredWidth = getBoundingWidth(cellClone);
if (BrowserInfo.get().isIE()) {
/*
* IE browsers have some issues with subpixels. Occasionally
* content is overflown even if not necessary. Increase the
* counted required size by 0.01 just to be on the safe side.
*/
requiredWidth += 0.01;
}
cellClone.removeFromParent();
return requiredWidth;
}
/**
* Gets the minimum width needed to display the cell properly.
*
* @param colIndex
* index of column to measure
* @param withContent
*
* Note that {@link Escalator#getBody() the body} will calculate its
* height, while the others will return a precomputed value.
*
* @since 7.5.0
*
* @return the height of this table section
*/
protected abstract double getHeightOfSection();
/**
* Gets the logical row index for the given table row element.
*
* @param tr
* the table row element inside this container.
* @return the logical index of the given element
*/
public int getLogicalRowIndex(final TableRowElement tr) {
// Note: BodyRowContainerImpl overrides this behaviour, since the
// physical index and logical index don't match there. For header
// and footer there is a match.
return tr.getSectionRowIndex();
};
}
private abstract class AbstractStaticRowContainer
extends AbstractRowContainer {
/** The height of the combined rows in the DOM. Never negative. */
private double heightOfSection = 0;
public AbstractStaticRowContainer(
final TableSectionElement headElement) {
super(headElement);
}
@Override
public int getDomRowCount() {
return root.getChildCount();
}
@Override
protected void paintRemoveRows(final int index,
final int numberOfRows) {
for (int i = index; i < index + numberOfRows; i++) {
final TableRowElement tr = root.getRows().getItem(index);
paintRemoveRow(tr, index);
}
recalculateSectionHeight();
}
@Override
protected TableRowElement getTrByVisualIndex(final int index)
throws IndexOutOfBoundsException {
if (index >= 0 && index < root.getChildCount()) {
return root.getRows().getItem(index);
} else {
throw new IndexOutOfBoundsException(
"No such visual index: " + index);
}
}
@Override
public void insertRows(int index, int numberOfRows) {
super.insertRows(index, numberOfRows);
recalculateElementSizes();
applyHeightByRows();
}
@Override
public void removeRows(int index, int numberOfRows) {
/*
* While the rows in a static section are removed, the scrollbar is
* temporarily shrunk and then re-expanded. This leads to the fact
* that the scroll position is scooted up a bit. This means that we
* need to reset the position here.
*
* If Escalator, at some point, gets a JIT evaluation functionality,
* this re-setting is a strong candidate for removal.
*/
double oldScrollPos = verticalScrollbar.getScrollPos();
super.removeRows(index, numberOfRows);
recalculateElementSizes();
applyHeightByRows();
verticalScrollbar.setScrollPos(oldScrollPos);
}
@Override
protected void reapplyDefaultRowHeights() {
if (root.getChildCount() == 0) {
return;
}
Profiler.enter(
"Escalator.AbstractStaticRowContainer.reapplyDefaultRowHeights");
Element tr = root.getRows().getItem(0);
while (tr != null) {
reapplyRowHeight(TableRowElement.as(tr), getDefaultRowHeight());
tr = tr.getNextSiblingElement();
}
/*
* Because all rows are immediately displayed in the static row
* containers, the section's overall height has most probably
* changed.
*/
recalculateSectionHeight();
Profiler.leave(
"Escalator.AbstractStaticRowContainer.reapplyDefaultRowHeights");
}
@Override
protected void recalculateSectionHeight() {
Profiler.enter(
"Escalator.AbstractStaticRowContainer.recalculateSectionHeight");
double newHeight = calculateTotalRowHeight();
if (newHeight != heightOfSection) {
heightOfSection = newHeight;
sectionHeightCalculated();
/*
* We need to update the scrollbar dimension at this point. If
* we are scrolled too far down and the static section shrinks,
* the body will try to render rows that don't exist during
* body.verifyEscalatorCount. This is because the logical row
* indices are calculated from the scrollbar position.
*/
verticalScrollbar.setOffsetSize(
heightOfEscalator - header.getHeightOfSection()
- footer.getHeightOfSection());
body.verifyEscalatorCount();
body.spacerContainer.updateSpacerDecosVisibility();
}
Profiler.leave(
"Escalator.AbstractStaticRowContainer.recalculateSectionHeight");
}
/**
* Informs the row container that the height of its respective table
* section has changed.
*
* These calculations might affect some layouting logic, such as the
* body is being offset by the footer, the footer needs to be readjusted
* according to its height, and so on.
*
* A table section is either header, body or footer.
*/
protected abstract void sectionHeightCalculated();
@Override
protected void refreshCells(Range logicalRowRange, Range colRange) {
assertArgumentsAreValidAndWithinRange(logicalRowRange.getStart(),
logicalRowRange.length());
if (!isAttached()) {
return;
}
Profiler.enter("Escalator.AbstractStaticRowContainer.refreshCells");
if (hasColumnAndRowData()) {
for (int row = logicalRowRange.getStart(); row < logicalRowRange
.getEnd(); row++) {
final TableRowElement tr = getTrByVisualIndex(row);
refreshRow(tr, row, colRange);
}
}
Profiler.leave("Escalator.AbstractStaticRowContainer.refreshCells");
}
@Override
protected void paintInsertRows(int visualIndex, int numberOfRows) {
paintInsertStaticRows(visualIndex, numberOfRows);
}
@Override
protected boolean rowCanBeFrozen(TableRowElement tr) {
assert root.isOrHasChild(
tr) : "Row does not belong to this table section";
return true;
}
@Override
protected double getHeightOfSection() {
return Math.max(0, heightOfSection);
}
}
private class HeaderRowContainer extends AbstractStaticRowContainer {
public HeaderRowContainer(final TableSectionElement headElement) {
super(headElement);
}
@Override
protected void sectionHeightCalculated() {
double heightOfSection = getHeightOfSection();
bodyElem.getStyle().setMarginTop(heightOfSection, Unit.PX);
spacerDecoContainer.getStyle().setMarginTop(heightOfSection,
Unit.PX);
verticalScrollbar.getElement().getStyle().setTop(heightOfSection,
Unit.PX);
headerDeco.getStyle().setHeight(heightOfSection, Unit.PX);
}
@Override
protected String getCellElementTagName() {
return "th";
}
@Override
protected AriaGridRole getRowElementRole() {
return AriaGridRole.ROWHEADER;
}
@Override
protected AriaGridRole getCellElementRole() {
return AriaGridRole.COLUMNHEADER;
}
@Override
public void setStylePrimaryName(String primaryStyleName) {
super.setStylePrimaryName(primaryStyleName);
UIObject.setStylePrimaryName(root, primaryStyleName + "-header");
}
}
private class FooterRowContainer extends AbstractStaticRowContainer {
public FooterRowContainer(final TableSectionElement footElement) {
super(footElement);
}
@Override
public void setStylePrimaryName(String primaryStyleName) {
super.setStylePrimaryName(primaryStyleName);
UIObject.setStylePrimaryName(root, primaryStyleName + "-footer");
}
@Override
protected String getCellElementTagName() {
return "td";
}
@Override
protected void sectionHeightCalculated() {
double headerHeight = header.getHeightOfSection();
double footerHeight = footer.getHeightOfSection();
int vscrollHeight = (int) Math
.floor(heightOfEscalator - headerHeight - footerHeight);
final boolean horizontalScrollbarNeeded = columnConfiguration
.calculateRowWidth() > widthOfEscalator;
if (horizontalScrollbarNeeded) {
vscrollHeight -= horizontalScrollbar.getScrollbarThickness();
}
footerDeco.getStyle().setHeight(footer.getHeightOfSection(),
Unit.PX);
verticalScrollbar.setOffsetSize(vscrollHeight);
}
}
private class BodyRowContainerImpl extends AbstractRowContainer
implements BodyRowContainer {
/*
* TODO [[optimize]]: check whether a native JsArray might be faster
* than LinkedList
*/
/**
* The order in which row elements are rendered visually in the browser,
* with the help of CSS tricks. Usually has nothing to do with the DOM
* order.
*
* @see #sortDomElements()
*/
private final LinkedList
* NOTE: this is not necessarily the first dom row in the dom tree, just
* the one positioned to the top with CSS. See maintenance notes at the
* top of this class for further information.
*
* @param topRowLogicalIndex
* logical index of the first dom row in visual order, might
* not match the dom tree order
*/
private void setTopRowLogicalIndex(int topRowLogicalIndex) {
if (LogConfiguration.loggingIsEnabled(Level.INFO)) {
Logger.getLogger("Escalator.BodyRowContainer")
.fine("topRowLogicalIndex: " + this.topRowLogicalIndex
+ " -> " + topRowLogicalIndex);
}
assert topRowLogicalIndex >= 0 : "topRowLogicalIndex became negative (top left cell contents: "
+ visualRowOrder.getFirst().getCells().getItem(0)
.getInnerText()
+ ") ";
/*
* if there's a smart way of evaluating and asserting the max index,
* this would be a nice place to put it. I haven't found out an
* effective and generic solution.
*/
this.topRowLogicalIndex = topRowLogicalIndex;
}
/**
* Returns the logical index of the first dom row in visual order. This
* also gives the offset between the logical and visual indexes.
*
* NOTE: this is not necessarily the first dom row in the dom tree, just
* the one positioned to the top with CSS. See maintenance notes at the
* top of this class for further information.
*
* @return logical index of the first dom row in visual order, might not
* match the dom tree order
*/
public int getTopRowLogicalIndex() {
return topRowLogicalIndex;
}
/**
* Updates the logical index of the first dom row in visual order with
* the given difference.
*
* NOTE: this is not necessarily the first dom row in the dom tree, just
* the one positioned to the top with CSS. See maintenance notes at the
* top of this class for further information.
*
* @param diff
* the amount to increase or decrease the logical index of
* the first dom row in visual order
*/
private void updateTopRowLogicalIndex(int diff) {
setTopRowLogicalIndex(topRowLogicalIndex + diff);
}
private class DeferredDomSorter {
private static final int SORT_DELAY_MILLIS = 50;
// as it happens, 3 frames = 50ms @ 60fps.
private static final int REQUIRED_FRAMES_PASSED = 3;
private final AnimationCallback frameCounter = new AnimationCallback() {
@Override
public void execute(double timestamp) {
framesPassed++;
boolean domWasSorted = sortIfConditionsMet();
if (!domWasSorted) {
animationHandle = AnimationScheduler.get()
.requestAnimationFrame(this);
} else {
waiting = false;
}
}
};
private int framesPassed;
private double startTime;
private AnimationHandle animationHandle;
/**
* NOTE: This method should not be called directly from anywhere else.
*
* @param viewportOffsetTop
*/
private void recycleRowsUpOnScroll(double viewportOffsetTop) {
/*
* We can ignore spacers here, because we keep enough rows within
* the visual range to fill the viewport completely whether or not
* any spacers are shown. There is a small tradeoff of having some
* rows rendered even if they are outside of the viewport, but this
* simplifies the handling significantly (we can't know what height
* any individual spacer has before it has been rendered, which
* happens with a delay) and keeps the visual range size stable
* while scrolling. Consequently, even if there are spacers within
* the current visual range, repositioning this many rows won't
* cause us to run out of rows at the bottom.
*
* The viewportOffsetTop is positive and we round up, and
* visualRowOrder can't be empty since we are scrolling, so there is
* always going to be at least one row to move. There should also be
* one buffer row that actually falls outside of the viewport, in
* order to ensure that tabulator navigation works if the rows have
* components in them. The buffer row is only needed if filling the
* gap doesn't bring us to the top row already.
*/
int rowsToFillTheGap = (int) Math
.ceil(viewportOffsetTop / getDefaultRowHeight());
// ensure we don't try to move more rows than are available
// above
rowsToFillTheGap = Math.min(rowsToFillTheGap,
getTopRowLogicalIndex());
// add the buffer row if there is room for it
if (rowsToFillTheGap < getTopRowLogicalIndex()) {
++rowsToFillTheGap;
}
// we may have scrolled up past all the rows and beyond, can
// only recycle as many rows as we have
int rowsToRecycle = Math.min(rowsToFillTheGap,
visualRowOrder.size());
// select the rows to recycle from the end of the visual range
int end = visualRowOrder.size();
int start = end - rowsToRecycle;
/*
* Calculate the logical index for insertion point based on how many
* rows would be needed to fill the gap. Because we are recycling
* rows to the top the insertion index will also be the new top row
* logical index.
*/
int newTopRowLogicalIndex = getTopRowLogicalIndex()
- rowsToFillTheGap;
// recycle the rows and move them to their new positions
moveAndUpdateEscalatorRows(Range.between(start, end), 0,
newTopRowLogicalIndex);
setTopRowLogicalIndex(newTopRowLogicalIndex);
}
/**
* Recycling rows down for {@link #updateEscalatorRowsOnScroll()}.
*
* NOTE: This method should not be called directly from anywhere else.
*
* @param topElementPosition
* @param scrollTop
*/
private void recycleRowsDownOnScroll(double topElementPosition,
double scrollTop) {
/*
* It's better to have any extra rows below than above, so move as
* many of them as possible regardless of how many are needed to
* fill the gap, as long as one buffer row remains at the top. It
* should not be possible to scroll down enough to create a gap
* without it being possible to recycle rows to fill the gap, so
* viewport itself doesn't need adjusting no matter what.
*/
// we already have the rows and spacers here and we don't want
// to recycle rows that are going to stay visible, so the
// spacers have to be taken into account
double extraRowPxAbove = getRowHeightsSumBetweenPxExcludingSpacers(
topElementPosition, scrollTop);
// how many rows fit within that extra space and can be
// recycled, rounded towards zero to avoid moving any partially
// visible rows
int rowsToCoverTheExtra = (int) Math
.floor(extraRowPxAbove / getDefaultRowHeight());
// leave one to ensure there is a buffer row to help with tab
// navigation
if (rowsToCoverTheExtra > 0) {
--rowsToCoverTheExtra;
}
/*
* Don't move more rows than there are to move, but also don't move
* more rows than should exist at the bottom. However, it's not
* possible to scroll down beyond available rows, so there is always
* at least one row to recycle.
*/
int rowsToRecycle = Math.min(
Math.min(rowsToCoverTheExtra, visualRowOrder.size()),
getRowCount() - getTopRowLogicalIndex()
- visualRowOrder.size());
// are only some of the rows getting recycled instead of all
// of them
boolean partialMove = rowsToRecycle < visualRowOrder.size();
// calculate the logical index where the rows should be moved
int logicalTargetIndex;
if (partialMove) {
/*
* We scroll so little that we can just keep adding the rows
* immediately below the current escalator.
*/
logicalTargetIndex = getTopRowLogicalIndex()
+ visualRowOrder.size();
} else {
/*
* Since all escalator rows are getting recycled all spacers are
* going to get removed and the calculations have to ignore the
* spacers again in order to figure out which rows are to be
* displayed. In practice we may end up scrolling further down
* than the scroll position indicated initially as the spacers
* that get removed give room for more rows than expected.
*
* We can rely on calculations here because there won't be any
* old rows left to end up mismatched with.
*/
logicalTargetIndex = (int) Math
.floor(scrollTop / getDefaultRowHeight());
/*
* Make sure we don't try to move rows below the actual row
* count, even if some of the rows end up hidden at the top as a
* result. This won't leave us with any old rows in any case,
* because we already checked earlier that there is room to
* recycle all the rows. It's only a question of how the new
* visual range gets positioned in relation to the viewport.
*/
if (logicalTargetIndex
+ visualRowOrder.size() > getRowCount()) {
logicalTargetIndex = getRowCount() - visualRowOrder.size();
}
}
/*
* Recycle the rows and move them to their new positions. Since we
* are moving the viewport downwards, the visual target index is
* always at the bottom and matches the length of the visual range.
* Note: Due to how moveAndUpdateEscalatorRows works, this will work
* out even if we move all the rows, and try to place them
* "at the end".
*/
moveAndUpdateEscalatorRows(Range.between(0, rowsToRecycle),
visualRowOrder.size(), logicalTargetIndex);
// top row logical index needs to be updated differently
// depending on which update strategy was used, since the rows
// are being moved down
if (partialMove) {
// move down by the amount of recycled rows
updateTopRowLogicalIndex(rowsToRecycle);
} else {
// the insertion index is the new top row logical index
setTopRowLogicalIndex(logicalTargetIndex);
}
}
/**
* Calculates how much of the given range contains only rows with
* spacers excluded.
*
* @param y1
* start position
* @param y2
* end position
* @return position difference excluding any space taken up by spacers
*/
private double getRowHeightsSumBetweenPxExcludingSpacers(double y1,
double y2) {
assert y1 < y2 : "y1 must be smaller than y2";
double viewportPx = y2 - y1;
double spacerPx = spacerContainer.getSpacerHeightsSumBetweenPx(y1,
SpacerInclusionStrategy.PARTIAL, y2,
SpacerInclusionStrategy.PARTIAL);
return viewportPx - spacerPx;
}
@Override
public void insertRows(int index, int numberOfRows) {
insertingOrRemoving = true;
super.insertRows(index, numberOfRows);
insertingOrRemoving = false;
if (heightMode == HeightMode.UNDEFINED) {
setHeightByRows(getRowCount());
}
}
@Override
public void removeRows(int index, int numberOfRows) {
insertingOrRemoving = true;
super.removeRows(index, numberOfRows);
insertingOrRemoving = false;
if (heightMode == HeightMode.UNDEFINED) {
setHeightByRows(getRowCount());
}
}
@Override
protected void paintInsertRows(final int index,
final int numberOfRows) {
assert index >= 0
&& index < getRowCount() : "Attempting to insert a row "
+ "outside of the available range.";
assert numberOfRows > 0 : "Attempting to insert a non-positive "
+ "amount of rows, something must be wrong.";
if (numberOfRows <= 0) {
return;
}
/*
* NOTE: this method handles and manipulates logical, visual, and
* physical indexes a lot. If you don't remember what those mean and
* how they relate to each other, see the top of this class for
* Maintenance Notes.
*
* At the beginning of this method the logical index of the data
* provider has already been updated to include the new rows, but
* visual and physical indexes have not, nor has the spacer indexing
* been updated, and the topRowLogicalIndex may be out of date as
* well.
*/
// top of visible area before any rows are actually added
double scrollTop = getScrollTop();
// logical index of the first row within the visual range before any
// rows are actually added
int oldTopRowLogicalIndex = getTopRowLogicalIndex();
// length of the visual range before any rows are actually added
int oldVisualRangeLength = visualRowOrder.size();
/*
* If there is room for more dom rows within the maximum visual
* range, add them. Calling this method repositions all the rows and
* spacers below the insertion point and updates the spacer indexes
* accordingly.
*
* TODO: Details rows should be added and populated here, since they
* have variable heights and affect the position calculations.
* Currently that's left to be triggered at the end and with a
* delay. If any new spacers exist, everything below them is going
* to be repositioned again for every spacer addition.
*/
final List
* NOTE: This method should not be called directly from anywhere else.
*
* @param index
* @param numberOfRows
* @param oldTopRowLogicalIndex
*/
private void paintInsertRowsAboveViewPort(int index, int numberOfRows,
int oldTopRowLogicalIndex) {
/*
* Because there is no need to expand the visual range, no row or
* spacer contents get updated. All rows, spacers, and scroll
* position simply need to be shifted down accordingly and the
* spacer indexes need updating.
*/
spacerContainer.updateSpacerIndexesForRowAndAfter(index,
oldTopRowLogicalIndex + visualRowOrder.size(),
numberOfRows);
// height of a single row
double defaultRowHeight = getDefaultRowHeight();
// height of new rows, out of visual range so spacers assumed to
// have no height
double newRowsHeight = numberOfRows * defaultRowHeight;
// update the positions
moveViewportAndContent(index, newRowsHeight, newRowsHeight,
newRowsHeight);
// top row logical index moves down by the number of new rows
updateTopRowLogicalIndex(numberOfRows);
}
/**
* Row insertion handling for {@link #paintInsertRows(int, int)} when
* the range will be inserted within the visual range above the
* viewport.
*
* NOTE: This method should not be called directly from anywhere else.
*
* @param index
* @param numberOfRows
* @param oldTopRowLogicalIndex
* @param addedRowCount
*/
private void paintInsertRowsWithinVisualRangeButAboveViewport(int index,
int numberOfRows, int oldTopRowLogicalIndex,
int addedRowCount) {
/*
* Unless we are scrolled all the way to the top the visual range is
* always out of view because we need a buffer row for tabulator
* navigation. Depending on the scroll position and spacers there
* might even be several rendered rows above the viewport,
* especially when we are scrolled all the way to the bottom.
*
* Even though the new rows will be initially out of view they still
* need to be correctly populated and positioned. Their contents
* won't be refreshed if they become visible later on (e.g. when a
* spacer gets hidden, which causes more rows to fit within the
* viewport) because they are expected to be already up to date.
*
* Note that it's not possible to insert content so that it's
* partially visible at the top. A partially visible row at top will
* still be the exact same partially visible row after the
* insertion, no matter which side of that row the new content gets
* inserted to. This section handles the use case where the new
* content is inserted above the partially visible row.
*
* Because the insertion point is out of view above the viewport,
* the only thing that should change for the end user visually is
* the scroll handle, which gets a new position and possibly turns a
* bit smaller if a lot of rows got inserted.
*
* From a technical point of view this also means that any rows that
* might need to get recycled should be taken from the BEGINNING of
* the visual range, above the insertion point. There might still be
* some "extra" rows below the viewport as well, but those should be
* left alone. They are going to be needed where they are if any
* spacers get closed or reduced in size.
*
* On a practical level we need to tweak the virtual viewport --
* scroll handle positions, row and spacer positions, and ensure the
* scroll area height is calculated correctly. Viewport should
* remain in a fixed position in relation to the existing rows and
* display no new rows. If any rows get recycled and have spacers
* either before or after the update the height of those spacers
* affects the position calculations.
*
* Insertion point can be anywhere from just before the previous
* first row of the visual range to just before the first actually
* visible row. The insertion shifts down the content below
* insertion point, which excludes any dom rows that remain above
* the insertion point after recycling is finished. After the rows
* below insertion point have been moved the viewport needs to be
* shifted down a similar amount to regain its old relative position
* again.
*
* The visual range only ever contains at most as many rows as would
* fit within the viewport without any spacers with one extra row on
* both at the top and at the bottom as buffer rows, so the amount
* of rows that needs to be checked is always reasonably limited.
*/
// insertion index within the visual range
int visualTargetIndex = index - oldTopRowLogicalIndex;
// how many dom rows before insertion point versus how many new
// rows didn't get their own dom rows -- smaller amount
// determines how many rows can and need to be recycled
int rowsToUpdate = Math.min(visualTargetIndex,
numberOfRows - addedRowCount);
// height of a single row
double defaultRowHeight = getDefaultRowHeight();
boolean rowVisibilityChanged = false;
if (rowsToUpdate > 0) {
// recycle the rows and update the positions, adjust
// logical index for inserted rows that won't fit within
// visual range
int logicalIndex = index + numberOfRows - rowsToUpdate;
if (visualTargetIndex > 0) {
// move after any added dom rows
moveAndUpdateEscalatorRows(Range.between(0, rowsToUpdate),
visualTargetIndex + addedRowCount, logicalIndex);
} else {
// move before any added dom rows
moveAndUpdateEscalatorRows(Range.between(0, rowsToUpdate),
visualTargetIndex, logicalIndex);
}
// adjust viewport down to maintain the initial position
double newRowsHeight = numberOfRows * defaultRowHeight;
double newSpacerHeights = spacerContainer
.getSpacerHeightsSumUntilIndex(
logicalIndex + rowsToUpdate)
- spacerContainer.getSpacerHeightsSumUntilIndex(index);
/*
* FIXME: spacers haven't been added yet and they can cause
* escalator contents to shift after the fact in a way that
* can't be countered for here.
*
* FIXME: verticalScrollbar internal state causes this update to
* fail partially and the next attempt at scrolling causes
* things to jump.
*
* Couldn't find a quick fix to either problem and this use case
* is somewhat marginal so left them here for now.
*/
moveViewportAndContent(null, 0, 0,
newSpacerHeights + newRowsHeight);
rowVisibilityChanged = true;
} else {
// no rows to recycle but update the spacer indexes
spacerContainer.updateSpacerIndexesForRowAndAfter(index,
index + numberOfRows - addedRowCount,
numberOfRows - addedRowCount);
double newRowsHeight = numberOfRows * defaultRowHeight;
if (addedRowCount > 0) {
// update the viewport, rows and spacers were
// repositioned already by the method for adding dom
// rows
moveViewportAndContent(null, 0, 0, newRowsHeight);
rowVisibilityChanged = true;
} else {
// all changes are actually above the viewport after
// all, update all positions
moveViewportAndContent(index, newRowsHeight, newRowsHeight,
newRowsHeight);
}
}
if (numberOfRows > addedRowCount) {
/*
* If there are more new rows than how many new dom rows got
* added, the top row logical index necessarily gets shifted
* down by that difference because recycling doesn't replace any
* logical rows, just shifts them off the visual range, and the
* inserted rows that don't fit to the visual range also push
* the other rows down. If every new row got new dom rows as
* well the top row logical index doesn't change, because the
* insertion point was within the visual range.
*/
updateTopRowLogicalIndex(numberOfRows - addedRowCount);
}
if (rowVisibilityChanged) {
fireRowVisibilityChangeEvent();
}
if (rowsToUpdate > 0) {
// update the physical index
sortDomElements();
}
}
/**
* Row insertion handling for {@link #paintInsertRows(int, int)} when
* the range will be inserted within the visual range either within or
* below the viewport.
*
* NOTE: This method should not be called directly from anywhere else.
*
* @param index
* @param numberOfRows
* @param oldTopRowLogicalIndex
* @param addedRowCount
*/
private void paintInsertRowsWithinVisualRangeAndWithinOrBelowViewport(
int index, int numberOfRows, int oldTopRowLogicalIndex,
int addedRowCount) {
// insertion index within the visual range
int visualIndex = index - oldTopRowLogicalIndex;
// how many dom rows after insertion point versus how many new
// rows to add -- smaller amount determines how many rows can or
// need to be recycled, excluding the rows that already got new
// dom rows
int rowsToUpdate = Math.max(
Math.min(visualRowOrder.size() - visualIndex, numberOfRows)
- addedRowCount,
0);
if (rowsToUpdate > 0) {
moveAndUpdateEscalatorRows(
Range.between(visualRowOrder.size() - rowsToUpdate,
visualRowOrder.size()),
visualIndex + addedRowCount, index + addedRowCount);
fireRowVisibilityChangeEvent();
// update the physical index
sortDomElements();
}
}
/**
* Move escalator rows around, and make sure everything gets
* appropriately repositioned and repainted. In the case of insertion or
* removal, following spacer indexes get updated as well.
*
* @param visualSourceRange
* the range of rows to move to a new place
* @param visualTargetIndex
* the visual index where the rows will be placed to
* @param logicalTargetIndex
* the logical index to be assigned to the first moved row
*/
private void moveAndUpdateEscalatorRows(final Range visualSourceRange,
final int visualTargetIndex, final int logicalTargetIndex)
throws IllegalArgumentException {
if (visualSourceRange.isEmpty()) {
return;
}
int sourceRangeLength = visualSourceRange.length();
int domRowCount = getDomRowCount();
int rowCount = getRowCount();
assert visualSourceRange.getStart() >= 0 : "Visual source start "
+ "must be 0 or greater (was "
+ visualSourceRange.getStart() + ")";
assert logicalTargetIndex >= 0 : "Logical target must be 0 or "
+ "greater (was " + logicalTargetIndex + ")";
assert visualTargetIndex >= 0 : "Visual target must be 0 or greater (was "
+ visualTargetIndex + ")";
assert visualTargetIndex <= domRowCount : "Visual target "
+ "must not be greater than the number of escalator rows (was "
+ visualTargetIndex + ", escalator rows " + domRowCount
+ ")";
assert logicalTargetIndex
+ sourceRangeLength <= rowCount : "Logical "
+ "target leads to rows outside of the data range ("
+ Range.withLength(logicalTargetIndex,
sourceRangeLength)
+ " goes beyond " + Range.withLength(0, rowCount)
+ ")";
/*
* Since we move a range into another range, the indices might move
* about. Having 10 rows, if we move 0..1 to index 10 (to the end of
* the collection), the target range will end up being 8..9, instead
* of 10..11.
*
* This applies only if we move elements forward in the collection,
* not backward.
*/
final int adjustedVisualTargetIndex;
if (visualSourceRange.getStart() < visualTargetIndex) {
adjustedVisualTargetIndex = visualTargetIndex
- sourceRangeLength;
} else {
adjustedVisualTargetIndex = visualTargetIndex;
}
int oldTopRowLogicalIndex = getTopRowLogicalIndex();
// first moved row's logical index before move
int oldSourceRangeLogicalStart = oldTopRowLogicalIndex
+ visualSourceRange.getStart();
// new top row logical index
int newTopRowLogicalIndex = logicalTargetIndex
- adjustedVisualTargetIndex;
// variables for update types that require special handling
boolean recycledToTop = logicalTargetIndex < oldTopRowLogicalIndex;
boolean recycledFromTop = visualSourceRange.getStart() == 0;
boolean scrollingUp = recycledToTop
&& visualSourceRange.getEnd() == visualRowOrder.size();
boolean scrollingDown = recycledFromTop
&& logicalTargetIndex >= oldTopRowLogicalIndex
+ visualRowOrder.size();
if (visualSourceRange.getStart() != adjustedVisualTargetIndex) {
/*
* Reorder the rows to their correct places within
* visualRowOrder (unless rows are moved back to their original
* places)
*/
/*
* TODO [[optimize]]: move whichever set is smaller: the ones
* explicitly moved, or the others. So, with 10 escalator rows,
* if we are asked to move idx[0..8] to the end of the list,
* it's faster to just move idx[9] to the beginning.
*/
final List
* NOTE: This method should not be called directly from anywhere else.
*
* @param logicalTargetIndex
* @param adjustedVisualTargetIndex
* @param sourceRangeLength
* @param spacerHeightsBeforeMoveTotal
* @param oldSourceRangeLogicalStart
* @return the combined height of any removed spacers
*/
private double refreshRecycledRowContents(int logicalTargetIndex,
int adjustedVisualTargetIndex, int sourceRangeLength,
int oldSourceRangeLogicalStart) {
final ListIterator
* NOTE: This method should not be called directly from anywhere else.
*
* @param oldSourceRangeLogicalStart
* @param sourceRangeLength
* @param oldTopRowLogicalIndex
* @param newTopRowLogicalIndex
* @param recycledFromTop
*/
private void updateSpacerIndexesForMoveWhenRecycledToOrFromTop(
int oldSourceRangeLogicalStart, int sourceRangeLength,
int oldTopRowLogicalIndex, int newTopRowLogicalIndex,
boolean recycledFromTop) {
if (recycledFromTop) {
// first rows are getting recycled thanks to insertion or
// removal, all the indexes below need to be updated
// accordingly
int indexesToShift;
if (newTopRowLogicalIndex != oldTopRowLogicalIndex) {
indexesToShift = newTopRowLogicalIndex
- oldTopRowLogicalIndex;
} else {
indexesToShift = -sourceRangeLength;
}
spacerContainer.updateSpacerIndexesForRowAndAfter(
oldSourceRangeLogicalStart + sourceRangeLength,
oldTopRowLogicalIndex + visualRowOrder.size(),
indexesToShift);
} else {
// rows recycled to the top, move the remaining spacer
// indexes up
spacerContainer.updateSpacerIndexesForRowAndAfter(
oldSourceRangeLogicalStart + sourceRangeLength,
getRowCount() + sourceRangeLength, -sourceRangeLength);
}
}
/**
* Update the spacer indexes to correspond with logical indexes for
* {@link #moveAndUpdateEscalatorRows(Range, int, int)} when the move
* does not recycle rows to or from top
*
* NOTE: This method should not be called directly from anywhere else.
*
* @param logicalTargetIndex
* @param oldSourceRangeLogicalStart
* @param sourceRangeLength
* @param movedDown
*/
private void updateSpacerIndexesForMoveWhenNotRecycledToOrFromTop(
int logicalTargetIndex, int oldSourceRangeLogicalStart,
int sourceRangeLength, boolean movedDown) {
if (movedDown) {
// move the shifted spacer indexes up to fill the freed
// space
spacerContainer.updateSpacerIndexesForRowAndAfter(
oldSourceRangeLogicalStart + sourceRangeLength,
logicalTargetIndex + sourceRangeLength,
-sourceRangeLength);
} else {
// move the shifted spacer indexes down to fill the freed
// space
spacerContainer.updateSpacerIndexesForRowAndAfter(
logicalTargetIndex, oldSourceRangeLogicalStart,
sourceRangeLength);
}
}
/**
* Reposition the rows that were moved for
* {@link #moveAndUpdateEscalatorRows(Range, int, int)}
*
* NOTE: This method should not be called directly from anywhere else.
*
* @param adjustedVisualTargetIndex
* @param sourceRangeLength
* @param newTopRowLogicalIndex
*/
private void repositionMovedRows(int adjustedVisualTargetIndex,
int sourceRangeLength, int newTopRowLogicalIndex) {
int start = adjustedVisualTargetIndex;
updateRowPositions(newTopRowLogicalIndex + start, start,
sourceRangeLength);
}
/**
* Reposition the rows that were shifted by the move for
* {@link #moveAndUpdateEscalatorRows(Range, int, int)}
*
* NOTE: This method should not be called directly from anywhere else.
*
* @param visualSourceRange
* @param visualTargetIndex
* @param adjustedVisualTargetIndex
* @param newTopRowLogicalIndex
* @param scrollingDownAndNoSpacersRemoved
* @param scrollingUp
* @param recycledToTop
*/
private void repositionRowsShiftedByTheMove(Range visualSourceRange,
int visualTargetIndex, int adjustedVisualTargetIndex,
int newTopRowLogicalIndex,
boolean scrollingDownAndNoSpacersRemoved, boolean scrollingUp,
boolean recycledToTop) {
if (visualSourceRange.length() == visualRowOrder.size()) {
// all rows got updated and were repositioned already
return;
}
if (scrollingDownAndNoSpacersRemoved || scrollingUp) {
// scrolling, no spacers got removed from or added above any
// remaining rows so everything is where it belongs already
// (there is no check for added spacers because adding happens
// with delay, whether any spacers are coming or not they don't
// exist yet and thus can't be taken into account here)
return;
}
if (adjustedVisualTargetIndex != visualTargetIndex) {
// rows moved down, shifted rows need to be moved up
int start = visualSourceRange.getStart();
updateRowPositions(newTopRowLogicalIndex + start, start,
adjustedVisualTargetIndex - start);
} else {
// rows moved up, shifted rows need to be repositioned
// unless it's just a recycling and no spacer heights
// above got updated
if (recycledToTop) {
// rows below the shifted ones need to be moved up (which is
// done in the next helper method) but the shifted rows
// themselves are already where they belong
// (this should only be done if no spacers were added, but
// we can't know that yet so we'll have to adjust for them
// afterwards if any do appear)
return;
}
int start = adjustedVisualTargetIndex
+ visualSourceRange.length();
updateRowPositions(newTopRowLogicalIndex + start, start,
visualSourceRange.getEnd() - start);
}
}
/**
* If necessary, reposition the rows that are below those rows that got
* moved or shifted for
* {@link #moveAndUpdateEscalatorRows(Range, int, int)}
*
* NOTE: This method should not be called directly from anywhere else.
*
* @param visualSourceRange
* @param visualTargetIndex
* @param adjustedVisualTargetIndex
* @param newTopRowLogicalIndex
* @param scrolling
* @param recycledToOrFromTop
* @param spacerHeightsChanged
*/
private void repositionRowsBelowMovedAndShiftedIfNeeded(
Range visualSourceRange, int visualTargetIndex,
int adjustedVisualTargetIndex, int newTopRowLogicalIndex,
boolean scrolling, boolean recycledToOrFromTop,
boolean spacerHeightsChanged) {
/*
* There is no need to check if any rows preceding the source and
* target range need their positions adjusted, but rows below both
* may very well need it if spacer heights changed or rows got
* inserted or removed instead of just moved around.
*
* When scrolling to either direction all the rows already got
* processed by earlier stages, there are no unprocessed rows left
* either above or below.
*/
if (!scrolling && (recycledToOrFromTop || spacerHeightsChanged)) {
int firstBelow;
if (adjustedVisualTargetIndex != visualTargetIndex) {
// rows moved down
firstBelow = adjustedVisualTargetIndex
+ visualSourceRange.length();
} else {
// rows moved up
firstBelow = visualSourceRange.getEnd();
}
updateRowPositions(newTopRowLogicalIndex + firstBelow,
firstBelow, visualRowOrder.size() - firstBelow);
}
}
@Override
public void updateRowPositions(int index, int numberOfRows) {
Range visibleRowRange = getVisibleRowRange();
Range rangeToUpdate = Range.withLength(index, numberOfRows);
Range intersectingRange = visibleRowRange
.partitionWith(rangeToUpdate)[1];
if (intersectingRange.isEmpty()) {
// no overlap with the visual range, ignore the positioning
return;
}
int adjustedIndex = intersectingRange.getStart();
int adjustedVisualIndex = adjustedIndex - getTopRowLogicalIndex();
updateRowPositions(adjustedIndex, adjustedVisualIndex,
intersectingRange.length());
// make sure there is no unnecessary gap
adjustScrollPositionIfNeeded();
scroller.recalculateScrollbarsForVirtualViewport();
}
/**
* Re-calculates and updates the positions of rows and spacers within
* the given range. Doesn't touch the scroll positions.
*
* @param logicalIndex
* logical index of the first row to reposition
* @param visualIndex
* visual index of the first row to reposition
* @param numberOfRows
* the number of rows to reposition
*/
private void updateRowPositions(int logicalIndex, int visualIndex,
int numberOfRows) {
double newRowTop = getRowTop(logicalIndex);
for (int i = 0; i < numberOfRows; ++i) {
TableRowElement tr = visualRowOrder.get(visualIndex + i);
setRowPosition(tr, 0, newRowTop);
newRowTop += getDefaultRowHeight();
SpacerContainer.SpacerImpl spacer = spacerContainer
.getSpacer(logicalIndex + i);
if (spacer != null) {
spacer.setPosition(0, newRowTop);
newRowTop += spacer.getHeight();
}
}
}
/**
* Checks whether there is an unexpected gap below the visible rows and
* adjusts the viewport if necessary.
*/
private void adjustScrollPositionIfNeeded() {
double scrollTop = getScrollTop();
int firstBelowVisualRange = getTopRowLogicalIndex()
+ visualRowOrder.size();
double gapBelow = scrollTop + getHeightOfSection()
- getRowTop(firstBelowVisualRange);
boolean bufferRowNeeded = gapBelow == 0
&& firstBelowVisualRange < getRowCount();
if (scrollTop > 0 && (gapBelow > 0 || bufferRowNeeded)) {
/*
* This situation can be reached e.g. by removing a spacer.
* Scroll position must be adjusted accordingly but no more than
* there is room to scroll up. If a buffer row is needed make
* sure the last row ends up at least slightly below the
* viewport.
*/
double adjustedGap = Math.max(gapBelow,
bufferRowNeeded ? 1 : 0);
double yDeltaScroll = Math.min(adjustedGap, scrollTop);
moveViewportAndContent(null, 0, 0, -yDeltaScroll);
}
}
/**
* Adjust the scroll position and move the contained rows.
*
* The difference between using this method and simply scrolling is that
* this method "takes the rows and spacers with it" and renders them
* appropriately. The viewport may be scrolled any arbitrary amount, and
* the contents are moved appropriately, but always snapped into a
* plausible place.
*
*
* This method does not update spacer indexes.
*
* @param index
* the logical index from which forward the rows and spacers
* should be updated, or {@code null} if all of them
* @param yDeltaRows
* how much rows should be shifted in pixels
* @param yDeltaSpacers
* how much spacers should be shifted in pixels
* @param yDeltaScroll
* how much scroll position should be shifted in pixels
*/
private void moveViewportAndContent(Integer index,
final double yDeltaRows, final double yDeltaSpacers,
final double yDeltaScroll) {
if (!WidgetUtil.pixelValuesEqual(yDeltaScroll, 0d)) {
double newTop = tBodyScrollTop + yDeltaScroll;
verticalScrollbar.setScrollPos(newTop);
setBodyScrollPosition(tBodyScrollLeft, newTop);
}
if (!WidgetUtil.pixelValuesEqual(yDeltaSpacers, 0d)) {
Collection
* If Escalator already is at (or beyond) max capacity, this method does
* nothing to the DOM.
*
* Calling this method repositions all the rows and spacers below the
* insertion point.
*
* @param visualIndex
* the index at which to add new escalator rows to DOM
* @param logicalIndex
* the logical index that corresponds with the first new
* escalator row, should usually be the same as visual index
* because there is still need for new rows, but this is not
* always the case e.g. if row height is changed
* @param numberOfRows
* the number of rows to add at
* NOTE: This method should not be called directly from anywhere else.
*
* @param index
* @param numberOfRows
* @param oldTopRowLogicalIndex
* @param oldVisualRangeLength
* @param removedAboveLength
* @param removedLogicalWithin
*/
private void paintRemoveRowsWithinVisualRange(int index,
int numberOfRows, int oldTopRowLogicalIndex,
int oldVisualRangeLength, int removedAboveLength,
Range removedLogicalWithin) {
/*
* Calculating where the visual range should start after the
* removals is not entirely trivial.
*
* Initially, any rows removed from within the visual range won't
* affect the top index, even if they are removed from the
* beginning, as the rows are also removed from the logical index.
* Likewise we don't need to care about rows removed from below the
* visual range. On the other hand, any rows removed from above the
* visual range do shift the index down.
*
* However, in all of these cases, if there aren't enough rows below
* the visual range to replace the content removed from within the
* visual range, more rows need to be brought in from above the old
* visual range in turn. This shifts the index down even further.
*/
// scroll position before any rows or spacers are removed
double scrollTop = getScrollTop();
Range removedVisualWithin = convertToVisual(removedLogicalWithin);
int remainingVisualRangeRowCount = visualRowOrder.size()
- removedVisualWithin.length();
int newTopRowLogicalIndex = oldTopRowLogicalIndex
- removedAboveLength;
int rowsToIncludeFromBelow = Math.min(
getRowCount() - newTopRowLogicalIndex
- remainingVisualRangeRowCount,
removedLogicalWithin.length());
int rowsToIncludeFromAbove = removedLogicalWithin.length()
- rowsToIncludeFromBelow;
int rowsToRemoveFromDom = 0;
if (rowsToIncludeFromAbove > 0) {
// don't try to bring in more rows than exist, it's possible
// to remove enough rows that visual range won't be full
// anymore
rowsToRemoveFromDom = Math
.max(rowsToIncludeFromAbove - newTopRowLogicalIndex, 0);
rowsToIncludeFromAbove -= rowsToRemoveFromDom;
newTopRowLogicalIndex -= rowsToIncludeFromAbove;
}
int visualIndexToRemove = Math.max(index - oldTopRowLogicalIndex,
0);
// remove extra dom rows and their spacers if any
double removedFromDomSpacerHeights = 0d;
if (rowsToRemoveFromDom > 0) {
for (int i = 0; i < rowsToRemoveFromDom; ++i) {
TableRowElement tr = visualRowOrder
.remove(visualIndexToRemove);
// logical index of this row before anything got removed
int logicalRowIndex = oldTopRowLogicalIndex
+ visualIndexToRemove + i;
double spacerHeight = spacerContainer
.getSpacerHeight(logicalRowIndex);
removedFromDomSpacerHeights += spacerHeight;
spacerContainer.removeSpacer(logicalRowIndex);
paintRemoveRow(tr, removedVisualWithin.getStart());
removeRowPosition(tr);
}
// update the associated row indexes for remaining spacers,
// even for those rows that are going to get recycled
spacerContainer.updateSpacerIndexesForRowAndAfter(
oldTopRowLogicalIndex + visualIndexToRemove
+ rowsToRemoveFromDom,
oldTopRowLogicalIndex + oldVisualRangeLength,
-rowsToRemoveFromDom);
}
// add new content from below visual range, if there is any
if (rowsToIncludeFromBelow > 0) {
// removed rows are recycled to just below the old visual
// range, calculate the logical index of the insertion
// point that is just below the existing rows, taking into
// account that the indexing has changed with the removal
int firstBelow = newTopRowLogicalIndex + rowsToIncludeFromAbove
+ remainingVisualRangeRowCount;
moveAndUpdateEscalatorRows(
Range.withLength(visualIndexToRemove,
rowsToIncludeFromBelow),
visualRowOrder.size(), firstBelow);
}
// add new content from above visual range, if there is any
// -- this is left last because most of the time it isn't even
// needed
if (rowsToIncludeFromAbove > 0) {
moveAndUpdateEscalatorRows(
Range.withLength(visualIndexToRemove,
rowsToIncludeFromAbove),
0, newTopRowLogicalIndex);
}
// recycling updates all relevant row and spacer positions but
// if we only removed DOM rows and didn't recycle any we still
// need to shift up the rows below the removal point
if (rowsToIncludeFromAbove <= 0 && rowsToIncludeFromBelow <= 0) {
// update the positions for the rows and spacers below the
// removed ones, assume there is no need to update scroll
// position since the final check adjusts that if needed
double yDelta = numberOfRows * getDefaultRowHeight()
+ removedFromDomSpacerHeights;
moveViewportAndContent(
newTopRowLogicalIndex + visualIndexToRemove, -yDelta,
-yDelta, 0);
}
setTopRowLogicalIndex(newTopRowLogicalIndex);
scroller.recalculateScrollbarsForVirtualViewport();
// calling this method also triggers adding new spacers to the
// recycled rows, if any are needed
fireRowVisibilityChangeEvent();
// populating the spacers might take a while, delay calculations
// or the viewport might get adjusted too high
Scheduler.get().scheduleFinally(() -> {
// make sure there isn't a gap at the bottom after removal
// and adjust the viewport if there is
// FIXME: this should be doable with
// adjustScrollPositionIfNeeded() but it uses current
// scrollTop, which may have ended in wrong position and
// results in assuming too big gap and consequently
// scrolling up too much
double extraSpaceAtBottom = scrollTop + getHeightOfSection()
- getRowTop(getTopRowLogicalIndex()
+ visualRowOrder.size());
if (extraSpaceAtBottom > 0 && scrollTop > 0) {
// we need to move the viewport up to adjust, while the
// rows and spacers can remain where they are
double yDeltaScroll = Math.min(extraSpaceAtBottom,
scrollTop);
moveViewportAndContent(null, 0, 0, -yDeltaScroll);
}
});
// update physical index
sortDomElements();
}
@Override
public int getLogicalRowIndex(final TableRowElement tr) {
assert tr
.getParentNode() == root : "The given element isn't a row element in the body";
int internalIndex = visualRowOrder.indexOf(tr);
return getTopRowLogicalIndex() + internalIndex;
}
@Override
protected void recalculateSectionHeight() {
// NOOP for body, since it doesn't make any sense.
}
/**
* Adjusts the row index and number to be relevant for the current
* virtual viewport.
*
* It converts a logical range of rows index to the matching visual
* range, truncating the resulting range with the viewport.
*
*
* This method should be called when e.g. the height of the Escalator
* changes.
*
* Note: This method will make sure that the escalator rows are
* placed in the proper places. By default new rows are added below, but
* if the content is scrolled down, the rows are populated on top
* instead.
*/
public void verifyEscalatorCount() {
/*
* This method indeed has a smell very similar to paintRemoveRows
* and paintInsertRows.
*
* Unfortunately, the code of those can't trivially be shared, since
* there are some slight differences in the respective
* responsibilities. The "paint" methods fake the addition and
* removal of rows, and make sure to either push existing data out
* of view, or draw new data into view. Only in some special cases
* will the DOM element count change.
*
* This method, however, has the explicit responsibility to verify
* that when "something" happens, we still have the correct amount
* of escalator rows in the DOM, and if not, we make sure to modify
* that count. Only in some special cases do we need to take into
* account other things than simply modifying the DOM element count.
*/
Profiler.enter("Escalator.BodyRowContainer.verifyEscalatorCount");
if (!isAttached()) {
return;
}
int oldTopRowLogicalIndex = getTopRowLogicalIndex();
int oldVisualRangeLength = visualRowOrder.size();
final int maxVisibleRowCount = getMaxVisibleRowCount();
final int neededEscalatorRows = Math.min(maxVisibleRowCount,
body.getRowCount());
final int rowDiff = neededEscalatorRows - oldVisualRangeLength;
if (rowDiff > 0) {
// more rows are needed
// calculate the indexes for adding rows below the last row of
// the visual range
final int visualTargetIndex = oldVisualRangeLength;
final int logicalTargetIndex;
if (!visualRowOrder.isEmpty()) {
logicalTargetIndex = oldTopRowLogicalIndex
+ visualTargetIndex;
} else {
logicalTargetIndex = 0;
}
// prioritise adding to the bottom so that there's less chance
// for a gap if a details row is later closed (e.g. by user)
final int addToBottom = Math.min(rowDiff,
getRowCount() - logicalTargetIndex);
final int addToTop = rowDiff - addToBottom;
if (addToTop > 0) {
fillAndPopulateEscalatorRowsIfNeeded(0,
oldTopRowLogicalIndex - addToTop, addToTop);
updateTopRowLogicalIndex(-addToTop);
}
if (addToBottom > 0) {
fillAndPopulateEscalatorRowsIfNeeded(visualTargetIndex,
logicalTargetIndex, addToBottom);
}
} else if (rowDiff < 0) {
// rows need to be removed
// prioritise removing rows from above the viewport as they are
// less likely to be needed in a hurry -- the rows below are
// more likely to slide into view when spacer contents are
// updated
// top of visible area before any rows are actually added
double scrollTop = getScrollTop();
// visual index of the first actually visible row, including
// spacer
int oldFirstVisibleVisualIndex = -1;
ListIterator
* This method relies on fixed row height (by
* {@link #getDefaultRowHeight()}) and can only take into account
* spacers that are within visual range. Any scrolling might invalidate
* these results, so this method shouldn't be used to estimate scroll
* positions.
*
* @param logicalIndex
* the logical index of the row for which to calculate the
* top position
* @return the position where the row should currently be, were it to
* exist
* @see #getRowTop(TableRowElement)
*/
private double getRowTop(int logicalIndex) {
double top = spacerContainer
.getSpacerHeightsSumUntilIndex(logicalIndex);
return top + (logicalIndex * getDefaultRowHeight());
}
public void shiftRowPositions(int row, double diff) {
for (TableRowElement tr : getVisibleRowsAfter(row)) {
setRowPosition(tr, 0, getRowTop(tr) + diff);
}
}
private List
* Called by {@link Escalator#onLoad()}.
*/
public boolean measureAndSetWidthIfNeeded() {
assert isAttached() : "Column.measureAndSetWidthIfNeeded() was called even though Escalator was not attached!";
if (measuringRequested) {
measuringRequested = false;
setWidth(definedWidth);
return true;
}
return false;
}
private void calculateWidth() {
calculatedWidth = getMaxCellWidth(columns.indexOf(this));
}
}
private final List
* Implementation detail: This method does no DOM modifications
* (i.e. is very cheap to call) if there are no rows in the DOM when
* this method is called.
*
* @see #hasSomethingInDom()
*/
@Override
public void removeColumns(final int index, final int numberOfColumns) {
if (numberOfColumns == 0) {
return;
}
// Validate
assertArgumentsAreValidAndWithinRange(index, numberOfColumns);
// Move the horizontal scrollbar to the left, if removed columns are
// to the left of the viewport
removeColumnsAdjustScrollbar(index, numberOfColumns);
// Remove from DOM
header.paintRemoveColumns(index, numberOfColumns);
body.paintRemoveColumns(index, numberOfColumns);
footer.paintRemoveColumns(index, numberOfColumns);
// Remove from bookkeeping
flyweightRow.removeCells(index, numberOfColumns);
columns.subList(index, index + numberOfColumns).clear();
// Adjust frozen columns
if (index < getFrozenColumnCount()) {
if (index + numberOfColumns < frozenColumns) {
/*
* Last removed column was frozen, meaning that all removed
* columns were frozen. Just decrement the number of frozen
* columns accordingly.
*/
frozenColumns -= numberOfColumns;
} else {
/*
* If last removed column was not frozen, we have removed
* columns beyond the frozen range, so all remaining frozen
* columns are to the left of the removed columns.
*/
frozenColumns = index;
}
}
scroller.recalculateScrollbarsForVirtualViewport();
body.verifyEscalatorCount();
if (getColumnConfiguration().getColumnCount() > 0) {
reapplyRowWidths(header);
reapplyRowWidths(body);
reapplyRowWidths(footer);
}
/*
* Colspans make any kind of automatic clever content re-rendering
* impossible: As soon as anything has colspans, removing one might
* reveal further colspans, modifying the DOM structure once again,
* ending in a cascade of updates. Because we don't know how the
* data is updated.
*
* So, instead, we don't do anything. The client code is responsible
* for re-rendering the content (if so desired). Everything Just
* Works (TM) if colspans aren't used.
*/
}
private void reapplyRowWidths(AbstractRowContainer container) {
if (container.getRowCount() > 0) {
container.reapplyRowWidths();
}
}
private void removeColumnsAdjustScrollbar(int index,
int numberOfColumns) {
if (horizontalScrollbar.getOffsetSize() >= horizontalScrollbar
.getScrollSize()) {
return;
}
double leftPosOfFirstColumnToRemove = getCalculatedColumnsWidth(
Range.between(0, index));
double widthOfColumnsToRemove = getCalculatedColumnsWidth(
Range.withLength(index, numberOfColumns));
double scrollLeft = horizontalScrollbar.getScrollPos();
if (scrollLeft <= leftPosOfFirstColumnToRemove) {
/*
* viewport is scrolled to the left of the first removed column,
* so there's no need to adjust anything
*/
return;
}
double adjustedScrollLeft = Math.max(leftPosOfFirstColumnToRemove,
scrollLeft - widthOfColumnsToRemove);
horizontalScrollbar.setScrollPos(adjustedScrollLeft);
}
/**
* Calculate the width of a row, as the sum of columns' widths.
*
* @return the width of a row, in pixels
*/
public double calculateRowWidth() {
return getCalculatedColumnsWidth(
Range.between(0, getColumnCount()));
}
private void assertArgumentsAreValidAndWithinRange(final int index,
final int numberOfColumns) {
if (numberOfColumns < 1) {
throw new IllegalArgumentException(
"Number of columns can't be less than 1 (was "
+ numberOfColumns + ")");
}
if (index < 0 || index + numberOfColumns > getColumnCount()) {
throw new IndexOutOfBoundsException("The given "
+ "column range (" + index + ".."
+ (index + numberOfColumns)
+ ") was outside of the current "
+ "number of columns (" + getColumnCount() + ")");
}
}
/**
* {@inheritDoc}
*
* Implementation detail: This method does no DOM modifications
* (i.e. is very cheap to call) if there is no data for rows when this
* method is called.
*
* @see #hasColumnAndRowData()
*/
@Override
public void insertColumns(final int index, final int numberOfColumns) {
if (numberOfColumns == 0) {
return;
}
// Validate
if (index < 0 || index > getColumnCount()) {
throw new IndexOutOfBoundsException("The given index(" + index
+ ") was outside of the current number of columns (0.."
+ getColumnCount() + ")");
}
if (numberOfColumns < 1) {
throw new IllegalArgumentException(
"Number of columns must be 1 or greater (was "
+ numberOfColumns);
}
// Add to bookkeeping
flyweightRow.addCells(index, numberOfColumns);
for (int i = 0; i < numberOfColumns; i++) {
columns.add(index, new Column());
}
// Adjust frozen columns
boolean frozen = index < frozenColumns;
if (frozen) {
frozenColumns += numberOfColumns;
}
// Add to DOM
header.paintInsertColumns(index, numberOfColumns, frozen);
body.paintInsertColumns(index, numberOfColumns, frozen);
footer.paintInsertColumns(index, numberOfColumns, frozen);
// this needs to be before the scrollbar adjustment.
boolean scrollbarWasNeeded = horizontalScrollbar
.getOffsetSize() < horizontalScrollbar.getScrollSize();
scroller.recalculateScrollbarsForVirtualViewport();
boolean scrollbarIsNowNeeded = horizontalScrollbar
.getOffsetSize() < horizontalScrollbar.getScrollSize();
if (!scrollbarWasNeeded && scrollbarIsNowNeeded) {
// This might as a side effect move rows around (when scrolled
// all the way down) and require the DOM to be up to date, i.e.
// the column to be added
body.verifyEscalatorCount();
}
// fix initial width
if (header.getRowCount() > 0 || body.getRowCount() > 0
|| footer.getRowCount() > 0) {
Map
* The meaning of each value may differ depending on the context it is being
* used in. Check that particular method's JavaDoc.
*/
private enum SpacerInclusionStrategy {
/** A representation of "the entire spacer". */
COMPLETE,
/** A representation of "a partial spacer". */
PARTIAL,
/** A representation of "no spacer at all". */
NONE
}
private class SpacerContainer {
/** This is used mainly for testing purposes */
private static final String SPACER_LOGICAL_ROW_PROPERTY = "vLogicalRow";
private final class SpacerImpl implements Spacer {
private TableCellElement spacerElement;
private TableRowElement root;
private DivElement deco;
private int rowIndex;
private double height = -1;
private boolean domHasBeenSetup = false;
private double decoHeight;
private double defaultCellBorderBottomSize = -1;
public SpacerImpl(int rowIndex) {
this.rowIndex = rowIndex;
root = TableRowElement.as(DOM.createTR());
spacerElement = TableCellElement.as(DOM.createTD());
root.appendChild(spacerElement);
root.setPropertyInt(SPACER_LOGICAL_ROW_PROPERTY, rowIndex);
deco = DivElement.as(DOM.createDiv());
}
public void setPositionDiff(double x, double y) {
setPosition(getLeft() + x, getTop() + y);
}
public void setupDom(double height) {
assert !domHasBeenSetup : "DOM can't be set up twice.";
assert RootPanel.get().getElement().isOrHasChild(
root) : "Root element should've been attached to the DOM by now.";
domHasBeenSetup = true;
getRootElement().getStyle().setWidth(getInnerWidth(), Unit.PX);
setHeight(height);
spacerElement
.setColSpan(getColumnConfiguration().getColumnCount());
setStylePrimaryName(getStylePrimaryName());
}
public TableRowElement getRootElement() {
return root;
}
@Override
public Element getDecoElement() {
return deco;
}
public void setPosition(double x, double y) {
positions.set(getRootElement(), x, y);
positions.set(getDecoElement(), 0,
y - getSpacerDecoTopOffset());
}
private double getSpacerDecoTopOffset() {
return getBody().getDefaultRowHeight();
}
public void setStylePrimaryName(String style) {
UIObject.setStylePrimaryName(root, style + "-spacer");
UIObject.setStylePrimaryName(deco, style + "-spacer-deco");
}
/**
* Clear spacer height without moving other contents.
*
* @see #setHeight(double)
*/
private void clearHeight() {
height = 0;
root.getStyle().setHeight(0, Unit.PX);
updateDecoratorGeometry(0);
}
public void setHeight(double height) {
assert height >= 0 : "Height must be more >= 0 (was " + height
+ ")";
final double heightDiff = height - Math.max(0, this.height);
final double oldHeight = this.height;
this.height = height;
// since the spacer might be rendered on top of the previous
// rows border (done with css), need to increase height the
// amount of the border thickness
if (defaultCellBorderBottomSize < 0) {
defaultCellBorderBottomSize = WidgetUtil
.getBorderBottomThickness(body
.getRowElement(
getVisibleRowRange().getStart())
.getFirstChildElement());
}
root.getStyle().setHeight(height + defaultCellBorderBottomSize,
Unit.PX);
// move the visible spacers getRow row onwards.
shiftSpacerPositionsAfterRow(getRow(), heightDiff);
/*
* If we're growing, we'll adjust the scroll size first, then
* adjust scrolling. If we're shrinking, we do it after the
* second if-clause.
*/
boolean spacerIsGrowing = heightDiff > 0;
if (spacerIsGrowing) {
verticalScrollbar.setScrollSize(
verticalScrollbar.getScrollSize() + heightDiff);
}
/*
* Don't modify the scrollbars if we're expanding the -1 spacer
* while we're scrolled to the top.
*/
boolean minusOneSpacerException = spacerIsGrowing
&& getRow() == -1 && body.getTopRowLogicalIndex() == 0;
boolean viewportNeedsScrolling = getRow() < body
.getTopRowLogicalIndex() && !minusOneSpacerException;
if (viewportNeedsScrolling) {
/*
* We can't use adjustScrollPos here, probably because of a
* bookkeeping-related race condition.
*
* This particular situation is easier, however, since we
* know exactly how many pixels we need to move (heightDiff)
* and all elements below the spacer always need to move
* that pixel amount.
*/
for (TableRowElement row : body.visualRowOrder) {
body.setRowPosition(row, 0,
body.getRowTop(row) + heightDiff);
}
double top = getTop();
double bottom = top + oldHeight;
double scrollTop = verticalScrollbar.getScrollPos();
boolean viewportTopIsAtMidSpacer = top < scrollTop
&& scrollTop < bottom;
final double moveDiff;
if (viewportTopIsAtMidSpacer && !spacerIsGrowing) {
/*
* If the scroll top is in the middle of the modified
* spacer, we want to scroll the viewport up as usual,
* but we don't want to scroll past the top of it.
*
* Math.max ensures this (remember: the result is going
* to be negative).
*/
moveDiff = Math.max(heightDiff, top - scrollTop);
} else {
moveDiff = heightDiff;
}
body.setBodyScrollPosition(tBodyScrollLeft,
tBodyScrollTop + moveDiff);
verticalScrollbar.setScrollPosByDelta(moveDiff);
} else {
body.shiftRowPositions(getRow(), heightDiff);
}
if (!spacerIsGrowing) {
verticalScrollbar.setScrollSize(
verticalScrollbar.getScrollSize() + heightDiff);
}
updateDecoratorGeometry(height);
}
/** Resizes and places the decorator. */
private void updateDecoratorGeometry(double detailsHeight) {
Style style = deco.getStyle();
decoHeight = detailsHeight + getBody().getDefaultRowHeight();
style.setHeight(decoHeight, Unit.PX);
}
@Override
public Element getElement() {
return spacerElement;
}
@Override
public int getRow() {
return rowIndex;
}
public double getHeight() {
assert height >= 0 : "Height was not previously set by setHeight.";
return height;
}
public double getTop() {
return positions.getTop(getRootElement());
}
public double getLeft() {
return positions.getLeft(getRootElement());
}
/**
* Sets a new row index for this spacer. Also updates the
* bookkeeping at {@link SpacerContainer#rowIndexToSpacer}.
*/
@SuppressWarnings("boxing")
public void setRowIndex(int rowIndex) {
SpacerImpl spacer = rowIndexToSpacer.remove(this.rowIndex);
assert this == spacer : "trying to move an unexpected spacer.";
int oldIndex = this.rowIndex;
this.rowIndex = rowIndex;
root.setPropertyInt(SPACER_LOGICAL_ROW_PROPERTY, rowIndex);
rowIndexToSpacer.put(this.rowIndex, this);
fireEvent(new SpacerIndexChangedEvent(oldIndex, this.rowIndex));
}
/**
* Updates the spacer's visibility parameters, based on whether it
* is being currently visible or not.
*
* @deprecated Escalator no longer uses this logic at initialisation
* as there can only be a limited number of spacers and
* hidden spacers within visual range interfere with
* position calculations.
*/
@Deprecated
public void updateVisibility() {
if (isInViewport()) {
show();
} else {
hide();
}
}
private boolean isInViewport() {
int top = (int) Math.ceil(getTop());
int height = (int) Math.floor(getHeight());
Range location = Range.withLength(top, height);
return getViewportPixels().intersects(location);
}
public void show() {
getRootElement().getStyle().clearDisplay();
getDecoElement().getStyle().clearDisplay();
fireEvent(new SpacerVisibilityChangedEvent(getRow(), true));
}
public void hide() {
getRootElement().getStyle().setDisplay(Display.NONE);
getDecoElement().getStyle().setDisplay(Display.NONE);
fireEvent(new SpacerVisibilityChangedEvent(getRow(), false));
}
/**
* Crop the decorator element so that it doesn't overlap the header
* and footer sections.
*
* @param bodyTop
* the top cordinate of the escalator body
* @param bodyBottom
* the bottom cordinate of the escalator body
* @param decoWidth
* width of the deco
*/
private void updateDecoClip(final double bodyTop,
final double bodyBottom, final double decoWidth) {
final int top = deco.getAbsoluteTop();
final int bottom = deco.getAbsoluteBottom();
/*
* FIXME
*
* Height and its use is a workaround for the issue where
* coordinates of the deco are not calculated yet. This will
* prevent a deco from being displayed when it's added to DOM
*/
final int height = bottom - top;
if (top < bodyTop || bottom > bodyBottom) {
final double topClip = Math.max(0.0D, bodyTop - top);
final double bottomClip = height
- Math.max(0.0D, bottom - bodyBottom);
// TODO [optimize] not sure how GWT compiles this
final String clip = new StringBuilder("rect(")
.append(topClip).append("px,").append(decoWidth)
.append("px,").append(bottomClip).append("px,0)")
.toString();
deco.getStyle().setProperty("clip", clip);
} else {
deco.getStyle().setProperty("clip", "auto");
}
}
}
private final TreeMap
* NOTE: Changed functionality since 8.9. Previous incarnation of this
* method updated the positions of all the contents below the first
* removed spacer.
*
* @param removedRange
* logical range of spacers to remove
*/
@SuppressWarnings("boxing")
public void removeSpacers(Range removedRange) {
Map
*
* In this method, the {@link SpacerInclusionStrategy} has the following
* meaning when a spacer lies in the middle of either pixel argument:
*
* In this method, the {@link SpacerInclusionStrategy} has the following
* meaning when a spacer lies in the middle of either pixel argument:
*
* This moves both their associated logical row index and also their
* visual placement.
*
* Note: This method does not check for the validity of any
* arguments.
*
* @param index
* the index of first row to move
* @param numberOfRows
* the number of rows to shift the spacers with. A positive
* value is downwards, a negative value is upwards.
*/
public void shiftSpacersByRows(int index, int numberOfRows) {
final double pxDiff = numberOfRows * body.getDefaultRowHeight();
List
* Note: This method does not check for the validity of any
* arguments.
*
* @param startIndex
* the previous logical index of first row to update
* @param endIndex
* the previous logical index of first row that doesn't need
* updating anymore
* @param numberOfRows
* the number of rows to shift the associated logical index
* with. A positive value is downwards, a negative value is
* upwards.
*/
private void updateSpacerIndexesForRowAndAfter(int startIndex,
int endIndex, int numberOfRows) {
List
* This constant is placed in the Escalator class, instead of an inner
* class, since even mathematical expressions aren't allowed in non-static
* inner classes for constants.
*/
private static final double RATIO_OF_30_DEGREES = 1 / Math.sqrt(3);
/**
* The solution to
*
* This constant is placed in the Escalator class, instead of an inner
* class, since even mathematical expressions aren't allowed in non-static
* inner classes for constants.
*/
private static final double RATIO_OF_40_DEGREES = Math.tan(2 * Math.PI / 9);
private static final String DEFAULT_WIDTH = "500.0px";
private static final String DEFAULT_HEIGHT = "400.0px";
private FlyweightRow flyweightRow = new FlyweightRow();
/** The {@code } tag. */
private final TableSectionElement headElem = TableSectionElement
.as(DOM.createTHead());
/** The {@code
* If Escalator is currently not in {@link HeightMode#CSS}, the given value
* is remembered, and applied once the mode is applied.
*
* @see #setHeightMode(HeightMode)
*/
@Override
public void setHeight(String height) {
/*
* TODO remove method once RequiresResize and the Vaadin layoutmanager
* listening mechanisms are implemented
*/
if (height != null && !height.isEmpty()) {
heightByCss = height;
} else {
if (getHeightMode() == HeightMode.UNDEFINED) {
heightByRows = body.getRowCount();
applyHeightByRows();
return;
} else {
heightByCss = DEFAULT_HEIGHT;
}
}
if (getHeightMode() == HeightMode.CSS) {
setHeightInternal(height);
}
}
private void setHeightInternal(final String height) {
final int escalatorRowsBefore = body.visualRowOrder.size();
if (height != null && !height.isEmpty()) {
super.setHeight(height);
} else {
if (getHeightMode() == HeightMode.UNDEFINED) {
int newHeightByRows = body.getRowCount();
if (heightByRows != newHeightByRows) {
heightByRows = newHeightByRows;
applyHeightByRows();
}
return;
} else {
super.setHeight(DEFAULT_HEIGHT);
}
}
recalculateElementSizes();
if (escalatorRowsBefore != body.visualRowOrder.size()) {
fireRowVisibilityChangeEvent();
}
}
/**
* Returns the vertical scroll offset. Note that this is not necessarily the
* same as the {@code scrollTop} attribute in the DOM.
*
* @return the logical vertical scroll offset
*/
public double getScrollTop() {
return verticalScrollbar.getScrollPos();
}
/**
* Sets the vertical scroll offset. Note that this will not necessarily
* become the same as the {@code scrollTop} attribute in the DOM.
*
* @param scrollTop
* the number of pixels to scroll vertically
*/
public void setScrollTop(final double scrollTop) {
verticalScrollbar.setScrollPos(scrollTop);
}
/**
* Returns the logical horizontal scroll offset. Note that this is not
* necessarily the same as the {@code scrollLeft} attribute in the DOM.
*
* @return the logical horizontal scroll offset
*/
public double getScrollLeft() {
return horizontalScrollbar.getScrollPos();
}
/**
* Sets the logical horizontal scroll offset. Note that will not necessarily
* become the same as the {@code scrollLeft} attribute in the DOM.
*
* @param scrollLeft
* the number of pixels to scroll horizontally
*/
public void setScrollLeft(final double scrollLeft) {
horizontalScrollbar.setScrollPos(scrollLeft);
}
/**
* Returns the scroll width for the escalator. Note that this is not
* necessary the same as {@code Element.scrollWidth} in the DOM.
*
* @since 7.5.0
* @return the scroll width in pixels
*/
public double getScrollWidth() {
return horizontalScrollbar.getScrollSize();
}
/**
* Returns the scroll height for the escalator. Note that this is not
* necessary the same as {@code Element.scrollHeight} in the DOM.
*
* @since 7.5.0
* @return the scroll height in pixels
*/
public double getScrollHeight() {
return verticalScrollbar.getScrollSize();
}
/**
* Scrolls the body horizontally so that the column at the given index is
* visible and there is at least {@code padding} pixels in the direction of
* the given scroll destination.
*
* @param columnIndex
* the index of the column to scroll to
* @param destination
* where the column should be aligned visually after scrolling
* @param padding
* the number pixels to place between the scrolled-to column and
* the viewport edge.
* @throws IndexOutOfBoundsException
* if {@code columnIndex} is not a valid index for an existing
* column
* @throws IllegalArgumentException
* if {@code destination} is {@link ScrollDestination#MIDDLE}
* and padding is nonzero; or if the indicated column is frozen;
* or if {@code destination == null}
*/
public void scrollToColumn(final int columnIndex,
final ScrollDestination destination, final int padding)
throws IndexOutOfBoundsException, IllegalArgumentException {
validateScrollDestination(destination, padding);
verifyValidColumnIndex(columnIndex);
if (columnIndex < columnConfiguration.frozenColumns) {
throw new IllegalArgumentException(
"The given column index " + columnIndex + " is frozen.");
}
scroller.scrollToColumn(columnIndex, destination, padding);
}
private void verifyValidColumnIndex(final int columnIndex)
throws IndexOutOfBoundsException {
if (columnIndex < 0
|| columnIndex >= columnConfiguration.getColumnCount()) {
throw new IndexOutOfBoundsException("The given column index "
+ columnIndex + " does not exist.");
}
}
/**
* Scrolls the body vertically so that the row at the given index is visible
* and there is at least {@literal padding} pixels to the given scroll
* destination.
*
* @param rowIndex
* the index of the logical row to scroll to
* @param destination
* where the row should be aligned visually after scrolling
* @param padding
* the number pixels to place between the scrolled-to row and the
* viewport edge.
* @throws IndexOutOfBoundsException
* if {@code rowIndex} is not a valid index for an existing row
* @throws IllegalArgumentException
* if {@code destination} is {@link ScrollDestination#MIDDLE}
* and padding is nonzero; or if {@code destination == null}
* @see #scrollToRowAndSpacer(int, ScrollDestination, int)
* @see #scrollToSpacer(int, ScrollDestination, int)
*/
public void scrollToRow(final int rowIndex,
final ScrollDestination destination, final int padding)
throws IndexOutOfBoundsException, IllegalArgumentException {
verifyValidRowIndex(rowIndex);
body.scrollToRowSpacerOrBoth(rowIndex, destination, padding,
ScrollType.ROW);
}
private void verifyValidRowIndex(final int rowIndex) {
if (rowIndex < 0 || rowIndex >= body.getRowCount()) {
throw new IndexOutOfBoundsException(
"The given row index " + rowIndex + " does not exist.");
}
}
/**
* Scrolls the body vertically so that the spacer at the given row index is
* visible and there is at least {@literal padding} pixels to the given
* scroll destination.
*
* @since 7.5.0
* @param spacerIndex
* the row index of the spacer to scroll to
* @param destination
* where the spacer should be aligned visually after scrolling
* @param padding
* the number of pixels to place between the scrolled-to spacer
* and the viewport edge
* @throws IllegalArgumentException
* if {@code spacerIndex} is not an opened spacer; or if
* {@code destination} is {@link ScrollDestination#MIDDLE} and
* padding is nonzero; or if {@code destination == null}
* @see #scrollToRow(int, ScrollDestination, int)
* @see #scrollToRowAndSpacer(int, ScrollDestination, int)
*/
public void scrollToSpacer(final int spacerIndex,
ScrollDestination destination, final int padding)
throws IllegalArgumentException {
body.scrollToRowSpacerOrBoth(spacerIndex, destination, padding,
ScrollType.SPACER);
}
/**
* Scrolls vertically to a row and the spacer below it.
*
* If a spacer is not open at that index, this method behaves like
* {@link #scrollToRow(int, ScrollDestination, int)}
*
* @since 7.5.0
* @param rowIndex
* the index of the logical row to scroll to. -1 takes the
* topmost spacer into account as well.
* @param destination
* where the row should be aligned visually after scrolling
* @param padding
* the number pixels to place between the scrolled-to row and the
* viewport edge.
* @see #scrollToRow(int, ScrollDestination, int)
* @see #scrollToSpacer(int, ScrollDestination, int)
* @throws IllegalArgumentException
* if {@code destination} is {@link ScrollDestination#MIDDLE}
* and {@code padding} is not zero; or if {@code rowIndex} is
* not a valid row index, or -1; or if
* {@code destination == null}; or if {@code rowIndex == -1} and
* there is no spacer open at that index.
*/
public void scrollToRowAndSpacer(final int rowIndex,
final ScrollDestination destination, final int padding)
throws IllegalArgumentException {
if (rowIndex != -1) {
verifyValidRowIndex(rowIndex);
}
body.scrollToRowSpacerOrBoth(rowIndex, destination, padding,
ScrollType.ROW_AND_SPACER);
}
private static void validateScrollDestination(
final ScrollDestination destination, final int padding) {
if (destination == null) {
throw new IllegalArgumentException("Destination cannot be null");
}
if (destination == ScrollDestination.MIDDLE && padding != 0) {
throw new IllegalArgumentException(
"You cannot have a padding with a MIDDLE destination");
}
}
/**
* Recalculates the dimensions for all elements that require manual
* calculations. Also updates the dimension caches.
*
* Note: This method has the side-effect
* automatically makes sure that an appropriate amount of escalator rows are
* present. So, if the body area grows, more escalator rows might be
* inserted. Conversely, if the body area shrinks,
* escalator rows might be removed.
*/
private void recalculateElementSizes() {
if (!isAttached()) {
return;
}
Profiler.enter("Escalator.recalculateElementSizes");
widthOfEscalator = Math.max(0, getBoundingWidth(getElement()));
heightOfEscalator = Math.max(0, getBoundingHeight(getElement()));
header.recalculateSectionHeight();
body.recalculateSectionHeight();
footer.recalculateSectionHeight();
scroller.recalculateScrollbarsForVirtualViewport();
body.verifyEscalatorCount();
body.reapplySpacerWidths();
Profiler.leave("Escalator.recalculateElementSizes");
}
/**
* Snap deltas of x and y to the major four axes (up, down, left, right)
* with a threshold of a number of degrees from those axes.
*
* @param deltaX
* the delta in the x axis
* @param deltaY
* the delta in the y axis
* @param thresholdRatio
* the threshold in ratio (0..1) between x and y for when to snap
* @return a two-element array:
* If Escalator is currently not in {@link HeightMode#ROW}, the given value
* is remembered, and applied once the mode is applied.
*
* @param rows
* the number of rows that should be visible in Escalator's body
* @throws IllegalArgumentException
* if {@code rows} is ≤ 0, {@link Double#isInfinite(double)
* infinite} or {@link Double#isNaN(double) NaN}.
* @see #setHeightMode(HeightMode)
*/
public void setHeightByRows(double rows) throws IllegalArgumentException {
if (heightMode == HeightMode.UNDEFINED && body.insertingOrRemoving) {
// this will be called again once the operation is finished, ignore
// for now
return;
}
if (rows < 0) {
throw new IllegalArgumentException(
"The number of rows must be a positive number.");
} else if (Double.isInfinite(rows)) {
throw new IllegalArgumentException(
"The number of rows must be finite.");
} else if (Double.isNaN(rows)) {
throw new IllegalArgumentException("The number must not be NaN.");
}
heightByRows = rows;
applyHeightByRows();
}
/**
* Gets the amount of rows in Escalator's body that are shown, while
* {@link #getHeightMode()} is {@link HeightMode#ROW}.
*
* By default, it is 10.
*
* @return the amount of rows that are being shown in Escalator's body
* @see #setHeightByRows(double)
*/
public double getHeightByRows() {
return heightByRows;
}
/**
* Reapplies the row-based height of the Grid, if Grid currently should
* define its height that way.
*/
private void applyHeightByRows() {
if (heightMode != HeightMode.ROW
&& heightMode != HeightMode.UNDEFINED) {
return;
}
double headerHeight = header.getHeightOfSection();
double footerHeight = footer.getHeightOfSection();
double bodyHeight = body.getDefaultRowHeight() * heightByRows;
double scrollbar = horizontalScrollbar.showsScrollHandle()
? horizontalScrollbar.getScrollbarThickness()
: 0;
double spacerHeight = 0; // ignored if HeightMode.ROW
if (heightMode == HeightMode.UNDEFINED) {
spacerHeight = body.spacerContainer.getSpacerHeightsSum();
}
double totalHeight = headerHeight + bodyHeight + spacerHeight
+ scrollbar + footerHeight;
setHeightInternal(totalHeight + "px");
}
/**
* Defines the mode in which the Escalator widget's height is calculated.
*
* If {@link HeightMode#CSS} is given, Escalator will respect the values
* given via {@link #setHeight(String)}, and behave as a traditional Widget.
*
* If {@link HeightMode#ROW} is given, Escalator will make sure that the
* {@link #getBody() body} will display as many rows as
* {@link #getHeightByRows()} defines. Note: If headers/footers are
* inserted or removed, the widget will resize itself to still display the
* required amount of rows in its body. It also takes the horizontal
* scrollbar into account.
*
* @param heightMode
* the mode in to which Escalator should be set
*/
public void setHeightMode(HeightMode heightMode) {
/*
* This method is a workaround for the fact that Vaadin re-applies
* widget dimensions (height/width) on each state change event. The
* original design was to have setHeight an setHeightByRow be equals,
* and whichever was called the latest was considered in effect.
*
* But, because of Vaadin always calling setHeight on the widget, this
* approach doesn't work.
*/
if (heightMode != this.heightMode) {
this.heightMode = heightMode;
switch (this.heightMode) {
case CSS:
setHeight(heightByCss);
break;
case ROW:
setHeightByRows(heightByRows);
break;
case UNDEFINED:
setHeightByRows(body.getRowCount());
break;
default:
throw new IllegalStateException("Unimplemented feature "
+ "- unknown HeightMode: " + this.heightMode);
}
}
}
/**
* Returns the current {@link HeightMode} the Escalator is in.
*
* Defaults to {@link HeightMode#CSS}.
*
* @return the current HeightMode
*/
public HeightMode getHeightMode() {
return heightMode;
}
/**
* Returns the {@link RowContainer} which contains the element.
*
* @param element
* the element to check for
* @return the container the element is in or
* If a direction is locked, the escalator will refuse to scroll in that
* direction.
*
* @param direction
* the orientation of the scroll to set the lock status
* @param locked
*
* NOTE: you should not do any modifications to the returned element.
* This API is only available for querying data from the element.
*
* @return the table wrapper element
* @since 8.1
*/
public Element getTableWrapper() {
return tableWrapper;
}
/**
* Returns the
*
*
* @since 8.2
*/
public class AriaGridHelper {
/**
* This field contains the total number of rows from the grid including
* rows from thead, tbody and tfoot.
*
* @since 8.2
*/
private int allRows;
/**
* Adds the given numberOfRows to allRows and calls
* {@link #updateAriaRowCount()}.
*
* @param numberOfRows
* number of rows that were added to the grid
*
* @since 8.2
*/
public void addRows(int numberOfRows) {
allRows += numberOfRows;
updateAriaRowCount();
}
/**
* Removes the given numberOfRows from allRows and calls
* {@link #updateAriaRowCount()}.
*
* @param numberOfRows
* number of rows that were removed from the grid
*
* @since 8.2
*/
public void removeRows(int numberOfRows) {
allRows -= numberOfRows;
updateAriaRowCount();
}
/**
* Sets the aria-rowcount attribute with the current value of
* {@link AriaGridHelper#allRows} if the grid is attached and
* {@link AriaGridHelper#allRows} > 0.
*
* @since 8.2
*/
public void updateAriaRowCount() {
if (!isAttached() || 0 > allRows) {
return;
}
getTable().setAttribute("aria-rowcount", String.valueOf(allRows));
}
/**
* Sets the {@code role} attribute to the given element.
*
* @param element
* element that should get the role attribute
* @param role
* role to be added
*
* @since 8.2
*/
public void updateRole(final Element element, AriaGridRole role) {
element.setAttribute("role", role.getName());
}
}
/**
* Holds the currently used aria roles within the grid for rows and cells.
*
* @since 8.2
*/
public enum AriaGridRole {
ROW("row"), ROWHEADER("rowheader"), ROWGROUP("rowgroup"), GRIDCELL(
"gridcell"), COLUMNHEADER("columnheader");
private final String name;
AriaGridRole(String name) {
this.name = name;
}
/**
* Return the name of the {@link AriaGridRole}.
*
* @return String name to be used as role attribute
*/
public String getName() {
return name;
}
}
public abstract class AbstractRowContainer implements RowContainer {
private EscalatorUpdater updater = EscalatorUpdater.NULL;
private int rows;
/**
* The table section element ({@code }, {@code } or
* {@code }) the rows (i.e. <tr> tags) are
* contained in.
*/
protected final TableSectionElement root;
/**
* The primary style name of the escalator. Most commonly provided by
* Escalator as "v-escalator".
*/
private String primaryStyleName = null;
private boolean defaultRowHeightShouldBeAutodetected = true;
private double defaultRowHeight = INITIAL_DEFAULT_ROW_HEIGHT;
private boolean initialColumnSizesCalculated = false;
private boolean autodetectingRowHeightLater = false;
public AbstractRowContainer(
final TableSectionElement rowContainerElement) {
root = rowContainerElement;
ariaGridHelper.updateRole(root, AriaGridRole.ROWGROUP);
}
@Override
public TableSectionElement getElement() {
return root;
}
/**
* Gets the tag name of an element to represent a cell in a row.
* true if the given element, or any of its
* descendants, can be frozen
*/
protected abstract boolean rowCanBeFrozen(TableRowElement tr);
/**
* Iterates through all the cells in a column and returns the width of
* the widest element in this RowContainer.
*
* @param index
* the index of the column to inspect
* @return the pixel width of the widest element in the indicated column
*/
public double calculateMaxColWidth(int index) {
TableRowElement row = TableRowElement
.as(root.getFirstChildElement());
double maxWidth = 0;
while (row != null) {
final TableCellElement cell = row.getCells().getItem(index);
final boolean isVisible = !cell.getStyle().getDisplay()
.equals(Display.NONE.getCssName());
if (isVisible) {
maxWidth = Math.max(maxWidth, getBoundingWidth(cell));
}
row = TableRowElement.as(row.getNextSiblingElement());
}
return maxWidth;
}
/**
* Reapplies all the cells' widths according to the calculated widths in
* the column configuration.
*/
public void reapplyColumnWidths() {
Element row = root.getFirstChildElement();
while (row != null) {
// Only handle non-spacer rows
if (!body.spacerContainer.isSpacer(row)) {
Element cell = row.getFirstChildElement();
int columnIndex = 0;
while (cell != null) {
final double width = getCalculatedColumnWidthWithColspan(
cell, columnIndex);
/*
* TODO Should Escalator implement ProvidesResize at
* some point, this is where we need to do that.
*/
cell.getStyle().setWidth(width, Unit.PX);
cell = cell.getNextSiblingElement();
columnIndex++;
}
}
row = row.getNextSiblingElement();
}
reapplyRowWidths();
}
private double getCalculatedColumnWidthWithColspan(final Element cell,
final int columnIndex) {
final int colspan = cell.getPropertyInt(FlyweightCell.COLSPAN_ATTR);
Range spannedColumns = Range.withLength(columnIndex, colspan);
/*
* Since browsers don't explode with overflowing colspans, escalator
* shouldn't either.
*/
if (spannedColumns.getEnd() > columnConfiguration
.getColumnCount()) {
spannedColumns = Range.between(columnIndex,
columnConfiguration.getColumnCount());
}
return columnConfiguration
.getCalculatedColumnsWidth(spannedColumns);
}
/**
* Applies the total length of the columns to each row element.
*
* } element, not the cells within.
*/
protected void reapplyRowWidths() {
double rowWidth = columnConfiguration.calculateRowWidth();
if (rowWidth < 0) {
return;
}
Element row = root.getFirstChildElement();
while (row != null) {
// IF there is a rounding error when summing the columns, we
// need to round the tr width up to ensure that columns fit and
// do not wrap
// E.g.122.95+123.25+103.75+209.25+83.52+88.57+263.45+131.21+126.85+113.13=1365.9299999999998
// For this we must set 1365.93 or the last column will wrap
row.getStyle().setWidth(WidgetUtil.roundSizeUp(rowWidth),
Unit.PX);
row = row.getNextSiblingElement();
}
}
/**
* The primary style name for the container.
*
* @param primaryStyleName
* the style name to use as prefix for all row and cell style
* names.
*/
protected void setStylePrimaryName(String primaryStyleName) {
String oldStyle = getStylePrimaryName();
if (SharedUtil.equals(oldStyle, primaryStyleName)) {
return;
}
this.primaryStyleName = primaryStyleName;
// Update already rendered rows and cells
Element row = root.getRows().getItem(0);
while (row != null) {
UIObject.setStylePrimaryName(row, primaryStyleName + "-row");
Element cell = TableRowElement.as(row).getCells().getItem(0);
while (cell != null) {
assert TableCellElement.is(cell);
UIObject.setStylePrimaryName(cell,
primaryStyleName + "-cell");
cell = cell.getNextSiblingElement();
}
row = row.getNextSiblingElement();
}
}
/**
* Returns the primary style name of the container.
*
* @return The primary style name or null if not set.
*/
protected String getStylePrimaryName() {
return primaryStyleName;
}
@Override
public void setDefaultRowHeight(double px)
throws IllegalArgumentException {
if (px < 1) {
throw new IllegalArgumentException(
"Height must be positive. " + px + " was given.");
}
defaultRowHeightShouldBeAutodetected = false;
defaultRowHeight = px;
reapplyDefaultRowHeights();
applyHeightByRows();
}
@Override
public double getDefaultRowHeight() {
return defaultRowHeight;
}
/**
* The default height of rows has (most probably) changed.
* true if content is taken into account,
* false if not
* @return cell width needed for displaying correctly
*/
double measureMinCellWidth(int colIndex, boolean withContent) {
assert isAttached() : "Can't measure max width of cell, since Escalator is not attached to the DOM.";
double minCellWidth = -1;
NodeListtrue if a sort is scheduled */
public boolean waiting = false;
public void reschedule() {
waiting = true;
resetConditions();
animationHandle = AnimationScheduler.get()
.requestAnimationFrame(frameCounter);
}
private boolean sortIfConditionsMet() {
boolean enoughFramesHavePassed = framesPassed >= REQUIRED_FRAMES_PASSED;
boolean enoughTimeHasPassed = (Duration.currentTimeMillis()
- startTime) >= SORT_DELAY_MILLIS;
boolean notTouchActivity = !scroller.touchHandlerBundle.touching;
boolean conditionsMet = enoughFramesHavePassed
&& enoughTimeHasPassed && notTouchActivity;
if (conditionsMet) {
resetConditions();
sortDomElements();
}
return conditionsMet;
}
private void resetConditions() {
if (animationHandle != null) {
animationHandle.cancel();
animationHandle = null;
}
startTime = Duration.currentTimeMillis();
framesPassed = 0;
}
}
private DeferredDomSorter domSorter = new DeferredDomSorter();
private final SpacerContainer spacerContainer = new SpacerContainer();
private boolean insertingOrRemoving = false;
public BodyRowContainerImpl(final TableSectionElement bodyElement) {
super(bodyElement);
}
@Override
public void setStylePrimaryName(String primaryStyleName) {
super.setStylePrimaryName(primaryStyleName);
UIObject.setStylePrimaryName(root, primaryStyleName + "-body");
spacerContainer.setStylePrimaryName(primaryStyleName);
}
public void updateEscalatorRowsOnScroll() {
if (visualRowOrder.isEmpty()) {
return;
}
boolean rowsWereMoved = false;
final double topElementPosition;
final double nextRowBottomOffset;
SpacerContainer.SpacerImpl topSpacer = spacerContainer
.getSpacer(getTopRowLogicalIndex() - 1);
if (topSpacer != null) {
topElementPosition = topSpacer.getTop();
nextRowBottomOffset = topSpacer.getHeight()
+ getDefaultRowHeight();
} else {
topElementPosition = getRowTop(visualRowOrder.getFirst());
nextRowBottomOffset = getDefaultRowHeight();
}
// TODO [[mpixscroll]]
final double scrollTop = tBodyScrollTop;
final double sectionHeight = getHeightOfSection();
/*
* Calculate how the visual range is situated in relation to the
* viewport. Negative value means part of visual range is hidden
* above or below the viewport, positive value means there is a gap
* at the top or the bottom of the viewport, zero means exact match.
* If there is a gap, some rows that are out of view may need to be
* recycled from the opposite end.
*/
final double viewportOffsetTop = topElementPosition - scrollTop;
final double viewportOffsetBottom = scrollTop + sectionHeight
- getRowTop(
getTopRowLogicalIndex() + visualRowOrder.size());
/*
* You can only scroll far enough to leave a gap if visualRowOrder
* contains a maximal amount of rows and there is at least one more
* outside of the visual range. Consequently there can only be a gap
* in one end of the viewport at a time.
*/
if (viewportOffsetTop > 0 || (viewportOffsetTop == 0
&& getTopRowLogicalIndex() > 0)) {
/*
* Scrolling up. Either there's empty room on top, or there
* should be a buffer row for tab navigation on top, but there
* isn't.
*/
recycleRowsUpOnScroll(viewportOffsetTop);
rowsWereMoved = true;
} else if ((viewportOffsetBottom > 0
&& (viewportOffsetTop + nextRowBottomOffset <= 0))
|| (viewportOffsetBottom == 0 && (getTopRowLogicalIndex()
+ visualRowOrder.size() < getRowCount() - 2))) {
/*
* Scrolling down. Either there's empty room at the bottom and
* the viewport has been scrolled more than the topmost visual
* row, or there should be a buffer row at the bottom to ensure
* tab navigation works, but there isn't.
*/
recycleRowsDownOnScroll(topElementPosition, scrollTop);
// Moving rows may have removed more spacers and created another
// gap, this time the scroll position needs adjusting. The last
// row within visual range should be just below the viewport as
// a buffer for helping with tab navigation, unless it's the
// last row altogether.
int lastRowInVisualRange = getTopRowLogicalIndex()
+ visualRowOrder.size() - 1;
double expectedBottom = getRowTop(lastRowInVisualRange);
if (lastRowInVisualRange == getRowCount() - 1) {
expectedBottom += getDefaultRowHeight() + spacerContainer
.getSpacerHeight(lastRowInVisualRange);
}
if (expectedBottom < scrollTop + sectionHeight) {
double expectedTop = Math.max(0,
expectedBottom - sectionHeight);
setBodyScrollPosition(tBodyScrollLeft, expectedTop);
setScrollTop(expectedTop);
}
rowsWereMoved = true;
}
if (rowsWereMoved) {
fireRowVisibilityChangeEvent();
// schedule updating of the physical indexes
domSorter.reschedule();
}
}
/**
* Recycling rows up for {@link #updateEscalatorRowsOnScroll()}.
*
*
*
* @deprecated This method isn't used by Escalator anymore since Vaadin
* 8.9 and the general row handling logic has been
* rewritten, so attempting to call this method may lead to
* unexpected consequences. This method is likely to get
* removed soon.
* @param yDelta
* the delta of pixels by which to move the viewport and
* content. A positive value moves everything downwards,
* while a negative value moves everything upwards
*/
@Deprecated
public void moveViewportAndContent(final double yDelta) {
if (yDelta == 0) {
return;
}
double newTop = tBodyScrollTop + yDelta;
verticalScrollbar.setScrollPos(newTop);
final double defaultRowHeight = getDefaultRowHeight();
double rowPxDelta = yDelta - (yDelta % defaultRowHeight);
int rowIndexDelta = (int) (yDelta / defaultRowHeight);
if (!WidgetUtil.pixelValuesEqual(rowPxDelta, 0)) {
Collectionindex
* @return a list of the added rows
*/
private List
*
*
* @return a logical range converted to a visual range, truncated to the
* current viewport. The first visual row has the index 0.
*/
private Range convertToVisual(final Range logicalRange) {
if (logicalRange.isEmpty()) {
return logicalRange;
} else if (visualRowOrder.isEmpty()) {
// empty range
return Range.withLength(0, 0);
}
final int currentTopRowIndex = getTopRowLogicalIndex();
final Range[] partitions = logicalRange
.partitionWith(getVisibleRowRange());
final Range insideRange = partitions[1];
return insideRange.offsetBy(-currentTopRowIndex);
}
@Override
protected String getCellElementTagName() {
return "td";
}
@Override
protected double getHeightOfSection() {
final int tableHeight = tableWrapper.getOffsetHeight();
final double footerHeight = footer.getHeightOfSection();
final double headerHeight = header.getHeightOfSection();
double heightOfSection = tableHeight - footerHeight - headerHeight;
return Math.max(0, heightOfSection);
}
@Override
protected void refreshCells(Range logicalRowRange, Range colRange) {
Profiler.enter("Escalator.BodyRowContainer.refreshRows");
final Range visualRange = convertToVisual(logicalRowRange);
if (!visualRange.isEmpty()) {
final int firstLogicalRowIndex = getLogicalRowIndex(
visualRowOrder.getFirst());
for (int rowNumber = visualRange
.getStart(); rowNumber < visualRange
.getEnd(); rowNumber++) {
refreshRow(visualRowOrder.get(rowNumber),
firstLogicalRowIndex + rowNumber, colRange);
}
}
Profiler.leave("Escalator.BodyRowContainer.refreshRows");
}
@Override
protected TableRowElement getTrByVisualIndex(final int index)
throws IndexOutOfBoundsException {
if (index >= 0 && index < visualRowOrder.size()) {
return visualRowOrder.get(index);
} else {
throw new IndexOutOfBoundsException(
"No such visual index: " + index);
}
}
@Override
public TableRowElement getRowElement(int index) {
if (index < 0 || index >= getRowCount()) {
throw new IndexOutOfBoundsException(
"No such logical index: " + index);
}
int visualIndex = index
- getLogicalRowIndex(visualRowOrder.getFirst());
if (visualIndex >= 0 && visualIndex < visualRowOrder.size()) {
return super.getRowElement(visualIndex);
} else {
throw new IllegalStateException("Row with logical index "
+ index + " is currently not available in the DOM");
}
}
private void setBodyScrollPosition(final double scrollLeft,
final double scrollTop) {
tBodyScrollLeft = scrollLeft;
tBodyScrollTop = scrollTop;
position.set(bodyElem, -tBodyScrollLeft, -tBodyScrollTop);
position.set(spacerDecoContainer, 0, -tBodyScrollTop);
}
/**
* Make sure that there is a correct amount of escalator rows: Add more
* if needed, or remove any superfluous ones.
* null if focus is outside of a body
* row.
*/
private TableRowElement getRowWithFocus() {
TableRowElement rowContainingFocus = null;
final Element focusedElement = WidgetUtil.getFocusedElement();
if (focusedElement != null && root.isOrHasChild(focusedElement)) {
Element e = focusedElement;
while (e != null && e != root) {
/*
* You never know if there's several tables embedded in a
* cell... We'll take the deepest one.
*/
if (TableRowElement.is(e)) {
rowContainingFocus = TableRowElement.as(e);
}
e = e.getParentElement();
}
}
return rowContainingFocus;
}
/**
* Returns the cell object which contains information about the cell or
* spacer the element is in. As an implementation detail each spacer is
* a row with one cell, but they are stored in their own container and
* share the indexing with the regular rows.
*
* @param element
* The element to get the cell for. If element is not present
* in row or spacer container then null is
* returned.
*
* @return the cell reference of the element, or null if
* element is not present in the {@link RowContainer} or the
* {@link SpacerContainer}.
*/
@Override
public Cell getCell(Element element) {
Cell cell = super.getCell(element);
if (cell == null) {
return null;
}
// Convert DOM coordinates to logical coordinates for rows
TableRowElement rowElement = (TableRowElement) cell.getElement()
.getParentElement();
if (!visualRowOrder.contains(rowElement)) {
for (Entrycolumns
*/
double getCalculatedColumnsWidth(final Range columns) {
/*
* This is an assert instead of an exception, since this is an
* internal method.
*/
assert columns
.isSubsetOf(Range.between(0, getColumnCount())) : "Range "
+ "was outside of current column range (i.e.: "
+ Range.between(0, getColumnCount())
+ ", but was given :" + columns;
double sum = 0;
for (int i = columns.getStart(); i < columns.getEnd(); i++) {
double columnWidthActual = getColumnWidthActual(i);
sum += columnWidthActual;
}
return sum;
}
double[] getCalculatedColumnWidths() {
if (widthsArray == null || widthsArray.length != getColumnCount()) {
widthsArray = new double[getColumnCount()];
for (int i = 0; i < columns.size(); i++) {
widthsArray[i] = columns.get(i).getCalculatedWidth();
}
}
return widthsArray;
}
@Override
public void refreshColumns(int index, int numberOfColumns)
throws IndexOutOfBoundsException, IllegalArgumentException {
if (numberOfColumns < 1) {
throw new IllegalArgumentException(
"Number of columns must be 1 or greater (was "
+ numberOfColumns + ")");
}
if (index < 0 || index + numberOfColumns > getColumnCount()) {
throw new IndexOutOfBoundsException("The given "
+ "column range (" + index + ".."
+ (index + numberOfColumns)
+ ") was outside of the current number of columns ("
+ getColumnCount() + ")");
}
header.refreshColumns(index, numberOfColumns);
body.refreshColumns(index, numberOfColumns);
footer.refreshColumns(index, numberOfColumns);
}
}
/**
* A decision on how to measure a spacer when it is partially within a
* designated range.
*
*
*
* @param px
* the pixel point after which to return all spacers
* @param strategy
* the inclusion strategy regarding the {@code px}
* @return a collection of the spacers that exist after {@code px}
*/
public Collection
*
*
* @param rangeTop
* the top pixel point
* @param topInclusion
* the inclusion strategy regarding {@code rangeTop}.
* @param rangeBottom
* the bottom pixel point
* @param bottomInclusion
* the inclusion strategy regarding {@code rangeBottom}.
* @return the pixels occupied by spacers between {@code rangeTop} and
* {@code rangeBottom}
*/
public double getSpacerHeightsSumBetweenPx(double rangeTop,
SpacerInclusionStrategy topInclusion, double rangeBottom,
SpacerInclusionStrategy bottomInclusion) {
assert rangeTop <= rangeBottom : "rangeTop must be less than rangeBottom";
double heights = 0;
/*
* TODO [[optimize]]: this might be somewhat inefficient (due to
* iterator-based scanning, instead of using the treemap's search
* functionalities). But it should be easy to write, read, verify
* and maintain.
*/
for (SpacerImpl spacer : rowIndexToSpacer.values()) {
double top = spacer.getTop();
double height = spacer.getHeight();
double bottom = top + height;
/*
* If we happen to implement a DoubleRange (in addition to the
* int-based Range) at some point, the following logic should
* probably be converted into using the
* Range.partitionWith-equivalent.
*/
boolean topIsAboveRange = top < rangeTop;
boolean topIsInRange = rangeTop <= top && top <= rangeBottom;
boolean topIsBelowRange = rangeBottom < top;
boolean bottomIsAboveRange = bottom < rangeTop;
boolean bottomIsInRange = rangeTop <= bottom
&& bottom <= rangeBottom;
boolean bottomIsBelowRange = rangeBottom < bottom;
assert topIsAboveRange ^ topIsBelowRange
^ topIsInRange : "Bad top logic";
assert bottomIsAboveRange ^ bottomIsBelowRange
^ bottomIsInRange : "Bad bottom logic";
if (bottomIsAboveRange) {
continue;
} else if (topIsBelowRange) {
return heights;
} else if (topIsAboveRange && bottomIsInRange) {
switch (topInclusion) {
case PARTIAL:
heights += bottom - rangeTop;
break;
case COMPLETE:
heights += height;
break;
default:
break;
}
} else if (topIsAboveRange && bottomIsBelowRange) {
/*
* Here we arbitrarily decide that the top inclusion will
* have the honor of overriding the bottom inclusion if
* happens to be a conflict of interests.
*/
switch (topInclusion) {
case NONE:
return 0;
case COMPLETE:
return height;
case PARTIAL:
return rangeBottom - rangeTop;
default:
throw new IllegalArgumentException(
"Unexpected inclusion state :" + topInclusion);
}
} else if (topIsInRange && bottomIsInRange) {
heights += height;
} else if (topIsInRange && bottomIsBelowRange) {
switch (bottomInclusion) {
case PARTIAL:
heights += rangeBottom - top;
break;
case COMPLETE:
heights += height;
break;
default:
break;
}
return heights;
} else {
assert false : "Unnaccounted-for situation";
}
}
return heights;
}
/**
* Gets the amount of pixels occupied by spacers from the top until a
* certain spot from the top of the body.
*
* @param px
* pixels counted from the top
* @return the pixels occupied by spacers up until {@code px}
*/
public double getSpacerHeightsSumUntilPx(double px) {
return getSpacerHeightsSumBetweenPx(0,
SpacerInclusionStrategy.PARTIAL, px,
SpacerInclusionStrategy.PARTIAL);
}
/**
* Gets the amount of pixels occupied by spacers until a logical row
* index. The spacer of the row corresponding with the given index isn't
* included.
*
* @param logicalIndex
* a logical row index
* @return the pixels occupied by spacers up until {@code logicalIndex}
*/
@SuppressWarnings("boxing")
public double getSpacerHeightsSumUntilIndex(int logicalIndex) {
return getHeights(
rowIndexToSpacer.headMap(logicalIndex, false).values());
}
private double getHeights(Collection|tan-1(x)|×(180/π) = 30
* .
* |tan-1(x)|×(180/π) = 40
* .
* true if header, body or footer has rows and there
* are columns
*/
private boolean hasColumnAndRowData() {
return (header.getRowCount() > 0 || body.getRowCount() > 0
|| footer.getRowCount() > 0)
&& columnConfiguration.getColumnCount() > 0;
}
/**
* Check whether there are any cells in the DOM.
*
* @return true if header, body or footer has any child
* elements
*/
private boolean hasSomethingInDom() {
return headElem.hasChildNodes() || bodyElem.hasChildNodes()
|| footElem.hasChildNodes();
}
/**
* Returns the row container for the header in this Escalator.
*
* @return the header. Never null
*/
public RowContainer getHeader() {
return header;
}
/**
* Returns the row container for the body in this Escalator.
*
* @return the body. Never null
*/
public BodyRowContainer getBody() {
return body;
}
/**
* Returns the row container for the footer in this Escalator.
*
* @return the footer. Never null
*/
public RowContainer getFooter() {
return footer;
}
/**
* Returns the configuration object for the columns in this Escalator.
*
* @return the configuration object for the columns in this Escalator. Never
* null
*/
public ColumnConfiguration getColumnConfiguration() {
return columnConfiguration;
}
@Override
public void setWidth(final String width) {
if (width != null && !width.isEmpty()) {
super.setWidth(width);
} else {
super.setWidth(DEFAULT_WIDTH);
}
recalculateElementSizes();
}
/**
* {@inheritDoc}
* [snappedX, snappedY]
*/
private static double[] snapDeltas(final double deltaX, final double deltaY,
final double thresholdRatio) {
final double[] array = new double[2];
if (deltaX != 0 && deltaY != 0) {
final double aDeltaX = Math.abs(deltaX);
final double aDeltaY = Math.abs(deltaY);
final double yRatio = aDeltaY / aDeltaX;
final double xRatio = aDeltaX / aDeltaY;
array[0] = (xRatio < thresholdRatio) ? 0 : deltaX;
array[1] = (yRatio < thresholdRatio) ? 0 : deltaY;
} else {
array[0] = deltaX;
array[1] = deltaY;
}
return array;
}
/**
* Adds an event handler that gets notified when the range of visible rows
* changes e.g. because of scrolling, row resizing or spacers
* appearing/disappearing.
*
* @param rowVisibilityChangeHandler
* the event handler
* @return a handler registration for the added handler
*/
public HandlerRegistration addRowVisibilityChangeHandler(
RowVisibilityChangeHandler rowVisibilityChangeHandler) {
return addHandler(rowVisibilityChangeHandler,
RowVisibilityChangeEvent.TYPE);
}
private void fireRowVisibilityChangeEvent() {
if (!body.visualRowOrder.isEmpty()) {
int visibleRangeStart = body.getTopRowLogicalIndex();
int visibleRowCount = body.visualRowOrder.size();
fireEvent(new RowVisibilityChangeEvent(visibleRangeStart,
visibleRowCount));
} else {
fireEvent(new RowVisibilityChangeEvent(0, 0));
}
}
/**
* Gets the logical index range of currently visible rows.
*
* @return logical index range of visible rows
*/
public Range getVisibleRowRange() {
if (!body.visualRowOrder.isEmpty()) {
return Range.withLength(body.getTopRowLogicalIndex(),
body.visualRowOrder.size());
} else {
return Range.withLength(0, 0);
}
}
/**
* Returns the widget from a cell node or null if there is no
* widget in the cell
*
* @param cellNode
* The cell node
*/
static Widget getWidgetFromCell(Node cellNode) {
Node possibleWidgetNode = cellNode.getFirstChild();
if (possibleWidgetNode != null
&& possibleWidgetNode.getNodeType() == Node.ELEMENT_NODE) {
@SuppressWarnings("deprecation")
com.google.gwt.user.client.Element castElement = (com.google.gwt.user.client.Element) possibleWidgetNode
.cast();
Widget w = WidgetUtil.findWidget(castElement);
// Ensure findWidget did not traverse past the cell element in the
// DOM hierarchy
if (cellNode.isOrHasChild(w.getElement())) {
return w;
}
}
return null;
}
@Override
public void setStylePrimaryName(String style) {
super.setStylePrimaryName(style);
verticalScrollbar.setStylePrimaryName(style);
horizontalScrollbar.setStylePrimaryName(style);
UIObject.setStylePrimaryName(tableWrapper, style + "-tablewrapper");
UIObject.setStylePrimaryName(headerDeco, style + "-header-deco");
UIObject.setStylePrimaryName(footerDeco, style + "-footer-deco");
UIObject.setStylePrimaryName(horizontalScrollbarDeco,
style + "-horizontal-scrollbar-deco");
UIObject.setStylePrimaryName(spacerDecoContainer,
style + "-spacer-deco-container");
header.setStylePrimaryName(style);
body.setStylePrimaryName(style);
footer.setStylePrimaryName(style);
}
/**
* Sets the number of rows that should be visible in Escalator's body, while
* {@link #getHeightMode()} is {@link HeightMode#ROW}.
* null if element
* is not present in any container.
*/
public RowContainer findRowContainer(Element element) {
if (getHeader().getElement() != element
&& getHeader().getElement().isOrHasChild(element)) {
return getHeader();
} else if (getBody().getElement() != element
&& getBody().getElement().isOrHasChild(element)) {
return getBody();
} else if (getFooter().getElement() != element
&& getFooter().getElement().isOrHasChild(element)) {
return getFooter();
}
return null;
}
/**
* Sets whether a scroll direction is locked or not.
* true to lock, false to unlock
*/
public void setScrollLocked(ScrollbarBundle.Direction direction,
boolean locked) {
switch (direction) {
case HORIZONTAL:
horizontalScrollbar.setLocked(locked);
break;
case VERTICAL:
verticalScrollbar.setLocked(locked);
break;
default:
throw new UnsupportedOperationException(
"Unexpected value: " + direction);
}
}
/**
* Checks whether or not an direction is locked for scrolling.
*
* @param direction
* the direction of the scroll of which to check the lock status
* @return true if the direction is locked
*/
public boolean isScrollLocked(ScrollbarBundle.Direction direction) {
switch (direction) {
case HORIZONTAL:
return horizontalScrollbar.isLocked();
case VERTICAL:
return verticalScrollbar.isLocked();
default:
throw new UnsupportedOperationException(
"Unexpected value: " + direction);
}
}
/**
* Adds a scroll handler to this escalator.
*
* @param handler
* the scroll handler to add
* @return a handler registration for the registered scroll handler
*/
public HandlerRegistration addScrollHandler(ScrollHandler handler) {
return addHandler(handler, ScrollEvent.TYPE);
}
/**
* Returns true if the Escalator is currently scrolling by touch, or has not
* made the decision yet whether to accept touch actions as scrolling or
* not.
*
* @see #setDelayToCancelTouchScroll(double)
*
* @return true when the component is touch scrolling at the moment
* @since 8.1
*/
public boolean isTouchScrolling() {
return scroller.touchHandlerBundle.touching;
}
/**
* Returns the time after which to not consider a touch event a scroll event
* if the user has not moved the touch. This can be used to differentiate
* between quick touch move (scrolling) and long tap (e.g. context menu or
* drag and drop operation).
*
* @return delay in milliseconds after which to cancel touch scrolling if
* there is no movement, -1 means scrolling is always allowed
* @since 8.1
*/
public double getDelayToCancelTouchScroll() {
return delayToCancelTouchScroll;
}
/**
* Sets the time after which to not consider a touch event a scroll event if
* the user has not moved the touch. This can be used to differentiate
* between quick touch move (scrolling) and long tap (e.g. context menu or
* drag and drop operation).
*
* @param delayToCancelTouchScroll
* delay in milliseconds after which to cancel touch scrolling if
* there is no movement, -1 to always allow scrolling
* @since 8.1
*/
public void setDelayToCancelTouchScroll(double delayToCancelTouchScroll) {
this.delayToCancelTouchScroll = delayToCancelTouchScroll;
}
@Override
public boolean isWorkPending() {
return body.domSorter.waiting || verticalScrollbar.isWorkPending()
|| horizontalScrollbar.isWorkPending() || layoutIsScheduled;
}
@Override
public void onResize() {
if (isAttached() && !layoutIsScheduled) {
layoutIsScheduled = true;
Scheduler.get().scheduleFinally(layoutCommand);
}
}
/**
* Gets the maximum number of body rows that can be visible on the screen at
* once.
*
* @return the maximum capacity
*/
public int getMaxVisibleRowCount() {
return body.getMaxVisibleRowCount();
}
/**
* Gets the escalator's inner width. This is the entire width in pixels,
* without the vertical scrollbar.
*
* @return escalator's inner width
*/
public double getInnerWidth() {
return getBoundingWidth(tableWrapper);
}
/**
* Resets all cached pixel sizes and reads new values from the DOM. This
* methods should be used e.g. when styles affecting the dimensions of
* elements in this escalator have been changed.
*/
public void resetSizesFromDom() {
header.autodetectRowHeightNow();
body.autodetectRowHeightNow();
footer.autodetectRowHeightNow();
for (int i = 0; i < columnConfiguration.getColumnCount(); i++) {
columnConfiguration.setColumnWidth(i,
columnConfiguration.getColumnWidth(i));
}
}
private Range getViewportPixels() {
int from = (int) Math.floor(verticalScrollbar.getScrollPos());
int to = (int) body.getHeightOfSection();
return Range.withLength(from, to);
}
@Override
@SuppressWarnings("deprecation")
public com.google.gwt.user.client.Element getSubPartElement(
String subPart) {
SubPartArguments args = SubPartArguments.create(subPart);
Element tableStructureElement = getSubPartElementTableStructure(args);
if (tableStructureElement != null) {
return DOM.asOld(tableStructureElement);
}
Element spacerElement = getSubPartElementSpacer(args);
if (spacerElement != null) {
return DOM.asOld(spacerElement);
}
return null;
}
/**
* Returns the {@code <table> element of the grid.
*
* @return the table element
* @since 8.2
*/
public Element getTable() {
return table;
}
private Element getSubPartElementTableStructure(SubPartArguments args) {
String type = args.getType();
int[] indices = args.getIndices();
// Get correct RowContainer for type from Escalator
RowContainer container = null;
if (type.equalsIgnoreCase("header")) {
container = getHeader();
} else if (type.equalsIgnoreCase("cell")) {
if (indices.length > 0) {
// If wanted row is not visible, we need to scroll there.
// Scrolling might be a no-op if row is already in the viewport.
scrollToRow(indices[0], ScrollDestination.ANY, 0);
}
container = getBody();
} else if (type.equalsIgnoreCase("footer")) {
container = getFooter();
}
if (null != container) {
if (indices.length == 0) {
// No indexing. Just return the wanted container element
return container.getElement();
} else {
try {
return getSubPart(container, indices);
} catch (Exception e) {
getLogger().log(Level.SEVERE, e.getMessage());
}
}
}
return null;
}
private Element getSubPart(RowContainer container, int[] indices) {
Element targetElement = container.getRowElement(indices[0]);
// Scroll wanted column to view if able
if (indices.length > 1 && targetElement != null) {
if (getColumnConfiguration().getFrozenColumnCount() <= indices[1]) {
scrollToColumn(indices[1], ScrollDestination.ANY, 0);
}
targetElement = getCellFromRow(TableRowElement.as(targetElement),
indices[1]);
for (int i = 2; i < indices.length && targetElement != null; ++i) {
targetElement = (Element) targetElement.getChild(indices[i]);
}
}
return targetElement;
}
private static Element getCellFromRow(TableRowElement rowElement,
int index) {
int childCount = rowElement.getCells().getLength();
if (index < 0 || index >= childCount) {
return null;
}
TableCellElement currentCell = null;
boolean indexInColspan = false;
int i = 0;
while (!indexInColspan) {
currentCell = rowElement.getCells().getItem(i);
// Calculate if this is the cell we are looking for
int colSpan = currentCell.getColSpan();
indexInColspan = index < colSpan + i;
// Increment by colspan to skip over hidden cells
i += colSpan;
}
return currentCell;
}
private Element getSubPartElementSpacer(SubPartArguments args) {
if ("spacer".equals(args.getType()) && args.getIndicesLength() == 1) {
// If spacer's row is not visible, we need to scroll there.
// Scrolling might be a no-op if row is already in the viewport.
scrollToSpacer(args.getIndex(0), ScrollDestination.ANY, 0);
return body.spacerContainer.getSubPartElement(args.getIndex(0));
} else {
return null;
}
}
@Override
@SuppressWarnings("deprecation")
public String getSubPartName(
com.google.gwt.user.client.Element subElement) {
/*
* The spacer check needs to be before table structure check, because
* (for now) the table structure will take spacer elements into account
* as well, when it shouldn't.
*/
String spacer = getSubPartNameSpacer(subElement);
if (spacer != null) {
return spacer;
}
String tableStructure = getSubPartNameTableStructure(subElement);
if (tableStructure != null) {
return tableStructure;
}
return null;
}
private String getSubPartNameTableStructure(Element subElement) {
List