Grid supports data set changes (#12645)

Change-Id: I5ceb52dea079f48b0065c1b2dbdc35b30fe8c4ee

8 files changed, 159 insertions, 711 deletions

diff --git a/client/src/com/vaadin/client/data/AbstractRemoteDataSource.java b/client/src/com/vaadin/client/data/AbstractRemoteDataSource.java
index ff8847ea44..127eb80696 100644
--- a/client/src/com/vaadin/client/data/AbstractRemoteDataSource.java
+++ b/client/src/com/vaadin/client/data/AbstractRemoteDataSource.java
@@ -22,7 +22,7 @@ import java.util.List;
 import com.google.gwt.core.client.Scheduler;
 import com.google.gwt.core.client.Scheduler.ScheduledCommand;
 import com.vaadin.client.Profiler;
-import com.vaadin.client.ui.grid.Range;
+import com.vaadin.shared.ui.grid.Range;
 
 /**
  * Base implementation for data sources that fetch data from a remote system.
@@ -238,4 +238,86 @@ public abstract class AbstractRemoteDataSource<T> implements DataSource<T> {
 
         Profiler.leave("AbstractRemoteDataSource.setRowData");
     }
+
+    /**
+     * Informs this data source that the server has removed data.
+     * 
+     * @param firstRowIndex
+     *            the index of the first removed row
+     * @param count
+     *            the number of removed rows, starting from
+     *            <code>firstRowIndex</code>
+     */
+    protected void removeRowData(int firstRowIndex, int count) {
+        Profiler.enter("AbstractRemoteDataSource.removeRowData");
+
+        // pack the cached data
+        for (int i = 0; i < count; i++) {
+            Integer oldIndex = Integer.valueOf(firstRowIndex + count + i);
+            if (rowCache.containsKey(oldIndex)) {
+                Integer newIndex = Integer.valueOf(firstRowIndex + i);
+                rowCache.put(newIndex, rowCache.remove(oldIndex));
+            }
+        }
+
+        Range removedRange = Range.withLength(firstRowIndex, count);
+        if (removedRange.intersects(cached)) {
+            Range[] partitions = cached.partitionWith(removedRange);
+            Range remainsBefore = partitions[0];
+            Range transposedRemainsAfter = partitions[2].offsetBy(-removedRange
+                    .length());
+            cached = remainsBefore.combineWith(transposedRemainsAfter);
+        }
+        estimatedSize -= count;
+        dataChangeHandler.dataRemoved(firstRowIndex, count);
+        checkCacheCoverage();
+
+        Profiler.leave("AbstractRemoteDataSource.removeRowData");
+    }
+
+    /**
+     * Informs this data source that new data has been inserted from the server.
+     * 
+     * @param firstRowIndex
+     *            the destination index of the new row data
+     * @param count
+     *            the number of rows inserted
+     */
+    protected void insertRowData(int firstRowIndex, int count) {
+        Profiler.enter("AbstractRemoteDataSource.insertRowData");
+
+        if (cached.contains(firstRowIndex)) {
+            int oldCacheEnd = cached.getEnd();
+            /*
+             * We need to invalidate the cache from the inserted row onwards,
+             * since the cache wants to be a contiguous range. It doesn't
+             * support holes.
+             * 
+             * If holes were supported, we could shift the higher part of
+             * "cached" and leave a hole the size of "count" in the middle.
+             */
+            cached = cached.splitAt(firstRowIndex)[0];
+
+            for (int i = firstRowIndex; i < oldCacheEnd; i++) {
+                rowCache.remove(Integer.valueOf(i));
+            }
+        }
+
+        else if (firstRowIndex < cached.getStart()) {
+            Range oldCached = cached;
+            cached = cached.offsetBy(count);
+
+            for (int i = 0; i < rowCache.size(); i++) {
+                Integer oldIndex = Integer.valueOf(oldCached.getEnd() - i);
+                Integer newIndex = Integer.valueOf(cached.getEnd() - i);
+                rowCache.put(newIndex, rowCache.remove(oldIndex));
+            }
+        }
+
+        estimatedSize += count;
+        dataChangeHandler.dataAdded(firstRowIndex, count);
+        checkCacheCoverage();
+
+        Profiler.leave("AbstractRemoteDataSource.insertRowData");
+    }
 }
