import com.vaadin.client.ui.grid.PositionFunction.Translate3DPosition;
import com.vaadin.client.ui.grid.PositionFunction.TranslatePosition;
import com.vaadin.client.ui.grid.PositionFunction.WebkitTranslate3DPosition;
+import com.vaadin.client.ui.grid.ScrollbarBundle.HorizontalScrollbarBundle;
+import com.vaadin.client.ui.grid.ScrollbarBundle.VerticalScrollbarBundle;
/*-
* that it _might_ perform better (rememeber to measure, implement,
* re-measure)
*/
- /*
- * [[escalator]]: This code will require alterations that are relevant for
- * the escalator functionality.
- */
/*
* [[rowwidth]] [[colwidth]]: This code will require alterations that are
* relevant for being able to support variable row heights or column widths.
}
}
- moveScrollFromEvent(escalator.scrollerElem, -deltaX, -deltaY,
+ moveScrollFromEvent(escalator, -deltaX, -deltaY,
event.getNativeEvent());
}
}
}
- public static void moveScrollFromEvent(final Element scrollerElem,
+ public static void moveScrollFromEvent(final Escalator escalator,
final double deltaX, final double deltaY,
final NativeEvent event) {
- /*
- * TODO [[optimize]]: instead of calling getScollLeft/Top that
- * potentially causes a reflow, update a new scroll absolute
- * position.
- */
- if (!Double.isNaN(deltaX) && deltaX != 0) {
- scrollerElem
- .setScrollLeft((int) (scrollerElem.getScrollLeft() + deltaX));
+
+ if (!Double.isNaN(deltaX)) {
+ escalator.horizontalScrollbar.setScrollPosByDelta((int) deltaX);
}
- if (!Double.isNaN(deltaY) && deltaY != 0) {
- scrollerElem
- .setScrollTop((int) (scrollerElem.getScrollTop() + deltaY));
+
+ if (!Double.isNaN(deltaY)) {
+ escalator.verticalScrollbar.setScrollPosByDelta((int) deltaY);
}
/*
private void cancelBecauseOfEdgeOrCornerMaybe(final int lastLeft,
final int lastTop) {
- if (lastLeft == scrollerElem.getScrollLeft()
- && lastTop == scrollerElem.getScrollTop()) {
+ if (lastLeft == horizontalScrollbar.getScrollPos()
+ && lastTop == verticalScrollbar.getScrollPos()) {
cancel();
}
}
deltaY = -0.5*e.wheelDelta;
}
- var scroller = esc.@com.vaadin.client.ui.grid.Escalator::scrollerElem;
- @com.vaadin.client.ui.grid.Escalator.JsniUtil::moveScrollFromEvent(*)(scroller, deltaX, deltaY, e);
+ @com.vaadin.client.ui.grid.Escalator.JsniUtil::moveScrollFromEvent(*)(esc, deltaX, deltaY, e);
});
}-*/;
* that the sizes of the scroll handles appear correct in the browser
*/
public void recalculateScrollbarsForVirtualViewport() {
- double scrollerHeight = height - header.height;
-
- /*
- * It looks better this way: if we only have a vertical scrollbar,
- * keep it between the header and footer. But if we have a
- * horizontal scrollbar, envelop the footer also.
- */
- if (!needsHorizontalScrollbars()) {
- scrollerHeight -= footer.height;
- }
-
- scrollerElem.getStyle().setHeight(scrollerHeight, Unit.PX);
-
- final double scrollerTop = header.height;
- scrollerElem.getStyle().setTop(scrollerTop, Unit.PX);
-
- /*
- * TODO [[freezecol]]: cut scrollerElem from the left to take freeze
- * columns into account. innerScroller probably needs some
- * adjustments too.
- */
-
// TODO [[rowheight]]: adjust for variable row heights.
- double innerScrollerHeight = ROW_HEIGHT_PX * body.getRowCount();
+ int innerScrollerHeight = ROW_HEIGHT_PX * body.getRowCount();
+
+ double vScrollBottom = footer.height;
if (needsHorizontalScrollbars()) {
- innerScrollerHeight += footer.height;
+ vScrollBottom += horizontalScrollbar.getScrollbarThickness();
}
- innerScrollerElem.getStyle()
- .setHeight(innerScrollerHeight, Unit.PX);
+
+ verticalScrollbar.getElement().getStyle()
+ .setTop(header.height, Unit.PX);
+ verticalScrollbar.getElement().getStyle()
+ .setBottom(vScrollBottom, Unit.PX);
+ verticalScrollbar.setScrollSize(innerScrollerHeight);
// TODO [[colwidth]]: adjust for variable column widths.
int columnsToScroll = columnConfiguration.getColumnCount()
- columnConfiguration.getFrozenColumnCount();
- innerScrollerElem.getStyle().setWidth(
- COLUMN_WIDTH_PX * columnsToScroll, Unit.PX);
+ horizontalScrollbar
+ .setScrollSize(COLUMN_WIDTH_PX * columnsToScroll);
+
+ final Style hScrollbarStyle = horizontalScrollbar.getElement()
+ .getStyle();
+ if (needsVerticalScrollbars()) {
+ final int hScrollbarRight = verticalScrollbar
+ .getScrollbarThickness();
+ hScrollbarStyle.setRight(hScrollbarRight, Unit.PX);
+ } else {
+ hScrollbarStyle.clearRight();
+ }
// we might've got new or got rid of old scrollbars.
recalculateTableWrapperSize();
*/
public void recalculateTableWrapperSize() {
double wrapperHeight = height;
- if (scrollerElem.getOffsetWidth() < innerScrollerElem
- .getOffsetWidth()) {
- wrapperHeight -= Util.getNativeScrollbarSize();
+ if (horizontalScrollbar.getOffsetSize() < horizontalScrollbar
+ .getScrollSize()) {
+ wrapperHeight -= horizontalScrollbar.getScrollbarThickness();
}
double wrapperWidth = width;
- if (scrollerElem.getOffsetHeight() - footer.height < innerScrollerElem
- .getOffsetHeight()) {
- wrapperWidth -= Util.getNativeScrollbarSize();
+ if (verticalScrollbar.getOffsetSize() - footer.height < verticalScrollbar
+ .getScrollSize()) {
+ wrapperWidth -= verticalScrollbar.getScrollbarThickness();
}
tableWrapper.getStyle().setHeight(wrapperHeight, Unit.PX);
return;
}
- final int scrollLeft = scrollerElem.getScrollLeft();
- final int scrollTop = scrollerElem.getScrollTop();
+ final int scrollLeft = horizontalScrollbar.getScrollPos();
+ final int scrollTop = verticalScrollbar.getScrollPos();
if (lastScrollLeft != scrollLeft) {
for (int i = 0; i < columnConfiguration.frozenColumns; i++) {
}
}
- private static final String CLASS_NAME = "v-escalator";
+ static final String CLASS_NAME = "v-escalator";
private abstract class AbstractRowContainer implements RowContainer {
private EscalatorUpdater updater = EscalatorUpdater.NULL;
}
/*
- * TODO [[escalator]][[rowheight]]: even if no rows are evaluated in
- * the current viewport, the heights of some unrendered rows might
- * change in a refresh. This would cause the scrollbar to be
- * adjusted (in scrollHeight and/or scrollTop). Do we want to take
- * this into account?
+ * TODO [[rowheight]]: even if no rows are evaluated in the current
+ * viewport, the heights of some unrendered rows might change in a
+ * refresh. This would cause the scrollbar to be adjusted (in
+ * scrollHeight and/or scrollTop). Do we want to take this into
+ * account?
*/
if (hasColumnAndRowData()) {
/*
final int leftByDiff = (int) (scroller.lastScrollLeft - removedColumnsPxAmount);
final int newScrollLeft = Math.max(firstRemovedColumnLeft,
leftByDiff);
- scrollerElem.setScrollLeft(newScrollLeft);
+ horizontalScrollbar.setScrollPos(newScrollLeft);
}
// this needs to be after the scroll position adjustment above.
* COLUMN_WIDTH_PX;
if (columnsWereAddedToTheLeftOfViewport) {
- scrollerElem
- .setScrollLeft((int) (scroller.lastScrollLeft + numberOfColumns
+ horizontalScrollbar
+ .setScrollPos((int) (scroller.lastScrollLeft + numberOfColumns
* COLUMN_WIDTH_PX));
}
}
*/
scroller.recalculateScrollbarsForVirtualViewport();
- final boolean addedRowsAboveCurrentViewport = index * ROW_HEIGHT_PX < scrollerElem
- .getScrollTop();
- final boolean addedRowsBelowCurrentViewport = index * ROW_HEIGHT_PX > scrollerElem
- .getScrollTop() + calculateHeight();
+ final boolean addedRowsAboveCurrentViewport = index * ROW_HEIGHT_PX < getScrollTop();
+ final boolean addedRowsBelowCurrentViewport = index * ROW_HEIGHT_PX > getScrollTop()
+ + calculateHeight();
if (addedRowsAboveCurrentViewport) {
/*
}
internalScrollEventCalls++;
- scrollerElem.setScrollTop(scrollerElem.getScrollTop() + yDelta);
+ verticalScrollbar.setScrollPosByDelta(yDelta);
final int snappedYDelta = yDelta - yDelta % ROW_HEIGHT_PX;
for (final Element tr : visualRowOrder) {
// TODO [[rowheight]]
final int yDelta = removedAbove.length() * ROW_HEIGHT_PX;
final int firstLogicalRowHeight = ROW_HEIGHT_PX;
- final boolean removalScrollsToShowFirstLogicalRow = scrollerElem
- .getScrollTop() - yDelta < firstLogicalRowHeight;
+ final boolean removalScrollsToShowFirstLogicalRow = verticalScrollbar
+ .getScrollPos() - yDelta < firstLogicalRowHeight;
if (removedVisualInside.isEmpty()
&& (!removalScrollsToShowFirstLogicalRow || !firstVisualRowIsRemoved)) {
* current negative scrolltop, presto!), so that it isn't
* aligned funnily
*/
- adjustScrollPosIgnoreEvents(-scrollerElem.getScrollTop());
+ adjustScrollPosIgnoreEvents(-verticalScrollbar
+ .getScrollPos());
}
}
}
}
- scrollerElem.getStyle().setLeft(frozenColumns * COLUMN_WIDTH_PX,
- Unit.PX);
+ /*
+ * If decreasing the amount of frozen columns, and scrolled to the
+ * right, the scroll position will reset. So we need to remember the
+ * scroll position, and re-apply it once the scrollbar size has been
+ * adjusted.
+ */
+ int scrollPos = horizontalScrollbar.getScrollPos();
+ horizontalScrollbar.getElement().getStyle()
+ .setLeft(frozenColumns * COLUMN_WIDTH_PX, Unit.PX);
scroller.recalculateScrollbarsForVirtualViewport();
+ horizontalScrollbar.setScrollPos(scrollPos);
}
@Override
private int tBodyScrollTop = 0;
private int tBodyScrollLeft = 0;
- private final Element scrollerElem = DOM.createDiv();
- private final Element innerScrollerElem = DOM.createDiv();
+ private final VerticalScrollbarBundle verticalScrollbar = new VerticalScrollbarBundle();
+ private final HorizontalScrollbarBundle horizontalScrollbar = new HorizontalScrollbarBundle();
private final HeaderRowContainer header = new HeaderRowContainer(headElem);
private final BodyRowContainer body = new BodyRowContainer(bodyElem);
setElement(root);
setStyleName(CLASS_NAME);
- scrollerElem.setClassName(CLASS_NAME + "-scroller");
- root.appendChild(scrollerElem);
-
- scrollerElem.appendChild(innerScrollerElem);
+ root.appendChild(verticalScrollbar.getElement());
+ root.appendChild(horizontalScrollbar.getElement());
+ verticalScrollbar.setScrollbarThickness(Util.getNativeScrollbarSize());
+ horizontalScrollbar
+ .setScrollbarThickness(Util.getNativeScrollbarSize());
tableWrapper = DOM.createDiv();
tableWrapper.setClassName(CLASS_NAME + "-tablewrapper");
recalculateElementSizes();
body.paintInsertRows(0, body.getRowCount());
- scroller.attachScrollListener(scrollerElem);
+ scroller.attachScrollListener(verticalScrollbar
+ .getElement());
+ scroller.attachScrollListener(horizontalScrollbar
+ .getElement());
scroller.attachMousewheelListener(getElement());
scroller.attachTouchListeners(getElement());
} else {
- scroller.detachScrollListener(scrollerElem);
+ scroller.detachScrollListener(verticalScrollbar
+ .getElement());
+ scroller.detachScrollListener(horizontalScrollbar
+ .getElement());
scroller.detachMousewheelListener(getElement());
scroller.detachTouchListeners(getElement());
}
* @return the logical vertical scroll offset
*/
public double getScrollTop() {
- return scrollerElem.getScrollTop();
+ return verticalScrollbar.getScrollPos();
}
/**
* the number of pixels to scroll vertically
*/
public void setScrollTop(final double scrollTop) {
- scrollerElem.setScrollTop((int) scrollTop);
+ verticalScrollbar.setScrollPos((int) scrollTop);
}
/**
* @return the logical horizontal scroll offset
*/
public int getScrollLeft() {
- return scrollerElem.getScrollLeft();
+ return horizontalScrollbar.getScrollPos();
}
/**
* the number of pixels to scroll horizontally
*/
public void setScrollLeft(final int scrollLeft) {
- scrollerElem.setScrollLeft(scrollLeft);
+ horizontalScrollbar.setScrollPos(scrollLeft);
}
/**
--- /dev/null
+/*
+ * Copyright 2000-2013 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package com.vaadin.client.ui.grid;
+
+import com.google.gwt.dom.client.Style.Overflow;
+import com.google.gwt.dom.client.Style.Unit;
+import com.google.gwt.user.client.DOM;
+import com.google.gwt.user.client.Element;
+
+/**
+ * An element-like bundle representing a configurable and visual scrollbar in
+ * one axis.
+ *
+ * @since 7.2
+ * @author Vaadin Ltd
+ * @see VerticalScrollbarBundle
+ * @see HorizontalScrollbarBundle
+ */
+abstract class ScrollbarBundle {
+ private static final String CLASS_NAME = Escalator.CLASS_NAME + "-scroller";
+
+ /**
+ * The pixel size for OSX's invisible scrollbars.
+ * <p>
+ * Touch devices don't show a scrollbar at all, so the scrollbar size is
+ * irrelevant in their case. There doesn't seem to be any other popular
+ * platforms that has scrollbars similar to OSX. Thus, this behavior is
+ * tailored for OSX only, until additional platforms start behaving this
+ * way.
+ */
+ private static final int OSX_INVISIBLE_SCROLLBAR_FAKE_SIZE_PX = 13;
+
+ /**
+ * A representation of a single vertical scrollbar.
+ *
+ * @see VerticalScrollbarBundle#getElement()
+ */
+ final static class VerticalScrollbarBundle extends ScrollbarBundle {
+ public VerticalScrollbarBundle() {
+ root.addClassName(CLASS_NAME + "-vertical");
+ }
+
+ @Override
+ public void setScrollPos(int px) {
+ root.setScrollTop(px);
+ }
+
+ @Override
+ public int getScrollPos() {
+ return root.getScrollTop();
+ }
+
+ @Override
+ protected void internalSetScrollSize(int px) {
+ scrollSizeElement.getStyle().setHeight(px, Unit.PX);
+ }
+
+ @Override
+ public int getScrollSize() {
+ return scrollSizeElement.getOffsetHeight();
+ }
+
+ @Override
+ protected void internalSetOffsetSize(int px) {
+ root.getStyle().setHeight(px, Unit.PX);
+ }
+
+ @Override
+ public int getOffsetSize() {
+ return root.getOffsetHeight();
+ }
+
+ @Override
+ protected void internalSetScrollbarThickness(int px) {
+ root.getStyle().setWidth(px, Unit.PX);
+ scrollSizeElement.getStyle().setWidth(px, Unit.PX);
+ }
+
+ @Override
+ protected int internalGetScrollbarThickness() {
+ return root.getOffsetWidth();
+ }
+
+ @Override
+ protected void forceScrollbar(boolean enable) {
+ if (enable) {
+ root.getStyle().setOverflowY(Overflow.SCROLL);
+ } else {
+ root.getStyle().clearOverflowY();
+ }
+ }
+ }
+
+ /**
+ * A representation of a single horizontal scrollbar.
+ *
+ * @see HorizontalScrollbarBundle#getElement()
+ */
+ final static class HorizontalScrollbarBundle extends ScrollbarBundle {
+ protected HorizontalScrollbarBundle() {
+ root.addClassName(CLASS_NAME + "-horizontal");
+ }
+
+ @Override
+ public void setScrollPos(int px) {
+ root.setScrollLeft(px);
+ }
+
+ @Override
+ public int getScrollPos() {
+ return root.getScrollLeft();
+ }
+
+ @Override
+ protected void internalSetScrollSize(int px) {
+ scrollSizeElement.getStyle().setWidth(px, Unit.PX);
+ }
+
+ @Override
+ public int getScrollSize() {
+ return scrollSizeElement.getOffsetWidth();
+ }
+
+ @Override
+ protected void internalSetOffsetSize(int px) {
+ root.getStyle().setWidth(px, Unit.PX);
+ }
+
+ @Override
+ public int getOffsetSize() {
+ return root.getOffsetWidth();
+ }
+
+ @Override
+ protected void internalSetScrollbarThickness(int px) {
+ root.getStyle().setHeight(px, Unit.PX);
+ scrollSizeElement.getStyle().setHeight(px, Unit.PX);
+ }
+
+ @Override
+ protected int internalGetScrollbarThickness() {
+ return root.getOffsetHeight();
+ }
+
+ @Override
+ protected void forceScrollbar(boolean enable) {
+ if (enable) {
+ root.getStyle().setOverflowX(Overflow.SCROLL);
+ } else {
+ root.getStyle().clearOverflowX();
+ }
+ }
+ }
+
+ protected final Element root = DOM.createDiv();
+ protected final Element scrollSizeElement = DOM.createDiv();
+ protected boolean isInvisibleScrollbar = false;
+
+ private ScrollbarBundle() {
+ root.appendChild(scrollSizeElement);
+ root.setClassName(CLASS_NAME);
+ }
+
+ /**
+ * Gets the root element of this scrollbar-composition.
+ *
+ * @return the root element
+ */
+ public Element getElement() {
+ return root;
+ }
+
+ /**
+ * Modifies the scroll position of this scrollbar by a number of pixels
+ *
+ * @param delta
+ * the delta in pixels to change the scroll position by
+ */
+ public void setScrollPosByDelta(int delta) {
+ if (delta != 0) {
+ /*
+ * TODO [[optimize]]: rewrite this so that we can evoid a potential
+ * reflow from getScrollPos()
+ */
+ setScrollPos(getScrollPos() + delta);
+ }
+ }
+
+ /**
+ * Modifies {@link #root root's} dimensions in the axis the scrollbar is
+ * representing.
+ *
+ * @param px
+ * the new size of {@link #root} in the dimension this scrollbar
+ * is representing
+ */
+ protected abstract void internalSetOffsetSize(int px);
+
+ /**
+ * Sets the length of the scrollbar.
+ *
+ * @param px
+ * the length of the scrollbar in pixels
+ */
+ public void setOffsetSize(int px) {
+ internalSetOffsetSize(px);
+ forceScrollbar(needsScrollbars());
+ }
+
+ /**
+ * Force the scrollbar to be visible with CSS. In practice, this means to
+ * set either <code>overflow-x</code> or <code>overflow-y</code> to "
+ * <code>scroll</code>" in the scrollbar's direction.
+ * <p>
+ * This is an IE8 workaround, since it doesn't always show scrollbars with
+ * <code>overflow: auto</code> enabled.
+ */
+ protected abstract void forceScrollbar(boolean enable);
+
+ /**
+ * Gets the length of the scrollbar
+ *
+ * @return the length of the scrollbar in pixels
+ */
+ public abstract int getOffsetSize();
+
+ /**
+ * Sets the scroll position of the scrollbar in the axis the scrollbar is
+ * representing.
+ *
+ * @param px
+ * the new scroll position in pixels
+ */
+ public abstract void setScrollPos(int px);
+
+ /**
+ * Gets the scroll position of the scrollbar in the axis the scrollbar is
+ * representing.
+ *
+ * @return the new scroll position in pixels
+ */
+ public abstract int getScrollPos();
+
+ /**
+ * Modifies {@link #scrollSizeElement scrollSizeElement's} dimensions in
+ * such a way that the scrollbar is able to scroll a certain number of
+ * pixels in the axis it is representing.
+ *
+ * @param px
+ * the new size of {@link #scrollSizeElement} in the dimension
+ * this scrollbar is representing
+ */
+ protected abstract void internalSetScrollSize(int px);
+
+ /**
+ * Sets the amount of pixels the scrollbar needs to be able to scroll
+ * through.
+ *
+ * @param px
+ * the number of pixels the scrollbar should be able to scroll
+ * through
+ */
+ public void setScrollSize(int px) {
+ internalSetScrollSize(px);
+ forceScrollbar(needsScrollbars());
+ }
+
+ /**
+ * Gets the amount of pixels the scrollbar needs to be able to scroll
+ * through.
+ *
+ * @return the number of pixels the scrollbar should be able to scroll
+ * through
+ */
+ public abstract int getScrollSize();
+
+ /**
+ * Modifies {@link #scrollSizeElement scrollSizeElement's} dimensions in the
+ * opposite axis to what the scrollbar is representing.
+ *
+ * @param px
+ * the dimension that {@link #scrollSizeElement} should take in
+ * the opposite axis to what the scrollbar is representing
+ */
+ protected abstract void internalSetScrollbarThickness(int px);
+
+ /**
+ * Sets the scrollbar's thickness.
+ * <p>
+ * If the thickness is set to 0, the scrollbar will be treated as an
+ * "invisible" scrollbar. This means, the DOM structure will be given a
+ * non-zero size, but {@link #getScrollbarThickness()} will still return the
+ * value 0.
+ *
+ * @param px
+ * the scrollbar's thickness in pixels
+ */
+ public void setScrollbarThickness(int px) {
+ isInvisibleScrollbar = (px == 0);
+ internalSetScrollbarThickness(px != 0 ? px
+ : OSX_INVISIBLE_SCROLLBAR_FAKE_SIZE_PX);
+ }
+
+ /**
+ * Gets the scrollbar's thickness as defined in the DOM.
+ *
+ * @return the scrollbar's thickness as defined in the DOM, in pixels
+ */
+ protected abstract int internalGetScrollbarThickness();
+
+ /**
+ * Gets the scrollbar's thickness.
+ * <p>
+ * This value will differ from the value in the DOM, if the thickness was
+ * set to 0 with {@link #setScrollbarThickness(int)}, as the scrollbar is
+ * then treated as "invisible."
+ *
+ * @return the scrollbar's thickness in pixels
+ */
+ public int getScrollbarThickness() {
+ if (!isInvisibleScrollbar) {
+ return internalGetScrollbarThickness();
+ } else {
+ return 0;
+ }
+ }
+
+ /**
+ * Checks whether the scrollbar should be active and needed, i.e. if the
+ * "content" is larger than the "frame".
+ *
+ * @return <code>true</code> iff the scrollbar should be active and needed
+ */
+ protected boolean needsScrollbars() {
+ return getOffsetSize() < getScrollSize();
+ }
+}
projects / vaadin-framework.git / commitdiff