diff --git a/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/coordinate/PositionUtilTest.java b/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/coordinate/PositionUtilTest.java
index 76011cd..0f34858 100644
--- a/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/coordinate/PositionUtilTest.java
+++ b/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/coordinate/PositionUtilTest.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2012, 2018 Original authors and others.
+ * Copyright (c) 2012, 2019 Original authors and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
@@ -11,6 +11,7 @@
 package org.eclipse.nebula.widgets.nattable.coordinate;
 
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertTrue;
 
 import java.util.ArrayList;
@@ -102,4 +103,45 @@
         }
     }
 
+    @Test
+    public void shouldJoinContiguousRanges() {
+        Range r1 = new Range(2, 5);
+        Range r2 = new Range(5, 9);
+        Range r3 = new Range(9, 12);
+
+        assertEquals(new Range(2, 12), PositionUtil.joinConsecutiveRanges(Arrays.asList(r1, r2, r3)));
+    }
+
+    @Test
+    public void shouldNotJoinNotContiguousRanges() {
+        Range r1 = new Range(2, 5);
+        Range r2 = new Range(6, 9);
+        Range r3 = new Range(10, 12);
+
+        assertNull(PositionUtil.joinConsecutiveRanges(Arrays.asList(r1, r2, r3)));
+    }
+
+    @Test
+    public void shouldMergeContiguousRangesToOne() {
+        Range r1 = new Range(2, 5);
+        Range r2 = new Range(4, 9);
+        Range r3 = new Range(7, 12);
+
+        List<Range> mergedRanges = PositionUtil.mergeRanges(Arrays.asList(r1, r2, r3));
+        assertEquals(1, mergedRanges.size());
+        assertEquals(new Range(2, 12), mergedRanges.get(0));
+    }
+
+    @Test
+    public void shouldMergeNotContiguousRanges() {
+        Range r1 = new Range(2, 5);
+        Range r2 = new Range(4, 9);
+        Range r3 = new Range(10, 12);
+        Range r4 = new Range(12, 15);
+
+        List<Range> mergedRanges = PositionUtil.mergeRanges(Arrays.asList(r1, r2, r3, r4));
+        assertEquals(2, mergedRanges.size());
+        assertEquals(new Range(2, 9), mergedRanges.get(0));
+        assertEquals(new Range(10, 15), mergedRanges.get(1));
+    }
 }
diff --git a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/coordinate/PositionUtil.java b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/coordinate/PositionUtil.java
index fbf4313..731de16 100644
--- a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/coordinate/PositionUtil.java
+++ b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/coordinate/PositionUtil.java
@@ -16,9 +16,11 @@
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
+import java.util.Comparator;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
+import java.util.TreeSet;
 
 import org.eclipse.nebula.widgets.nattable.selection.SelectionLayer.MoveDirectionEnum;
 