diff --git a/client/src/com/vaadin/client/data/RpcDataSourceConnector.java b/client/src/com/vaadin/client/data/RpcDataSourceConnector.java
index 1785fc62c2..4d22c10197 100644
--- a/client/src/com/vaadin/client/data/RpcDataSourceConnector.java
+++ b/client/src/com/vaadin/client/data/RpcDataSourceConnector.java
@@ -56,6 +56,16 @@ public class RpcDataSourceConnector extends AbstractExtensionConnector {
             public void setRowData(int firstRow, List<String[]> rows) {
                 dataSource.setRowData(firstRow, rows);
             }
+
+            @Override
+            public void removeRowData(int firstRow, int count) {
+                dataSource.removeRowData(firstRow, count);
+            }
+
+            @Override
+            public void insertRowData(int firstRow, int count) {
+                dataSource.insertRowData(firstRow, count);
+            }
         });
     }
 
diff --git a/client/src/com/vaadin/client/ui/grid/Escalator.java b/client/src/com/vaadin/client/ui/grid/Escalator.java
index 20a187e1a5..a395038890 100644
--- a/client/src/com/vaadin/client/ui/grid/Escalator.java
+++ b/client/src/com/vaadin/client/ui/grid/Escalator.java
@@ -35,12 +35,12 @@ import com.google.gwt.dom.client.NodeList;
 import com.google.gwt.dom.client.Style;
 import com.google.gwt.dom.client.Style.Display;
 import com.google.gwt.dom.client.Style.Unit;
+import com.google.gwt.event.shared.HandlerRegistration;
 import com.google.gwt.user.client.DOM;
 import com.google.gwt.user.client.Element;
 import com.google.gwt.user.client.Window;
 import com.google.gwt.user.client.ui.UIObject;
 import com.google.gwt.user.client.ui.Widget;
-import com.google.web.bindery.event.shared.HandlerRegistration;
 import com.vaadin.client.Profiler;
 import com.vaadin.client.Util;
 import com.vaadin.client.ui.grid.Escalator.JsniUtil.TouchHandlerBundle;
@@ -50,6 +50,7 @@ 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;
+import com.vaadin.shared.ui.grid.Range;
 import com.vaadin.shared.util.SharedUtil;
 
 /*-
@@ -1633,6 +1634,8 @@ public class Escalator extends Widget {
                 return;
             }
 
+            boolean rowsWereMoved = false;
+
             final int topRowPos = getRowTop(visualRowOrder.getFirst());
             // TODO [[mpixscroll]]
             final int scrollTop = tBodyScrollTop;
@@ -1655,6 +1658,8 @@ public class Escalator extends Widget {
                 final int logicalRowIndex = scrollTop / ROW_HEIGHT_PX;
                 moveAndUpdateEscalatorRows(Range.between(start, end), 0,
                         logicalRowIndex);
+
+                rowsWereMoved = (rowsToMove != 0);
             }
 
             else if (viewportOffset + ROW_HEIGHT_PX <= 0) {
@@ -1723,9 +1728,13 @@ public class Escalator extends Widget {
                             .get(1)) - 1;
                     moveAndUpdateEscalatorRows(strayRow, 0, topLogicalIndex);
                 }
+
+                rowsWereMoved = (rowsToMove != 0);
             }
 
-            fireRowVisibilityChangeEvent();
+            if (rowsWereMoved) {
+                fireRowVisibilityChangeEvent();
+            }
         }
 
         @Override
@@ -1805,6 +1814,8 @@ public class Escalator extends Widget {
                     setRowPosition(tr, 0, rowTop);
                     rowTop += ROW_HEIGHT_PX;
                 }
+
+                fireRowVisibilityChangeEvent();
             }
             return addedRows;
         }
@@ -1919,8 +1930,6 @@ public class Escalator extends Widget {
                     newRowTop += ROW_HEIGHT_PX;
                 }
             }
-
-            fireRowVisibilityChangeEvent();
         }
 
         /**
@@ -3181,9 +3190,15 @@ public class Escalator extends Widget {
      */
     @Override
     public void setHeight(final String height) {
+        final int escalatorRowsBefore = body.visualRowOrder.size();
+
         super.setHeight(height != null && !height.isEmpty() ? height
                 : DEFAULT_HEIGHT);
         recalculateElementSizes();
+
+        if (escalatorRowsBefore != body.visualRowOrder.size()) {
+            fireRowVisibilityChangeEvent();
+        }
     }
 
     /**
@@ -3437,26 +3452,30 @@ public class Escalator extends Widget {
      * Adds an event handler that gets notified when the range of visible rows
      * changes e.g. because of scrolling.
      * 
-     * @param rowVisibilityChangeHadler
+     * @param rowVisibilityChangeHandler
      *            the event handler
      * @return a handler registration for the added handler
      */
     public HandlerRegistration addRowVisibilityChangeHandler(
-            RowVisibilityChangeHandler rowVisibilityChangeHadler) {
-        return addHandler(rowVisibilityChangeHadler,
+            RowVisibilityChangeHandler rowVisibilityChangeHandler) {
+        return addHandler(rowVisibilityChangeHandler,
                 RowVisibilityChangeEvent.TYPE);
     }
 
     private void fireRowVisibilityChangeEvent() {
-        int visibleRangeStart = body.getLogicalRowIndex(body.visualRowOrder
-                .getFirst());
-        int visibleRangeEnd = body.getLogicalRowIndex(body.visualRowOrder
-                .getLast()) + 1;
+        if (!body.visualRowOrder.isEmpty()) {
+            int visibleRangeStart = body.getLogicalRowIndex(body.visualRowOrder
+                    .getFirst());
+            int visibleRangeEnd = body.getLogicalRowIndex(body.visualRowOrder
+                    .getLast()) + 1;
 
-        int visibleRowCount = visibleRangeEnd - visibleRangeStart;
+            int visibleRowCount = visibleRangeEnd - visibleRangeStart;
 
-        fireEvent(new RowVisibilityChangeEvent(visibleRangeStart,
-                visibleRowCount));
+            fireEvent(new RowVisibilityChangeEvent(visibleRangeStart,
+                    visibleRowCount));
+        } else {
+            fireEvent(new RowVisibilityChangeEvent(0, 0));
+        }
     }
 
     /**
diff --git a/client/src/com/vaadin/client/ui/grid/Grid.java b/client/src/com/vaadin/client/ui/grid/Grid.java
index 2dbb0275cd..7f8ab408a9 100644
--- a/client/src/com/vaadin/client/ui/grid/Grid.java
+++ b/client/src/com/vaadin/client/ui/grid/Grid.java
@@ -21,6 +21,7 @@ import java.util.List;
 
 import com.google.gwt.core.shared.GWT;
 import com.google.gwt.dom.client.Element;
+import com.google.gwt.event.shared.HandlerRegistration;
 import com.google.gwt.user.client.ui.Composite;
 import com.google.gwt.user.client.ui.HasVisibility;
 import com.google.gwt.user.client.ui.Widget;
@@ -73,6 +74,10 @@ public class Grid<T> extends Composite {
      */
     private final List<GridColumn<?, T>> columns = new ArrayList<GridColumn<?, T>>();
 
+    /**
+     * The datasource currently in use. <em>Note:</em> it is <code>null</code>
+     * on initialization, but not after that.
+     */
     private DataSource<T> dataSource;
 
     /**
@@ -1211,4 +1216,14 @@ public class Grid<T> extends Composite {
     public GridColumn<?, T> getLastFrozenColumn() {
         return lastFrozenColumn;
     }
+
+    public HandlerRegistration addRowVisibilityChangeHandler(
+            RowVisibilityChangeHandler handler) {
+        /*
+         * Reusing Escalator's RowVisibilityChangeHandler, since a scroll
+         * concept is too abstract. e.g. the event needs to be re-sent when the
+         * widget is resized.
+         */
+        return escalator.addRowVisibilityChangeHandler(handler);
+    }
 }
diff --git a/client/src/com/vaadin/client/ui/grid/GridConnector.java b/client/src/com/vaadin/client/ui/grid/GridConnector.java
index ffe1444942..f04326c7e6 100644
--- a/client/src/com/vaadin/client/ui/grid/GridConnector.java
+++ b/client/src/com/vaadin/client/ui/grid/GridConnector.java
@@ -30,6 +30,7 @@ import com.vaadin.shared.ui.Connect;
 import com.vaadin.shared.ui.grid.ColumnGroupRowState;
 import com.vaadin.shared.ui.grid.ColumnGroupState;
 import com.vaadin.shared.ui.grid.GridColumnState;