@@ -170,6 +172,73 @@
     }
 
     /**
+     * Join a set of ranges if they describe a consecutive range when combined.
+     *
+     * @param ranges
+     *            Collection of {@link Range}s that should be joined.
+     * @return The joined {@link Range} or <code>null</code> if {@link Range}s
+     *         do not describe a consecutive {@link Range} when combined.
+     *
+     * @since 1.6
+     */
+    public static Range joinConsecutiveRanges(Collection<Range> ranges) {
+        if (ranges == null || ranges.isEmpty()) {
+            return null;
+        }
+
+        // put to list
+        List<Range> sortedRanges = new ArrayList<Range>(ranges);
+
+        // sort by 1) start, 2) end position
+        Collections.sort(sortedRanges, new Comparator<Range>() {
+
+            @Override
+            public int compare(Range o1, Range o2) {
+                if (o1.start == o2.start) {
+                    return Integer.compare(o1.end, o2.end);
+                } else {
+                    return Integer.compare(o1.start, o2.start);
+                }
+            }
+        });
+
+        int start = sortedRanges.get(0).start;
+        int end = sortedRanges.get(0).end;
+        for (int i = 1; i < sortedRanges.size(); i++) {
+            Range range = sortedRanges.get(i);
+            if (range.start > end) {
+                return null;
+            }
+            end = Integer.max(end, range.end);
+        }
+
+        return new Range(start, end);
+    }
+
+    /**
+     * Takes a collection of {@link Range}s and merges them to get
+     * {@link Range}s without overlapping. If there are no gaps between the
+     * {@link Range}s a single Range will be the result, otherwise multiple
+     * {@link Range}s will be in the resulting collection.
+     *
+     * @param ranges
+     *            The {@link Range}s to merge.
+     * @return Collection of {@link Range}s without overlapping.
+     *
+     * @since 1.6
+     */
+    public static List<Range> mergeRanges(Collection<Range> ranges) {
+        Set<Integer> numbers = new TreeSet<Integer>();
+        for (Range range : ranges) {
+            for (int number = range.start; number < range.end; number++) {
+                numbers.add(number);
+            }
+        }
+
+        return getRanges(numbers);
+    }
+
+    /**
      * Calculates the horizontal move direction based on the from and to column
      * position.
      *
diff --git a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/selection/SelectionUtils.java b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/selection/SelectionUtils.java
index db0a43e..b6f9c27 100644
--- a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/selection/SelectionUtils.java
+++ b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/selection/SelectionUtils.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2012, 2018 Original authors and others.
+ * Copyright (c) 2012, 2019 Original authors and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
@@ -13,13 +13,10 @@
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
-import java.util.HashMap;
-import java.util.LinkedHashSet;
 import java.util.List;
-import java.util.Map;
 import java.util.Set;
 
-import org.eclipse.nebula.widgets.nattable.coordinate.PositionCoordinate;
+import org.eclipse.nebula.widgets.nattable.coordinate.PositionUtil;
 import org.eclipse.nebula.widgets.nattable.coordinate.Range;
 import org.eclipse.nebula.widgets.nattable.data.IRowDataProvider;
 import org.eclipse.nebula.widgets.nattable.layer.cell.ILayerCell;
@@ -110,50 +107,35 @@
      * @since 1.4
      */
     public static boolean hasConsecutiveSelection(SelectionLayer selectionLayer) {
-        if (selectionLayer != null
-                && SelectionUtils.isConsecutive(selectionLayer.getSelectedColumnPositions())) {
+        if (selectionLayer == null) {
+            return false;
+        }
 
-            Map<Integer, Set<Integer>> positions = new HashMap<Integer, Set<Integer>>();
-            int column = -1;
-            int row = -1;
+        int[] selectedColumnPositions = selectionLayer.getSelectedColumnPositions();
+        if (selectedColumnPositions.length == 0) {
+            return false;
+        }
 
-            // collect the selection information
-            for (PositionCoordinate coord : selectionLayer.getSelectedCellPositions()) {
-                Set<Integer> rows = positions.get(coord.columnPosition);
-                if (rows == null) {
-                    rows = new LinkedHashSet<Integer>();
-                    positions.put(coord.columnPosition, rows);
-                }
-                rows.add(coord.rowPosition);
+        Arrays.sort(selectedColumnPositions);
 
-                column = Math.max(column, coord.columnPosition);
-                row = Math.max(row, coord.rowPosition);
+        Set<Range> selectedRowPositions = selectionLayer.getSelectedRowPositions();
+        Range range = PositionUtil.joinConsecutiveRanges(selectedRowPositions);
+        if (range == null) {
+            return false;
+        }
+
+        for (int colPosIdx = 0; colPosIdx < selectedColumnPositions.length; colPosIdx++) {
+            if (colPosIdx > 0 && selectedColumnPositions[colPosIdx - 1] + 1 != selectedColumnPositions[colPosIdx]) {
+                return false;
             }
-
-            // check if the selected region is a rectangle
-            // every row collection for each column needs to have the same size
-            // and the same content
-            Set<Integer> previous = null;
-            for (Set<Integer> rows : positions.values()) {
-                if (previous != null && !previous.equals(rows)) {
+            final int columnPosition = selectedColumnPositions[colPosIdx];
+            for (int rowPositionIndex = range.start; rowPositionIndex < range.end; rowPositionIndex++) {
+                if (!selectionLayer.isCellPositionSelected(columnPosition, rowPositionIndex)) {
                     return false;
                 }
-                previous = rows;
-            }
-
-            // test if rows are consecutive
-            if (previous != null) {
-                int[] rowPositions = new int[previous.size()];
-                int i = 0;
-                for (Integer rowPos : previous) {
-                    rowPositions[i++] = rowPos;
-                }
-                if (SelectionUtils.isConsecutive(rowPositions)) {
-                    return true;
-                }
             }
         }
-        return false;
+        return true;
     }
 
     /**
@@ -170,16 +152,34 @@
      * @since 1.4
      */
     public static ILayerCell getBottomRightCellInSelection(SelectionLayer selectionLayer) {
-        if (hasConsecutiveSelection(selectionLayer)) {
-            int column = -1;
-            int row = -1;
-            for (PositionCoordinate coord : selectionLayer.getSelectedCellPositions()) {
-                column = Math.max(column, coord.columnPosition);
-                row = Math.max(row, coord.rowPosition);
-            }
-            return selectionLayer.getCellByPosition(column, row);
+        if (selectionLayer == null) {
+            return null;
         }
-        return null;
+
+        int[] selectedColumnPositions = selectionLayer.getSelectedColumnPositions();
+        Arrays.sort(selectedColumnPositions);
+
+        Set<Range> selectedRowPositions = selectionLayer.getSelectedRowPositions();
+        Range range = PositionUtil.joinConsecutiveRanges(selectedRowPositions);
+        if (range == null) {
+            return null;
+        }
+
+        for (int colPosIdx = 0; colPosIdx < selectedColumnPositions.length; colPosIdx++) {
+            if (colPosIdx > 0 && selectedColumnPositions[colPosIdx - 1] + 1 != selectedColumnPositions[colPosIdx]) {
+                return null;
+            }
+            final int columnPosition = selectedColumnPositions[colPosIdx];
+            for (int rowPositionIndex = range.start; rowPositionIndex < range.end; rowPositionIndex++) {
+                if (!selectionLayer.isCellPositionSelected(columnPosition, rowPositionIndex)) {
+                    return null;
+                }
+            }
+        }
+
+        int colPosition = selectedColumnPositions[selectedColumnPositions.length - 1];
+        int rowPosition = range.end - 1;
+        return selectionLayer.getCellByPosition(colPosition, rowPosition);
     }
 
     /**