+import com.vaadin.shared.ui.grid.GridServerRpc;
 import com.vaadin.shared.ui.grid.GridState;
 
 /**
@@ -83,6 +84,21 @@ public class GridConnector extends AbstractComponentConnector {
     }
 
     @Override
+    protected void init() {
+        super.init();
+        getWidget().addRowVisibilityChangeHandler(
+                new RowVisibilityChangeHandler() {
+                    @Override
+                    public void onRowVisibilityChange(
+                            RowVisibilityChangeEvent event) {
+                        getRpcProxy(GridServerRpc.class).setVisibleRows(
+                                event.getFirstVisibleRow(),
+                                event.getVisibleRowCount());
+                    }
+                });
+    }
+
+    @Override
     public void onStateChanged(StateChangeEvent stateChangeEvent) {
         super.onStateChanged(stateChangeEvent);
 
diff --git a/client/src/com/vaadin/client/ui/grid/Range.java b/client/src/com/vaadin/client/ui/grid/Range.java
deleted file mode 100644
index 634a182421..0000000000
--- a/client/src/com/vaadin/client/ui/grid/Range.java
+++ /dev/null
@@ -1,378 +0,0 @@
-/*
- * 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;
-
-/**
- * An immutable representation of a range, marked by start and end points.
- * <p>
- * The range is treated as inclusive at the start, and exclusive at the end.
- * I.e. the range [0..1[ has the length 1, and represents one integer: 0.
- * <p>
- * The range is considered {@link #isEmpty() empty} if the start is the same as
- * the end.
- * 
- * @since 7.2
- * @author Vaadin Ltd
- */
-public final class Range {
-    private final int start;
-    private final int end;
-
-    /**
-     * Creates a range object representing a single integer.
-     * 
-     * @param integer
-     *            the number to represent as a range
-     * @return the range represented by <code>integer</code>
-     */
-    public static Range withOnly(final int integer) {
-        return new Range(integer, integer + 1);
-    }
-
-    /**
-     * Creates a range between two integers.
-     * <p>
-     * The range start is <em>inclusive</em> and the end is <em>exclusive</em>.
-     * So, a range "between" 0 and 5 represents the numbers 0, 1, 2, 3 and 4,
-     * but not 5.
-     * 
-     * @param start
-     *            the start of the the range, inclusive
-     * @param end
-     *            the end of the range, exclusive
-     * @return a range representing <code>[start..end[</code>
-     * @throws IllegalArgumentException
-     *             if <code>start &gt; end</code>
-     */
-    public static Range between(final int start, final int end)
-            throws IllegalArgumentException {
-        return new Range(start, end);
-    }
-
-    /**
-     * Creates a range from a start point, with a given length.
-     * 
-     * @param start
-     *            the first integer to include in the range
-     * @param length
-     *            the length of the resulting range
-     * @return a range starting from <code>start</code>, with
-     *         <code>length</code> number of integers following
-     * @throws IllegalArgumentException
-     *             if length &lt; 0
-     */
-    public static Range withLength(final int start, final int length)
-            throws IllegalArgumentException {
-        if (length < 0) {
-            /*
-             * The constructor of Range will throw an exception if start >
-             * start+length (i.e. if length is negative). We're throwing the
-             * same exception type, just with a more descriptive message.
-             */
-            throw new IllegalArgumentException("length must not be negative");
-        }
-        return new Range(start, start + length);
-    }
-
-    /**
-     * Creates a new range between two numbers: <code>[start..end[</code>.
-     * 
-     * @param start
-     *            the start integer, inclusive
-     * @param end
-     *            the end integer, exclusive
-     * @throws IllegalArgumentException
-     *             if <code>start &gt; end</code>
-     */
-    private Range(final int start, final int end)
-            throws IllegalArgumentException {
-        if (start > end) {
-            throw new IllegalArgumentException(
-                    "start must not be greater than end");
-        }
-
-        this.start = start;
-        this.end = end;
-    }
-
-    /**
-     * Returns the <em>inclusive</em> start point of this range.
-     * 
-     * @return the start point of this range
-     */
-    public int getStart() {
-        return start;
-    }
-
-    /**
-     * Returns the <em>exclusive</em> end point of this range.
-     * 
-     * @return the end point of this range
-     */
-    public int getEnd() {
-        return end;
-    }
-
-    /**
-     * The number of integers contained in the range.
-     * 
-     * @return the number of integers contained in the range
-     */
-    public int length() {
-        return getEnd() - getStart();
-    }
-
-    /**
-     * Checks whether the range has no elements between the start and end.
-     * 
-     * @return <code>true</code> iff the range contains no elements.
-     */
-    public boolean isEmpty() {
-        return getStart() >= getEnd();
-    }
-
-    /**
-     * Checks whether this range and another range are at least partially
-     * covering the same values.
-     * 
-     * @param other
-     *            the other range to check against
-     * @return <code>true</code> if this and <code>other</code> intersect
-     */
-    public boolean intersects(final Range other) {
-        return getStart() < other.getEnd() && other.getStart() < getEnd();
-    }
-
-    /**
-     * Checks whether an integer is found within this range.
-     * 
-     * @param integer
-     *            an integer to test for presence in this range
-     * @return <code>true</code> iff <code>integer</code> is in this range
-     */
-    public boolean contains(final int integer) {
-        return getStart() <= integer && integer < getEnd();
-    }
-
-    /**
-     * Checks whether this range is a subset of another range.
-     * 
-     * @return <code>true</code> iff <code>other</code> completely wraps this
-     *         range
-     */
-    public boolean isSubsetOf(final Range other) {
-        return other.getStart() <= getStart() && getEnd() <= other.getEnd();
-    }
-
-    /**
-     * Overlay this range with another one, and partition the ranges according
-     * to how they position relative to each other.
-     * <p>
-     * The three partitions are returned as a three-element Range array:
-     * <ul>
-     * <li>Elements in this range that occur before elements in
-     * <code>other</code>.
-     * <li>Elements that are shared between the two ranges.
-     * <li>Elements in this range that occur after elements in
-     * <code>other</code>.
-     * </ul>
-     * 
-     * @param other
-     *            the other range to act as delimiters.
-     * @return a three-element Range array of partitions depicting the elements
-     *         before (index 0), shared/inside (index 1) and after (index 2).
-     */
-    public Range[] partitionWith(final Range other) {
-        final Range[] splitBefore = splitAt(other.getStart());
-        final Range rangeBefore = splitBefore[0];
-        final Range[] splitAfter = splitBefore[1].splitAt(other.getEnd());
-        final Range rangeInside = splitAfter[0];
-        final Range rangeAfter = splitAfter[1];
-        return new Range[] { rangeBefore, rangeInside, rangeAfter };
-    }
-
-    /**
-     * Get a range that is based on this one, but offset by a number.
-     * 
-     * @param offset
-     *            the number to offset by
-     * @return a copy of this range, offset by <code>offset</code>
-     */
-    public Range offsetBy(final int offset) {
-        if (offset == 0) {
-            return this;
-        } else {
-            return new Range(start + offset, end + offset);
-        }
-    }
-
-    @Override
-    public String toString() {
-        return getClass().getSimpleName() + " [" + getStart() + ".." + getEnd()
-                + "[" + (isEmpty() ? " (empty)" : "");
-    }
-
-    @Override
-    public int hashCode() {
-        final int prime = 31;
-        int result = 1;
-        result = prime * result + end;
-        result = prime * result + start;
-        return result;
-    }
-
-    @Override
-    public boolean equals(final Object obj) {
-        if (this == obj) {
-            return true;
-        }
-        if (obj == null) {
-            return false;
-        }
-        if (getClass() != obj.getClass()) {
-            return false;
-        }
-        final Range other = (Range) obj;
-        if (end != other.end) {
-            return false;
-        }
-        if (start != other.start) {
-            return false;
-        }
-        return true;
-    }
-
-    /**
-     * Checks whether this range starts before the start of another range.
-     * 
-     * @param other
-     *            the other range to compare against
-     * @return <code>true</code> iff this range starts before the
-     *         <code>other</code>
-     */
-    public boolean startsBefore(final Range other) {
-        return getStart() < other.getStart();
-    }
-
-    /**
-     * Checks whether this range ends before the start of another range.
-     * 
-     * @param other
-     *            the other range to compare against
-     * @return <code>true</code> iff this range ends before the
-     *         <code>other</code>
-     */
-    public boolean endsBefore(final Range other) {
-        return getEnd() <= other.getStart();
-    }
-
-    /**
-     * Checks whether this range ends after the end of another range.
-     * 
-     * @param other
-     *            the other range to compare against
-     * @return <code>true</code> iff this range ends after the
-     *         <code>other</code>
-     */
-    public boolean endsAfter(final Range other) {
-        return getEnd() > other.getEnd();
-    }
-
-    /**
-     * Checks whether this range starts after the end of another range.
-     * 
-     * @param other
-     *            the other range to compare against
-     * @return <code>true</code> iff this range starts after the
-     *         <code>other</code>
-     */
-    public boolean startsAfter(final Range other) {
-        return getStart() >= other.getEnd();
-    }
-
-    /**
-     * Split the range into two at a certain integer.
-     * <p>
-     * <em>Example:</em> <code>[5..10[.splitAt(7) == [5..7[, [7..10[</code>
-     * 
-     * @param integer
-     *            the integer at which to split the range into two
-     * @return an array of two ranges, with <code>[start..integer[</code> in the
-     *         first element, and <code>[integer..end[</code> in the second
-     *         element.
-     *         <p>
-     *         If {@code integer} is less than {@code start}, [empty,
-     *         {@code this} ] is returned. if <code>integer</code> is equal to
-     *         or greater than {@code end}, [{@code this}, empty] is returned
-     *         instead.
-     */
-    public Range[] splitAt(final int integer) {
-        if (integer < start) {
-            return new Range[] { Range.withLength(start, 0), this };
-        } else if (integer >= end) {
-            return new Range[] { this, Range.withLength(end, 0) };
-        } else {
-            return new Range[] { new Range(start, integer),
-                    new Range(integer, end) };
-        }
-    }
-
-    /**
-     * Split the range into two after a certain number of integers into the
-     * range.
-     * <p>
-     * Calling this method is equivalent to calling
-     * <code>{@link #splitAt(int) splitAt}({@link #getStart()}+length);</code>
-     * <p>
-     * <em>Example:</em>
-     * <code>[5..10[.splitAtFromStart(2) == [5..7[, [7..10[</code>
-     * 
-     * @param length
-     *            the length at which to split this range into two
-     * @return an array of two ranges, having the <code>length</code>-first
-     *         elements of this range, and the second range having the rest. If
-     *         <code>length</code> &leq; 0, the first element will be empty, and
-     *         the second element will be this range. If <code>length</code>
-     *         &geq; {@link #length()}, the first element will be this range,
-     *         and the second element will be empty.
-     */
-    public Range[] splitAtFromStart(final int length) {
-        return splitAt(getStart() + length);
-    }
-
-    /**
-     * Combines two ranges to create a range containing all values in both
-     * ranges, provided there are no gaps between the ranges.
-     * 
-     * @param other
-     *            the range to combine with this range
-     * 
-     * @return the combined range
-     * 
-     * @throws IllegalArgumentException
-     *             if the two ranges aren't connected
-     */
-    public Range combineWith(Range other) throws IllegalArgumentException {
-        if (getStart() > other.getEnd() || other.getStart() > getEnd()) {
-            throw new IllegalArgumentException("There is a gap between " + this
-                    + " and " + other);
-        }
-
-        return Range.between(Math.min(getStart(), other.getStart()),
-                Math.max(getEnd(), other.getEnd()));
-    }
-}
diff --git a/client/tests/src/com/vaadin/client/ui/grid/PartitioningTest.java b/client/tests/src/com/vaadin/client/ui/grid/PartitioningTest.java
index 3cbc6351b1..e97bb339e4 100644
--- a/client/tests/src/com/vaadin/client/ui/grid/PartitioningTest.java
+++ b/client/tests/src/com/vaadin/client/ui/grid/PartitioningTest.java
@@ -21,6 +21,8 @@ import static org.junit.Assert.assertTrue;
 
 import org.junit.Test;
 
+import com.vaadin.shared.ui.grid.Range;
+
 @SuppressWarnings("static-method")
 public class PartitioningTest {
 
diff --git a/client/tests/src/com/vaadin/client/ui/grid/RangeTest.java b/client/tests/src/com/vaadin/client/ui/grid/RangeTest.java
deleted file mode 100644
index d73b0fb02f..0000000000
--- a/client/tests/src/com/vaadin/client/ui/grid/RangeTest.java
+++ /dev/null
@@ -1,318 +0,0 @@
-/*
- * 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 static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-
-import org.junit.Test;
-
-@SuppressWarnings("static-method")
-public class RangeTest {
-
-    @Test(expected = IllegalArgumentException.class)
-    public void startAfterEndTest() {
-        Range.between(10, 9);
-    }
-
-    @Test(expected = IllegalArgumentException.class)
-    public void negativeLengthTest() {
-        Range.withLength(10, -1);
-    }
-
-    @Test
-    public void constructorEquivalenceTest() {
-        assertEquals("10 == [10,11[", Range.withOnly(10), Range.between(10, 11));
-        assertEquals("[10,20[ == 10, length 10", Range.between(10, 20),
-                Range.withLength(10, 10));
-        assertEquals("10 == 10, length 1", Range.withOnly(10),
-                Range.withLength(10, 1));
-    }
-
-    @Test
-    public void boundsTest() {
-        {
-            final Range range = Range.between(0, 10);
-            assertEquals("between(0, 10) start", 0, range.getStart());
-            assertEquals("between(0, 10) end", 10, range.getEnd());
-        }
-
-        {
-            final Range single = Range.withOnly(10);
-            assertEquals("withOnly(10) start", 10, single.getStart());
-            assertEquals("withOnly(10) end", 11, single.getEnd());
-        }
-
-        {
-            final Range length = Range.withLength(10, 5);
-            assertEquals("withLength(10, 5) start", 10, length.getStart());
-            assertEquals("withLength(10, 5) end", 15, length.getEnd());
-        }
-    }
-
-    @Test
-    @SuppressWarnings("boxing")
-    public void equalsTest() {
-        final Range range1 = Range.between(0, 10);
-        final Range range2 = Range.withLength(0, 11);
-
-        assertTrue("null", !range1.equals(null));
-        assertTrue("reflexive", range1.equals(range1));
-        assertEquals("symmetric", range1.equals(range2), range2.equals(range1));
-    }
-
-    @Test
-    public void containsTest() {
-        final int start = 0;
-        final int end = 10;
-        final Range range = Range.between(start, end);
-
-        assertTrue("start should be contained", range.contains(start));
-        assertTrue("start-1 should not be contained",
-                !range.contains(start - 1));
-        assertTrue("end should not be contained", !range.contains(end));
-        assertTrue("end-1 should be contained", range.contains(end - 1));
-
-        assertTrue("[0..10[ contains 5", Range.between(0, 10).contains(5));
-        assertTrue("empty range does not contain 5", !Range.between(5, 5)
-                .contains(5));
-    }
-
-    @Test
-    public void emptyTest() {
-        assertTrue("[0..0[ should be empty", Range.between(0, 0).isEmpty());
-        assertTrue("Range of length 0 should be empty", Range.withLength(0, 0)
-                .isEmpty());
-
-        assertTrue("[0..1[ should not be empty", !Range.between(0, 1).isEmpty());
-        assertTrue("Range of length 1 should not be empty",
-                !Range.withLength(0, 1).isEmpty());
-    }
-
-    @Test
-    public void splitTest() {
-        final Range startRange = Range.between(0, 10);
-        final Range[] splitRanges = startRange.splitAt(5);
-        assertEquals("[0..10[ split at 5, lower", Range.between(0, 5),
-                splitRanges[0]);
-        assertEquals("[0..10[ split at 5, upper", Range.between(5, 10),
-                splitRanges[1]);
-    }
-
-    @Test
-    public void split_valueBefore() {
-        Range range = Range.between(10, 20);
-        Range[] splitRanges = range.splitAt(5);
-
-        assertEquals(Range.between(10, 10), splitRanges[0]);
-        assertEquals(range, splitRanges[1]);
-    }
-
-    @Test
-    public void split_valueAfter() {
-        Range range = Range.between(10, 20);
-        Range[] splitRanges = range.splitAt(25);
-
-        assertEquals(range, splitRanges[0]);
-        assertEquals(Range.between(20, 20), splitRanges[1]);
-    }
-
-    @Test
-    public void emptySplitTest() {
-        final Range range = Range.between(5, 10);
-        final Range[] split1 = range.splitAt(0);
-        assertTrue("split1, [0]", split1[0].isEmpty());
-        assertEquals("split1, [1]", range, split1[1]);
-
-        final Range[] split2 = range.splitAt(15);
-        assertEquals("split2, [0]", range, split2[0]);
-        assertTrue("split2, [1]", split2[1].isEmpty());
-    }
-
-    @Test
-    public void lengthTest() {
-        assertEquals("withLength length", 5, Range.withLength(10, 5).length());
-        assertEquals("between length", 5, Range.between(10, 15).length());
-        assertEquals("withOnly 10 length", 1, Range.withOnly(10).length());
-    }
-
-    @Test
-    public void intersectsTest() {
-        assertTrue("[0..10[ intersects [5..15[", Range.between(0, 10)
-                .intersects(Range.between(5, 15)));
-        assertTrue("[0..10[ does not intersect [10..20[", !Range.between(0, 10)
-                .intersects(Range.between(10, 20)));
-    }
-
-    @Test
-    public void intersects_emptyInside() {
-        assertTrue("[5..5[ does intersect with [0..10[", Range.between(5, 5)
-                .intersects(Range.between(0, 10)));
-        assertTrue("[0..10[ does intersect with [5..5[", Range.between(0, 10)
-                .intersects(Range.between(5, 5)));
-    }
-
-    @Test
-    public void intersects_emptyOutside() {
-        assertTrue("[15..15[ does not intersect with [0..10[",
-                !Range.between(15, 15).intersects(Range.between(0, 10)));
-        assertTrue("[0..10[ does not intersect with [15..15[",
-                !Range.between(0, 10).intersects(Range.between(15, 15)));
-    }
-
-    @Test
-    public void subsetTest() {
-        assertTrue("[5..10[ is subset of [0..20[", Range.between(5, 10)
-                .isSubsetOf(Range.between(0, 20)));
-
-        final Range range = Range.between(0, 10);
-        assertTrue("range is subset of self", range.isSubsetOf(range));
-
-        assertTrue("[0..10[ is not subset of [5..15[", !Range.between(0, 10)
-                .isSubsetOf(Range.between(5, 15)));
-    }
-
-    @Test
-    public void offsetTest() {
-        assertEquals(Range.between(5, 15), Range.between(0, 10).offsetBy(5));
-    }
-
-    @Test
-    public void rangeStartsBeforeTest() {
-        final Range former = Range.between(0, 5);
-        final Range latter = Range.between(1, 5);
-        assertTrue("former should starts before latter",
-                former.startsBefore(latter));
-        assertTrue("latter shouldn't start before latter",
-                !latter.startsBefore(former));
-
-        assertTrue("no overlap allowed",
-                !Range.between(0, 5).startsBefore(Range.between(0, 10)));
-    }
-
-    @Test
-    public void rangeStartsAfterTest() {
-        final Range former = Range.between(0, 5);
-        final Range latter = Range.between(5, 10);
-        assertTrue("latter should start after former",
-                latter.startsAfter(former));
-        assertTrue("former shouldn't start after latter",
-                !former.startsAfter(latter));
-
-        assertTrue("no overlap allowed",
-                !Range.between(5, 10).startsAfter(Range.between(0, 6)));
-    }
-
-    @Test
-    public void rangeEndsBeforeTest() {
-        final Range former = Range.between(0, 5);
-        final Range latter = Range.between(5, 10);
-        assertTrue("latter should end before former", former.endsBefore(latter));
-        assertTrue("former shouldn't end before latter",
-                !latter.endsBefore(former));
-
-        assertTrue("no overlap allowed",
-                !Range.between(5, 10).endsBefore(Range.between(9, 15)));
-    }
-
-    @Test
-    public void rangeEndsAfterTest() {
-        final Range former = Range.between(1, 5);
-        final Range latter = Range.between(1, 6);
-        assertTrue("latter should end after former", latter.endsAfter(former));
-        assertTrue("former shouldn't end after latter",
-                !former.endsAfter(latter));
-
-        assertTrue("no overlap allowed",
-                !Range.between(0, 10).endsAfter(Range.between(5, 10)));
-    }
-
-    @Test(expected = IllegalArgumentException.class)
-    public void combine_notOverlappingFirstSmaller() {
-        Range.between(0, 10).combineWith(Range.between(11, 20));
-    }
-
-    @Test(expected = IllegalArgumentException.class)
-    public void combine_notOverlappingSecondLarger() {
-        Range.between(11, 20).combineWith(Range.between(0, 10));
-    }
-
-    @Test(expected = IllegalArgumentException.class)
-    public void combine_firstEmptyNotOverlapping() {
-        Range.between(15, 15).combineWith(Range.between(0, 10));
-    }
-
-    @Test(expected = IllegalArgumentException.class)
-    public void combine_secondEmptyNotOverlapping() {
-        Range.between(0, 10).combineWith(Range.between(15, 15));
-    }
-
-    @Test
-    public void combine_barelyOverlapping() {
-        Range r1 = Range.between(0, 10);
-        Range r2 = Range.between(10, 20);
-
-        // Test both ways, should give the same result
-        Range combined1 = r1.combineWith(r2);
-        Range combined2 = r2.combineWith(r1);
-        assertEquals(combined1, combined2);
-
-        assertEquals(0, combined1.getStart());
-        assertEquals(20, combined1.getEnd());
-    }
-
-    @Test
-    public void combine_subRange() {
-        Range r1 = Range.between(0, 10);
-        Range r2 = Range.between(2, 8);
-
-        // Test both ways, should give the same result
-        Range combined1 = r1.combineWith(r2);
-        Range combined2 = r2.combineWith(r1);
-        assertEquals(combined1, combined2);
-
-        assertEquals(r1, combined1);
-    }
-
-    @Test
-    public void combine_intersecting() {
-        Range r1 = Range.between(0, 10);
-        Range r2 = Range.between(5, 15);
-
-        // Test both ways, should give the same result
-        Range combined1 = r1.combineWith(r2);
-        Range combined2 = r2.combineWith(r1);
-        assertEquals(combined1, combined2);
-
-        assertEquals(0, combined1.getStart());
-        assertEquals(15, combined1.getEnd());
-
-    }
-
-    @Test
-    public void combine_emptyInside() {
-        Range r1 = Range.between(0, 10);
-        Range r2 = Range.between(5, 5);
-
-        // Test both ways, should give the same result
-        Range combined1 = r1.combineWith(r2);
-        Range combined2 = r2.combineWith(r1);
-        assertEquals(combined1, combined2);
-
-        assertEquals(r1, combined1);
-    }
-
-}