diff --git a/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/copy/command/CopyDataCommandHandlerTest.java b/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/copy/command/CopyDataCommandHandlerTest.java
index 2bf5738..62d129c 100644
--- a/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/copy/command/CopyDataCommandHandlerTest.java
+++ b/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/copy/command/CopyDataCommandHandlerTest.java
@@ -18,7 +18,18 @@
 import java.util.Iterator;
 import java.util.Set;
 
+import org.junit.Before;
+import org.junit.Ignore;
+import org.junit.Test;
+
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.graphics.Rectangle;
+import org.eclipse.swt.widgets.Display;
+import org.eclipse.swt.widgets.Shell;
+
+import org.eclipse.nebula.widgets.nattable.coordinate.IValueIterator;
 import org.eclipse.nebula.widgets.nattable.coordinate.Range;
+import org.eclipse.nebula.widgets.nattable.coordinate.RangeList;
 import org.eclipse.nebula.widgets.nattable.data.IDataProvider;
 import org.eclipse.nebula.widgets.nattable.grid.command.ClientAreaResizeCommand;
 import org.eclipse.nebula.widgets.nattable.grid.layer.ColumnHeaderLayer;
@@ -30,13 +41,7 @@
 import org.eclipse.nebula.widgets.nattable.selection.command.SelectColumnCommand;
 import org.eclipse.nebula.widgets.nattable.test.fixture.data.DataProviderFixture;
 import org.eclipse.nebula.widgets.nattable.util.IClientAreaProvider;
-import org.eclipse.swt.SWT;
-import org.eclipse.swt.graphics.Rectangle;
-import org.eclipse.swt.widgets.Display;
-import org.eclipse.swt.widgets.Shell;
-import org.junit.Before;
-import org.junit.Ignore;
-import org.junit.Test;
+
 
 public class CopyDataCommandHandlerTest {
 
@@ -112,13 +117,14 @@
 		selectionLayer.doCommand(new SelectCellCommand(selectionLayer, 9, 9, false, true));
 		selectionLayer.doCommand(new SelectCellCommand(selectionLayer, 1, 0, false, true));
 
-		ILayerCell[][] columns = commandHandler.assembleColumnHeaders();
+		RangeList selectedColumns = selectionLayer.getSelectedColumnPositions();
+		ILayerCell[] columns = commandHandler.assembleColumnHeader(selectedColumns, 1, 0);
 
 		assertEquals(5, columns.length);
-		assertEquals("Column 2", columns[0][1].getDataValue());
-		assertEquals("Column 3", columns[0][2].getDataValue());
-		assertEquals("Column 5", columns[0][3].getDataValue());
-		assertEquals("Column 10", columns[0][4].getDataValue());
+		assertEquals("Column 2", columns[1].getDataValue());
+		assertEquals("Column 3", columns[2].getDataValue());
+		assertEquals("Column 5", columns[3].getDataValue());
+		assertEquals("Column 10", columns[4].getDataValue());
 	}
 
 	@Test
@@ -131,12 +137,13 @@
 		selectionLayer.doCommand(new SelectCellCommand(selectionLayer, 9, 9, false, true));
 		selectionLayer.doCommand(new SelectColumnCommand(selectionLayer, 5, 0, false, true));
 
-		ILayerCell[] bodyCells = commandHandler.assembleBody(0);
+		RangeList selectedColumns = selectionLayer.getSelectedColumnPositions();
+		ILayerCell[] bodyCells = commandHandler.assembleBody(selectedColumns, 1, 0);
 		assertEquals(8, bodyCells.length);
 		assertEquals("[5,0]", bodyCells[4].getDataValue());
 		assertEquals("[8,0]", bodyCells[6].getDataValue());
 
-		bodyCells = commandHandler.assembleBody(9);
+		bodyCells = commandHandler.assembleBody(selectedColumns, 1, 9);
 		assertEquals("[9,9]", bodyCells[7].getDataValue());
 	}
 
@@ -199,18 +206,20 @@
 		// First cell should be blank, this is the corner
 		assertNull(cells[0]);
 		// Should only have Column headers
-		int[] selectedColumns = gridLayer.getBodyLayer().getSelectionLayer().getSelectedColumnPositions();
+		final RangeList selectedColumns = selectionLayer.getSelectedColumnPositions();
+		
+		IValueIterator columnsIter = selectedColumns.values().iterator();
 		for (int columnPosition = 1; columnPosition < cells.length; columnPosition++) {
 			ILayerCell cell = cells[columnPosition];
 			// Remember to substract offset from columnPosition
-			assertEquals(columnHeaderLayer.getDataValueByPosition(selectedColumns[columnPosition - 1], 0), cell.getDataValue());
+			assertEquals(columnHeaderLayer.getDataValueByPosition(columnsIter.nextValue(), 0), cell.getDataValue());
 		}
 	}
 
 	private void checkBodyCells(ILayerCell[][] copiedGrid) {
 		int cellWithDataCounter = 0;
-		int[] selectedColumns = selectionLayer.getSelectedColumnPositions();
-		Set<Range> selectedRowRanges = selectionLayer.getSelectedRowPositions();
+		RangeList selectedColumns = selectionLayer.getSelectedColumnPositions();
+		RangeList selectedRowRanges = selectionLayer.getSelectedRowPositions();
 
 		Set<Integer> selectedRows = new HashSet<Integer>();
 		for (Range range : selectedRowRanges) {
@@ -219,6 +228,7 @@
 		Iterator<Integer> rowsIterator = selectedRows.iterator();
 
 		// Row zero is for column headers
+		IValueIterator columnsIter = selectedColumns.values().iterator();
 		for (int rowPosition = 1; rowPosition < copiedGrid.length; rowPosition ++) {
 			ILayerCell[] cells = copiedGrid[rowPosition];
 
@@ -231,11 +241,11 @@
 				final ILayerCell cell = cells[columnPosition];
 				if (cell != null) {
 					cellWithDataCounter++;
-					assertEquals(selectionLayer.getDataValueByPosition(selectedColumns[columnPosition - 1], selectedRowPosition), cell
+					assertEquals(selectionLayer.getDataValueByPosition(columnsIter.nextValue(), selectedRowPosition), cell
 							.getDataValue());
 				}
 			}
 		}
-		assertEquals(selectionLayer.getSelectedCellPositions().length, cellWithDataCounter);
+		assertEquals(selectionLayer.getSelectedCellPositions().size(), cellWithDataCounter);
 	}
 }
diff --git a/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/resize/AutoResizeColumnsTest.java b/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/resize/AutoResizeColumnsTest.java
index e5e8427..98f30e8 100644
--- a/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/resize/AutoResizeColumnsTest.java
+++ b/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/resize/AutoResizeColumnsTest.java
@@ -13,6 +13,18 @@
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
 
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.graphics.Font;
+import org.eclipse.swt.graphics.FontData;
+import org.eclipse.swt.graphics.Image;
+import org.eclipse.swt.graphics.Rectangle;
+import org.eclipse.swt.widgets.Display;
+import org.eclipse.swt.widgets.Shell;
+
 import org.eclipse.nebula.widgets.nattable.config.CellConfigAttributes;
 import org.eclipse.nebula.widgets.nattable.config.ConfigRegistry;
 import org.eclipse.nebula.widgets.nattable.config.DefaultNatTableStyleConfiguration;
@@ -35,16 +47,7 @@
 import org.eclipse.nebula.widgets.nattable.util.GCFactory;
 import org.eclipse.nebula.widgets.nattable.util.GUIHelper;
 import org.eclipse.nebula.widgets.nattable.util.IClientAreaProvider;
-import org.eclipse.swt.SWT;
-import org.eclipse.swt.graphics.Font;
-import org.eclipse.swt.graphics.FontData;
-import org.eclipse.swt.graphics.Image;
-import org.eclipse.swt.graphics.Rectangle;
-import org.eclipse.swt.widgets.Display;
-import org.eclipse.swt.widgets.Shell;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
+
 
 public class AutoResizeColumnsTest {
 
@@ -135,7 +138,7 @@
 		SelectionLayer selectionLayer = ((DefaultBodyLayerStack) gridLayer.getBodyLayer()).getSelectionLayer();
 		selectionLayer.doCommand(new SelectColumnCommand(selectionLayer, 0, 0, false, false));
 		selectionLayer.doCommand(new SelectColumnCommand(selectionLayer, 1, 0, true, false));
-		assertEquals(2, selectionLayer.getFullySelectedColumnPositions().length);
+		assertEquals(2, selectionLayer.getFullySelectedColumnPositions().values().size());
 
 		// Resize grid column 5
 		gridLayer.doCommand(new ColumnResizeCommand(gridLayer, 5, 10));
diff --git a/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/search/strategy/ColumnSearchStrategyTest.java b/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/search/strategy/ColumnSearchStrategyTest.java
index 571ecfd..dfeef65 100644
--- a/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/search/strategy/ColumnSearchStrategyTest.java
+++ b/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/search/strategy/ColumnSearchStrategyTest.java
@@ -10,6 +10,11 @@
  ******************************************************************************/
 package org.eclipse.nebula.widgets.nattable.search.strategy;
 
+import java.util.List;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
 
 import org.eclipse.nebula.widgets.nattable.config.CellConfigAttributes;
 import org.eclipse.nebula.widgets.nattable.config.ConfigRegistry;
@@ -18,11 +23,8 @@
 import org.eclipse.nebula.widgets.nattable.grid.layer.DefaultGridLayer;
 import org.eclipse.nebula.widgets.nattable.layer.ILayer;
 import org.eclipse.nebula.widgets.nattable.search.CellValueAsStringComparator;
-import org.eclipse.nebula.widgets.nattable.search.strategy.ColumnSearchStrategy;
 import org.eclipse.nebula.widgets.nattable.test.fixture.layer.GridLayerFixture;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
+
 
 public class ColumnSearchStrategyTest {
 
@@ -42,16 +44,16 @@
 		// Choose three columns for searching
 		ColumnSearchStrategy columnSearchStrategy = new ColumnSearchStrategy(new int[]{2,5,8}, configRegistry);
 		columnSearchStrategy.setComparator(new CellValueAsStringComparator<Comparable<String>>());
-		PositionCoordinate[] cellsToSearch = columnSearchStrategy.getColumnCellsToSearch(layer);
+		List<PositionCoordinate> cellsToSearch = columnSearchStrategy.getColumnCellsToSearch(layer);
 
-		PositionCoordinate cell = cellsToSearch[0];
+		PositionCoordinate cell = cellsToSearch.get(0);
 		Assert.assertEquals(2, cell.columnPosition);
-		cell = cellsToSearch[5];
+		cell = cellsToSearch.get(5);
 		Assert.assertEquals(5, cell.columnPosition);
-		cell = cellsToSearch[10];
+		cell = cellsToSearch.get(10);
 		Assert.assertEquals(8, cell.columnPosition);
 
-		Assert.assertEquals(15, cellsToSearch.length);
+		Assert.assertEquals(15, cellsToSearch.size());
 	}
 
 	@Test
diff --git a/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/search/strategy/RowSearchStrategyTest.java b/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/search/strategy/RowSearchStrategyTest.java
index 88c35b5..1871ec8 100644
--- a/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/search/strategy/RowSearchStrategyTest.java
+++ b/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/search/strategy/RowSearchStrategyTest.java
@@ -10,6 +10,11 @@
  ******************************************************************************/
 package org.eclipse.nebula.widgets.nattable.search.strategy;
 
+import java.util.List;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
 
 import org.eclipse.nebula.widgets.nattable.config.ConfigRegistry;
 import org.eclipse.nebula.widgets.nattable.config.DefaultNatTableStyleConfiguration;
@@ -17,11 +22,8 @@
 import org.eclipse.nebula.widgets.nattable.grid.layer.DefaultGridLayer;
 import org.eclipse.nebula.widgets.nattable.layer.ILayer;
 import org.eclipse.nebula.widgets.nattable.search.CellValueAsStringComparator;
-import org.eclipse.nebula.widgets.nattable.search.strategy.RowSearchStrategy;
 import org.eclipse.nebula.widgets.nattable.test.fixture.layer.GridLayerFixture;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
+
 
 public class RowSearchStrategyTest {
 	
@@ -41,14 +43,14 @@
 	public void shouldAccessCellInSelectedRow() {
 		// Select three rows for searching
 		RowSearchStrategy rowStrategy = new RowSearchStrategy(new int[]{0,2,4}, configRegistry);
-		PositionCoordinate[] cellsToSearch = rowStrategy.getRowCellsToSearch(layer);
-		PositionCoordinate cell = cellsToSearch[0];
+		List<PositionCoordinate> cellsToSearch = rowStrategy.getRowCellsToSearch(layer);
+		PositionCoordinate cell = cellsToSearch.get(0);
 		Assert.assertEquals(0, cell.getRowPosition());
-		cell = cellsToSearch[10];
+		cell = cellsToSearch.get(10);
 		Assert.assertEquals(2, cell.getRowPosition());
-		cell = cellsToSearch[20];
+		cell = cellsToSearch.get(20);
 		Assert.assertEquals(4, cell.getRowPosition());
-		Assert.assertEquals(30, cellsToSearch.length);
+		Assert.assertEquals(30, cellsToSearch.size());
 	}
 	@Test
 	public void shouldSearchAllBodyCellsForRowInSelection() {
diff --git a/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/search/strategy/SelectionSearchStrategyTest.java b/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/search/strategy/SelectionSearchStrategyTest.java
index 90b1c94..f017dea 100644
--- a/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/search/strategy/SelectionSearchStrategyTest.java
+++ b/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/search/strategy/SelectionSearchStrategyTest.java
@@ -10,6 +10,16 @@
  ******************************************************************************/
 package org.eclipse.nebula.widgets.nattable.search.strategy;
 
+import java.util.List;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.graphics.Rectangle;
+import org.eclipse.swt.widgets.Display;
+import org.eclipse.swt.widgets.Shell;
 
 import org.eclipse.nebula.widgets.nattable.config.ConfigRegistry;
 import org.eclipse.nebula.widgets.nattable.config.DefaultNatTableStyleConfiguration;
@@ -19,19 +29,12 @@
 import org.eclipse.nebula.widgets.nattable.grid.layer.DefaultGridLayer;
 import org.eclipse.nebula.widgets.nattable.search.CellValueAsStringComparator;
 import org.eclipse.nebula.widgets.nattable.search.ISearchDirection;
-import org.eclipse.nebula.widgets.nattable.search.strategy.SelectionSearchStrategy;
 import org.eclipse.nebula.widgets.nattable.selection.SelectionLayer;
 import org.eclipse.nebula.widgets.nattable.selection.command.SelectAllCommand;
 import org.eclipse.nebula.widgets.nattable.selection.command.SelectCellCommand;
 import org.eclipse.nebula.widgets.nattable.test.fixture.layer.GridLayerFixture;
 import org.eclipse.nebula.widgets.nattable.util.IClientAreaProvider;
-import org.eclipse.swt.SWT;
-import org.eclipse.swt.graphics.Rectangle;
-import org.eclipse.swt.widgets.Display;
-import org.eclipse.swt.widgets.Shell;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
+
 
 public class SelectionSearchStrategyTest {
 
@@ -98,8 +101,8 @@
 		
 		// We should get 20 Cells from the body		
 		SelectionSearchStrategy selectionStrategy = new SelectionSearchStrategy(configRegistry);
-		PositionCoordinate[] cellsToSearch = selectionStrategy.getSelectedCells(gridLayer.getBodyLayer().getSelectionLayer());
-		Assert.assertEquals(20, cellsToSearch.length);
+		List<PositionCoordinate> cellsToSearch = selectionStrategy.getSelectedCells(gridLayer.getBodyLayer().getSelectionLayer());
+		Assert.assertEquals(20, cellsToSearch.size());
 	}
 
 	@Test
@@ -110,7 +113,7 @@
 		gridLayer.doCommand(new SelectCellCommand(gridLayer, 5, 4, false, true));
 		gridLayer.doCommand(new SelectCellCommand(gridLayer, 6, 2, false, true));
 		
-		Assert.assertEquals(5, gridLayer.getBodyLayer().getSelectionLayer().getSelectedCellPositions().length);
+		Assert.assertEquals(5, gridLayer.getBodyLayer().getSelectionLayer().getSelectedCellPositions().size());
 		
 		final SelectionLayer selectionLayer = gridLayer.getBodyLayer().getSelectionLayer();
 		SelectionSearchStrategy selectionStrategy = new SelectionSearchStrategy(configRegistry);
diff --git a/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/selection/CellSelectionTest.java b/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/selection/CellSelectionTest.java
index 6c9c781..6f49755 100644
--- a/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/selection/CellSelectionTest.java
+++ b/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/selection/CellSelectionTest.java
@@ -14,16 +14,18 @@
 import static org.junit.Assert.assertEquals;
 
 import java.util.Collection;
+import java.util.List;
+
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
 
 import org.eclipse.nebula.widgets.nattable.coordinate.PositionCoordinate;
 import org.eclipse.nebula.widgets.nattable.selection.SelectionLayer.MoveDirectionEnum;
 import org.eclipse.nebula.widgets.nattable.selection.command.SelectCellCommand;
 import org.eclipse.nebula.widgets.nattable.test.fixture.layer.DataLayerFixture;
-import org.eclipse.nebula.widgets.nattable.util.ArrayUtil;
-import org.junit.After;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
+
 
 public class CellSelectionTest {
 
@@ -58,12 +60,13 @@
 
 	private boolean wasPreviousSelectionCleared() {
 		// Make sure previous selection was cleared
-		return (selectionLayer.getSelectedColumnPositions().length == 1 && selectionLayer.getSelectedRowCount() == 1);
+		return (selectionLayer.getSelectedColumnPositions().values().size() == 1
+				&& selectionLayer.getSelectedRowCount() == 1);
 	}
 
 	private boolean wasPreviousColumnSelectionAppended() {
 		// Make sure previous column selection was not cleared
-		return selectionLayer.getSelectedColumnPositions().length > 1;
+		return selectionLayer.getSelectedColumnPositions().values().size() > 1;
 	}
 
 	private boolean wasPreviousRowSelectionAppended() {
@@ -377,20 +380,20 @@
 		selectionLayer.doCommand(new SelectCellCommand(selectionLayer, 1, 0, false, true));
 		selectionLayer.doCommand(new SelectCellCommand(selectionLayer, 9, 9, false, true));
 
-		PositionCoordinate[] cells = selectionLayer.getSelectedCellPositions();
-		Assert.assertEquals(4, cells.length);
+		List<PositionCoordinate> cells = selectionLayer.getSelectedCellPositions();
+		Assert.assertEquals(4, cells.size());
 		// (1, 0)
-		Assert.assertEquals(1, cells[0].columnPosition);
-		Assert.assertEquals(0, cells[0].rowPosition);
+		Assert.assertEquals(1, cells.get(0).columnPosition);
+		Assert.assertEquals(0, cells.get(0).rowPosition);
 		// (2, 3)
-		Assert.assertEquals(2, cells[1].columnPosition);
-		Assert.assertEquals(3, cells[1].rowPosition);
+		Assert.assertEquals(2, cells.get(1).columnPosition);
+		Assert.assertEquals(3, cells.get(1).rowPosition);
 		// (4, 1)
-		Assert.assertEquals(4, cells[2].columnPosition);
-		Assert.assertEquals(1, cells[2].rowPosition);
+		Assert.assertEquals(4, cells.get(2).columnPosition);
+		Assert.assertEquals(1, cells.get(2).rowPosition);
 		// (9, 9)
-		Assert.assertEquals(9, cells[3].columnPosition);
-		Assert.assertEquals(9, cells[3].rowPosition);
+		Assert.assertEquals(9, cells.get(3).columnPosition);
+		Assert.assertEquals(9, cells.get(3).rowPosition);
 	}
 
 	@Test
@@ -403,7 +406,7 @@
 		selectionLayer.doCommand(new SelectCellCommand(selectionLayer, 1, 2, false, true));
 		selectionLayer.doCommand(new SelectCellCommand(selectionLayer, 2, 2, false, true));
 
-		Collection<PositionCoordinate> cells = ArrayUtil.asCollection(selectionLayer.getSelectedCellPositions());
+		Collection<PositionCoordinate> cells = selectionLayer.getSelectedCellPositions();
 
 		Assert.assertEquals(6, cells.size());
 		// (1, 0)
@@ -427,14 +430,14 @@
 		selectionLayer.clear();
 		selectionLayer.doCommand(new SelectCellCommand(selectionLayer, 1, 0, false, true));
 
-		Collection<PositionCoordinate> cells = ArrayUtil.asCollection(selectionLayer.getSelectedCellPositions());
+		Collection<PositionCoordinate> cells = selectionLayer.getSelectedCellPositions();
 		Assert.assertEquals(1, cells.size());
 		Assert.assertTrue(cells.contains(new PositionCoordinate(selectionLayer, 1, 0)));
 
 		//select another cell with control mask
 		selectionLayer.doCommand(new SelectCellCommand(selectionLayer, 2, 0, false, true));
 
-		cells = ArrayUtil.asCollection(selectionLayer.getSelectedCellPositions());
+		cells = selectionLayer.getSelectedCellPositions();
 		Assert.assertEquals(1, cells.size());
 		Assert.assertTrue(cells.contains(new PositionCoordinate(selectionLayer, 2, 0)));
 
@@ -442,7 +445,7 @@
 		//only the first cell should be selected afterwards
 		selectionLayer.doCommand(new SelectCellCommand(selectionLayer, 2, 10, true, false));
 
-		cells = ArrayUtil.asCollection(selectionLayer.getSelectedCellPositions());
+		cells = selectionLayer.getSelectedCellPositions();
 		Assert.assertEquals(1, cells.size());
 		Assert.assertTrue(cells.contains(new PositionCoordinate(selectionLayer, 2, 0)));
 
@@ -450,7 +453,7 @@
 		//only the first cell should be selected afterwards
 		selectionLayer.doCommand(new SelectCellCommand(selectionLayer, 10, 0, true, false));
 
-		cells = ArrayUtil.asCollection(selectionLayer.getSelectedCellPositions());
+		cells = selectionLayer.getSelectedCellPositions();
 		Assert.assertEquals(1, cells.size());
 		Assert.assertTrue(cells.contains(new PositionCoordinate(selectionLayer, 2, 0)));
 	}
diff --git a/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/selection/ColumnSelectionTest.java b/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/selection/ColumnSelectionTest.java
index 74622cf..35fbcbe 100644
--- a/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/selection/ColumnSelectionTest.java
+++ b/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/selection/ColumnSelectionTest.java
@@ -15,14 +15,17 @@
 
 import java.util.Collection;
 
-import org.eclipse.nebula.widgets.nattable.coordinate.PositionCoordinate;
-import org.eclipse.nebula.widgets.nattable.selection.command.SelectColumnCommand;
-import org.eclipse.nebula.widgets.nattable.test.fixture.layer.DataLayerFixture;
-import org.eclipse.nebula.widgets.nattable.util.ArrayUtil;
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
 
+import org.eclipse.nebula.widgets.nattable.coordinate.PositionCoordinate;
+import org.eclipse.nebula.widgets.nattable.coordinate.Range;
+import org.eclipse.nebula.widgets.nattable.coordinate.RangeList;
+import org.eclipse.nebula.widgets.nattable.selection.command.SelectColumnCommand;
+import org.eclipse.nebula.widgets.nattable.test.fixture.layer.DataLayerFixture;
+
+
 public class ColumnSelectionTest {
 	// Tests for column selection NTBL-225
 
@@ -152,29 +155,32 @@
 		selectionLayer.clear();
 		selectionLayer.doCommand(new SelectColumnCommand(selectionLayer, 1, 0, false, true));
 
-		Collection<PositionCoordinate> cells = ArrayUtil.asCollection(selectionLayer.getSelectedCellPositions());
+		Collection<PositionCoordinate> cells = selectionLayer.getSelectedCellPositions();
+		RangeList columns = selectionLayer.getSelectedColumnPositions();
 		assertEquals(1, cells.size());
-		assertEquals(1, selectionLayer.getSelectedColumnPositions().length);
-		assertEquals(1, selectionLayer.getSelectedColumnPositions()[0]);
+		assertEquals(1, columns.size());
+		assertEquals(new Range(1), columns.get(0));
 		assertEquals(1, selectionLayer.getSelectedRowCount());
 
 		//select another column with control mask
 		selectionLayer.doCommand(new SelectColumnCommand(selectionLayer, 2, 0, false, true));
 
-		cells = ArrayUtil.asCollection(selectionLayer.getSelectedCellPositions());
+		cells = selectionLayer.getSelectedCellPositions();
+		columns = selectionLayer.getSelectedColumnPositions();
 		assertEquals(1, cells.size());
-		assertEquals(1, selectionLayer.getSelectedColumnPositions().length);
-		assertEquals(2, selectionLayer.getSelectedColumnPositions()[0]);
+		assertEquals(1, columns.size());
+		assertEquals(new Range(2), columns.get(0));
 		assertEquals(1, selectionLayer.getSelectedRowCount());
 
 		//select additional columns with shift mask
 		//only the last column should be selected afterwards
 		selectionLayer.doCommand(new SelectColumnCommand(selectionLayer, 5, 0, true, false));
 
-		cells = ArrayUtil.asCollection(selectionLayer.getSelectedCellPositions());
+		cells = selectionLayer.getSelectedCellPositions();
+		columns = selectionLayer.getSelectedColumnPositions();
 		assertEquals(1, cells.size());
-		assertEquals(1, selectionLayer.getSelectedColumnPositions().length);
-		assertEquals(5, selectionLayer.getSelectedColumnPositions()[0]);
+		assertEquals(1, columns.size());
+		assertEquals(new Range(5), columns.get(0));
 		assertEquals(1, selectionLayer.getSelectedRowCount());
 	}
 
diff --git a/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/selection/RowSelectionTest.java b/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/selection/RowSelectionTest.java
index d720568..6a6a265 100644
--- a/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/selection/RowSelectionTest.java
+++ b/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/selection/RowSelectionTest.java
@@ -15,15 +15,17 @@
 
 import java.util.Collection;
 
-import org.eclipse.nebula.widgets.nattable.coordinate.PositionCoordinate;
-import org.eclipse.nebula.widgets.nattable.selection.command.SelectRowsCommand;
-import org.eclipse.nebula.widgets.nattable.test.fixture.layer.DataLayerFixture;
-import org.eclipse.nebula.widgets.nattable.util.ArrayUtil;
 import org.junit.After;
 import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Test;
 
+import org.eclipse.nebula.widgets.nattable.coordinate.PositionCoordinate;
+import org.eclipse.nebula.widgets.nattable.coordinate.RangeList;
+import org.eclipse.nebula.widgets.nattable.selection.command.SelectRowsCommand;
+import org.eclipse.nebula.widgets.nattable.test.fixture.layer.DataLayerFixture;
+
+
 public class RowSelectionTest {
 // Tests for column selection NTBL-225
 
@@ -56,7 +58,7 @@
 		Assert.assertEquals(2, selectionLayer.getLastSelectedCellPosition().getRowPosition());
 
 		// Cells in between should have been selected
-		Assert.assertEquals(columnCount, selectionLayer.getSelectedColumnPositions().length);
+		Assert.assertEquals(columnCount, selectionLayer.getSelectedColumnPositions().values().size());
 	}
 
 	@Test
@@ -151,8 +153,8 @@
 		Assert.assertEquals(1, lastColumnPosition);
 
 		// Cells in row should have been selected
-		final int[] selectedColumns = selectionLayer.getSelectedColumnPositions();
-		Assert.assertEquals(columnCount, selectedColumns.length);
+		final RangeList selectedColumns = selectionLayer.getSelectedColumnPositions();
+		Assert.assertEquals(columnCount, selectedColumns.values().size());
 		Assert.assertTrue(selectionLayer.isCellPositionSelected(4, 1));
 
 		// Test extending column selection to the right of previous column selection
@@ -176,7 +178,7 @@
 		selectionLayer.clear();
 		selectionLayer.doCommand(new SelectRowsCommand(selectionLayer, 1, 0, false, true));
 
-		Collection<PositionCoordinate> cells = ArrayUtil.asCollection(selectionLayer.getSelectedCellPositions());
+		Collection<PositionCoordinate> cells = selectionLayer.getSelectedCellPositions();
 		assertEquals(1, cells.size());
 		assertEquals(1, selectionLayer.getSelectedRowPositions().size());
 		assertEquals(1, selectionLayer.getSelectedRowCount());
@@ -184,7 +186,7 @@
 		//select another row with control mask
 		selectionLayer.doCommand(new SelectRowsCommand(selectionLayer, 1, 2, false, true));
 
-		cells = ArrayUtil.asCollection(selectionLayer.getSelectedCellPositions());
+		cells = selectionLayer.getSelectedCellPositions();
 		assertEquals(1, cells.size());
 		assertEquals(1, selectionLayer.getSelectedRowPositions().size());
 		assertEquals(1, selectionLayer.getSelectedRowCount());
@@ -192,7 +194,7 @@
 		//select additional rows with shift mask
 		selectionLayer.doCommand(new SelectRowsCommand(selectionLayer, 1, 5, true, false));
 
-		cells = ArrayUtil.asCollection(selectionLayer.getSelectedCellPositions());
+		cells = selectionLayer.getSelectedCellPositions();
 		assertEquals(1, cells.size());
 		assertEquals(1, selectionLayer.getSelectedRowPositions().size());
 		assertEquals(1, selectionLayer.getSelectedRowCount());
diff --git a/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/selection/SelectionModelTest.java b/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/selection/SelectionModelTest.java
index 1229bb7..fcffd26 100644
--- a/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/selection/SelectionModelTest.java
+++ b/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/selection/SelectionModelTest.java
@@ -8,27 +8,26 @@
  * Contributors:
  *     Original authors and others - initial API and implementation
  ******************************************************************************/
+
 package org.eclipse.nebula.widgets.nattable.selection;
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
 
-import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 
-
-import org.eclipse.nebula.widgets.nattable.coordinate.Range;
-import org.eclipse.nebula.widgets.nattable.selection.SelectionLayer;
-import org.eclipse.nebula.widgets.nattable.selection.SelectionModel;
-import org.eclipse.nebula.widgets.nattable.test.fixture.layer.DataLayerFixture;
-import org.eclipse.nebula.widgets.nattable.util.ObjectUtils;
-import org.eclipse.swt.graphics.Rectangle;
 import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Test;
 
+import org.eclipse.nebula.widgets.nattable.coordinate.Range;
+import org.eclipse.nebula.widgets.nattable.coordinate.RangeList;
+import org.eclipse.nebula.widgets.nattable.coordinate.Rectangle;
+import org.eclipse.nebula.widgets.nattable.test.fixture.layer.DataLayerFixture;
+import org.eclipse.nebula.widgets.nattable.util.ObjectUtils;
+
 
 public class SelectionModelTest {
 
@@ -54,38 +53,37 @@
 
 	@Test
 	public void isColumnFullySelected() throws Exception {
-		model.addSelection(new Rectangle(3, 0, 10, 10));
+		model.addSelection(new Rectangle(3, 0, 10, 100));
 
-		assertFalse(model.isColumnPositionFullySelected(3, 11));
-		assertTrue(model.isColumnPositionFullySelected(3, 10));
+		assertTrue(model.isColumnPositionFullySelected(3));
 
 		model.clearSelection(3, 1);
-		assertFalse(model.isColumnPositionFullySelected(3, 10));
+		assertFalse(model.isColumnPositionFullySelected(3));
 	}
 
 	@Test
 	public void isColumnFullySelectedForContiguousRectangles() throws Exception {
 		model.addSelection(new Rectangle(0, 0, 10, 10));
-		model.addSelection(new Rectangle(5, 10, 10, 10));
+		model.addSelection(new Rectangle(5, 10, 10, 90));
 
-		assertTrue(model.isColumnPositionFullySelected(5, 20));
+		assertTrue(model.isColumnPositionFullySelected(5));
 	}
 
 	@Test
 	public void isColumnFullySelectedForNonContiguousRectangles() throws Exception {
 		model.addSelection(new Rectangle(0, 0, 10, 10));
 		model.addSelection(new Rectangle(5, 5, 10, 8));
-		model.addSelection(new Rectangle(5, 15, 10, 5));
+		model.addSelection(new Rectangle(5, 15, 10, 90));
 
-		assertFalse(model.isColumnPositionFullySelected(5, 20));
+		assertFalse(model.isColumnPositionFullySelected(5));
 	}
 
 	@Test
 	public void isColumnFullySelectedForOverlapingRectangles() throws Exception {
 		model.addSelection(new Rectangle(0, 0, 10, 10));
-		model.addSelection(new Rectangle(5, 5, 10, 8));
+		model.addSelection(new Rectangle(5, 5, 10, 95));
 
-		assertTrue(model.isColumnPositionFullySelected(5, 13));
+		assertTrue(model.isColumnPositionFullySelected(5));
 	}
 
 	@Test
@@ -93,97 +91,101 @@
 		model.addSelection(new Rectangle(1, 5, 1, 1));
 		model.addSelection(new Rectangle(1, 10, 1, 1));
 
-		assertFalse(model.isColumnPositionFullySelected(1, 10));
+		assertFalse(model.isColumnPositionFullySelected(1));
 	}
 
 	@Test
 	public void isColumnFullySelectedWhenLastCellSelected() throws Exception {
 		model.addSelection(new Rectangle(1, 5, 1, 1));
 
-		assertFalse(model.isColumnPositionFullySelected(1, 6));
-		assertFalse(model.isColumnPositionFullySelected(1, 1000000));
+		assertFalse(model.isColumnPositionFullySelected(1));
 	}
 	
 	@Test
 	public void isRowFullySelected() throws Exception {
-		model.addSelection(new Rectangle(0,3,10,10));
-		assertTrue(model.isRowPositionFullySelected(3, 10));
+		model.addSelection(new Rectangle(0, 3, 100, 10));
+		
+		assertTrue(model.isRowPositionFullySelected(3));
 	}
 
 	@Test
 	public void isRowFullySelectedWhenMultipleRowsAndColumnsAreSelected() throws Exception {
 		//Rows 3, 6 fully selected
-		model.addSelection(new Rectangle(0,3,10,1));
-		model.addSelection(new Rectangle(0,6,10,1));
+		model.addSelection(new Rectangle(0, 3, 100, 1));
+		model.addSelection(new Rectangle(0, 6, 100, 1));
 		
 		//Column 2, 5 fully selected
-		model.addSelection(new Rectangle(2, 0,1,10));
-		model.addSelection(new Rectangle(5, 0,1,10));
+		model.addSelection(new Rectangle(2, 0, 1, 100));
+		model.addSelection(new Rectangle(5, 0, 1, 100));
 		
-		assertTrue(model.isRowPositionFullySelected(6, 10));
-		assertTrue(model.isRowPositionFullySelected(3, 10));
+		assertTrue(model.isRowPositionFullySelected(6));
+		assertTrue(model.isRowPositionFullySelected(3));
 		
 		// Remove Column 2
-		model.clearSelection(new Rectangle(2, 0,1,10));
-		assertFalse(model.isRowPositionFullySelected(6, 10));
-		assertFalse(model.isRowPositionFullySelected(3, 10));
+		model.clearSelection(new Rectangle(2, 0, 1, 100));
+		assertFalse(model.isRowPositionFullySelected(6));
+		assertFalse(model.isRowPositionFullySelected(3));
 		
 		//Add column 2 again
-		model.addSelection(new Rectangle(2, 0,1,10));
-		assertTrue(model.isRowPositionFullySelected(6, 10));
-		assertTrue(model.isRowPositionFullySelected(3, 10));
+		model.addSelection(new Rectangle(2, 0, 1, 100));
+		assertTrue(model.isRowPositionFullySelected(6));
+		assertTrue(model.isRowPositionFullySelected(3));
 	}
 
 	@Test
 	public void isRowNotFullySelected() throws Exception {
-		model.addSelection(new Rectangle(0,3,10,10));
+		model.addSelection(new Rectangle(0, 3, 10, 10));
 		
-		assertFalse(model.isRowPositionFullySelected(3, 11));
+		assertFalse(model.isRowPositionFullySelected(3));
 	}
 	
 	@Test
 	public void contains() throws Exception {
-		assertTrue(model.contains(new Rectangle(0, 0, 10, 10), new Rectangle(1, 1, 5, 5)));
-		assertTrue(model.contains(new Rectangle(0, 0, 10, 1), new Rectangle(5, 0, 1, 1)));
+		assertTrue(new Rectangle(0, 0, 10, 10).contains(new Rectangle(1, 1, 5, 5)));
+		assertTrue(new Rectangle(0, 0, 10, 1).contains(new Rectangle(5, 0, 1, 1)));
 		
-		assertFalse(model.contains(new Rectangle(0, 6, 0, 0), new Rectangle(2, 6, 1, 1)));
+		assertFalse(new Rectangle(0, 6, 0, 0).contains(new Rectangle(2, 6, 1, 1)));
 	}
 	
 	@Test
 	public void isMltipleCol() throws Exception {
-		model.addSelection(new Rectangle(1,0,1,20));
-		model.addSelection(new Rectangle(2,0,1,20));
-		model.addSelection(new Rectangle(3,0,1,20));
+		model.addSelection(new Rectangle(1, 0, 1, 100));
+		model.addSelection(new Rectangle(2, 0, 1, 100));
+		model.addSelection(new Rectangle(3, 0, 1, 100));
 		
-		assertFalse(model.isColumnPositionFullySelected(1, 21));
-		assertTrue(model.isColumnPositionFullySelected(2, 20));
+		assertTrue(model.isColumnPositionFullySelected(1));
+		assertTrue(model.isColumnPositionFullySelected(2));
+		assertFalse(model.isColumnPositionFullySelected(4));
 	}
 	
 	@Test
 	public void shouldReturnListOfFullySelectedColumns() throws Exception {
-		model.addSelection(new Rectangle(1,0,1,20));
-		model.addSelection(new Rectangle(2,10,1,4));
-		model.addSelection(new Rectangle(3,0,1,20));
+		RangeList fullySelectedColumns = model.getFullySelectedColumnPositions();
+		Assert.assertEquals(0, fullySelectedColumns.size());
 		
-		int[] fullySelectedColumns = model.getFullySelectedColumnPositions(20);
-		Assert.assertEquals(2, fullySelectedColumns.length);
-		Assert.assertEquals(1, fullySelectedColumns[0]);
-		Assert.assertEquals(3, fullySelectedColumns[1]);
+		model.addSelection(new Rectangle(1, 0, 1, 100));
+		model.addSelection(new Rectangle(2, 10, 1, 4));
+		model.addSelection(new Rectangle(3, 0, 1, 100));
+		
+		fullySelectedColumns = model.getFullySelectedColumnPositions();
+		Assert.assertEquals(2, fullySelectedColumns.size());
+		Assert.assertEquals(new Range(1), fullySelectedColumns.get(0));
+		Assert.assertEquals(new Range(3), fullySelectedColumns.get(1));
 	}
 	
 	@Test 
 	public void shouldReturnListOfFullySelectedRows() throws Exception {
-		int[] fullySelectedRows = model.getFullySelectedRowPositions(20);
-		Assert.assertEquals(0, fullySelectedRows.length);
+		RangeList fullySelectedRows = model.getFullySelectedRowPositions();
+		Assert.assertEquals(0, fullySelectedRows.size());
 
-		model.addSelection(new Rectangle(0,1,20,1));
-		model.addSelection(new Rectangle(3,2,4,1));
-		model.addSelection(new Rectangle(0,3,20,1));
+		model.addSelection(new Rectangle(0, 1, 100, 1));
+		model.addSelection(new Rectangle(3, 2, 4, 1));
+		model.addSelection(new Rectangle(0, 3, 100, 1));
 		
-		fullySelectedRows = model.getFullySelectedRowPositions(20);
-		Assert.assertEquals(2, fullySelectedRows.length);
-		Assert.assertEquals(1, fullySelectedRows[0]);
-		Assert.assertEquals(3, fullySelectedRows[1]);
+		fullySelectedRows = model.getFullySelectedRowPositions();
+		Assert.assertEquals(2, fullySelectedRows.size());
+		Assert.assertEquals(new Range(1), fullySelectedRows.get(0));
+		Assert.assertEquals(new Range(3), fullySelectedRows.get(1));
 	}
 	
 	@Test
@@ -587,11 +589,11 @@
 			model.addSelection(column, column % 3);
 		}
 		
-		int [] selectedColumns = model.getSelectedColumnPositions();
+		RangeList selectedColumns = model.getSelectedColumnPositions();
 		
 		Arrays.sort(columns);
 		
-		assertEquals(Arrays.toString(columns), Arrays.toString(selectedColumns));
+		assertEquals(Arrays.toString(columns), RangeList.listValues(selectedColumns).toString());
 	}
 	
 	@Test
@@ -715,19 +717,4 @@
 		removeRangeFromRange(col, row, numCols, numRows, removedRow, removedColumn, removedNumCols, removedNumRows);
 	}
 	
-	@Test
-	public void sortByY() throws Exception {
-		List<Rectangle> rectangles = new ArrayList<Rectangle>();
-		rectangles.add(new Rectangle(0, 3, 1, 1));
-		rectangles.add(new Rectangle(0, 5, 1, 1));
-		rectangles.add(new Rectangle(0, 1, 1, 1));
-		rectangles.add(new Rectangle(0, 13, 1, 1));
-
-		model.sortByY(rectangles);
-		
-		Assert.assertEquals(1, rectangles.get(0).y);
-		Assert.assertEquals(3, rectangles.get(1).y);
-		Assert.assertEquals(5, rectangles.get(2).y);
-		Assert.assertEquals(13, rectangles.get(3).y);
-	}
 }
diff --git a/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/style/editor/command/DisplayColumnStyleEditorCommandHandlerTest.java b/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/style/editor/command/DisplayColumnStyleEditorCommandHandlerTest.java
index 9a8ea55..2c33cc4 100644
--- a/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/style/editor/command/DisplayColumnStyleEditorCommandHandlerTest.java
+++ b/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/style/editor/command/DisplayColumnStyleEditorCommandHandlerTest.java
@@ -18,10 +18,15 @@
 import java.util.List;
 import java.util.Properties;
 
+import org.junit.Before;
+import org.junit.Test;
+
+import org.eclipse.swt.widgets.Shell;
 
 import org.eclipse.nebula.widgets.nattable.config.CellConfigAttributes;
 import org.eclipse.nebula.widgets.nattable.config.DefaultNatTableStyleConfiguration;
 import org.eclipse.nebula.widgets.nattable.config.IConfigRegistry;
+import org.eclipse.nebula.widgets.nattable.coordinate.RangeList;
 import org.eclipse.nebula.widgets.nattable.layer.cell.ColumnOverrideLabelAccumulator;
 import org.eclipse.nebula.widgets.nattable.layer.stack.DummyGridLayerStack;
 import org.eclipse.nebula.widgets.nattable.selection.SelectionLayer;
@@ -31,15 +36,11 @@
 import org.eclipse.nebula.widgets.nattable.style.Style;
 import org.eclipse.nebula.widgets.nattable.style.VerticalAlignmentEnum;
 import org.eclipse.nebula.widgets.nattable.style.editor.ColumnStyleEditorDialog;
-import org.eclipse.nebula.widgets.nattable.style.editor.command.DisplayColumnStyleEditorCommand;
-import org.eclipse.nebula.widgets.nattable.style.editor.command.DisplayColumnStyleEditorCommandHandler;
 import org.eclipse.nebula.widgets.nattable.test.fixture.CellStyleFixture;
 import org.eclipse.nebula.widgets.nattable.test.fixture.NatTableFixture;
 import org.eclipse.nebula.widgets.nattable.test.fixture.PropertiesFixture;
 import org.eclipse.nebula.widgets.nattable.test.fixture.layer.DataLayerFixture;
-import org.eclipse.swt.widgets.Shell;
-import org.junit.Before;
-import org.junit.Test;
+
 
 public class DisplayColumnStyleEditorCommandHandlerTest {
 
@@ -63,7 +64,7 @@
 	@Test
 	public void doCommand() throws Exception {
 		handlerUnderTest.dialog = new ColumnStyleEditorDialog(new Shell(), new CellStyleFixture());
-		handlerUnderTest.applySelectedStyleToColumns(commandFixture, new int[]{0});
+		handlerUnderTest.applySelectedStyleToColumns(commandFixture, new RangeList(0));
 
 		Style selectedStyle = (Style) configRegistryFixture.getConfigAttribute(CELL_STYLE, NORMAL, handlerUnderTest.getConfigLabel(0));
 
@@ -102,7 +103,7 @@
 	@Test
 	public void shouldRemoveLabelFromPersistenceIfStyleIsCleared() throws Exception {
 		handlerUnderTest.dialog = new ColumnStyleEditorDialog(new Shell(), null);
-		handlerUnderTest.applySelectedStyleToColumns(commandFixture, new int[]{0});
+		handlerUnderTest.applySelectedStyleToColumns(commandFixture, new RangeList(0));
 
 		Style selectedStyle = (Style) configRegistryFixture.getConfigAttribute(CELL_STYLE, NORMAL, handlerUnderTest.getConfigLabel(0));
 
diff --git a/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/test/integration/SelectionIntegrationTest.java b/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/test/integration/SelectionIntegrationTest.java
index 7694196..4b01756 100644
--- a/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/test/integration/SelectionIntegrationTest.java
+++ b/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/test/integration/SelectionIntegrationTest.java
@@ -12,16 +12,20 @@
 
 import static org.junit.Assert.assertEquals;
 
+import java.util.List;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+import org.eclipse.swt.SWT;
+
 import org.eclipse.nebula.widgets.nattable.coordinate.PositionCoordinate;
 import org.eclipse.nebula.widgets.nattable.grid.layer.DefaultGridLayer;
 import org.eclipse.nebula.widgets.nattable.layer.stack.DummyGridLayerStack;
 import org.eclipse.nebula.widgets.nattable.selection.SelectionLayer;
 import org.eclipse.nebula.widgets.nattable.selection.command.SelectCellCommand;
 import org.eclipse.nebula.widgets.nattable.test.fixture.NatTableFixture;
-import org.eclipse.swt.SWT;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
 
 /**
  * Integration test for all default selection behavior.
@@ -45,23 +49,28 @@
 
 	@Test
 	public void movingSelectionWithLeftArrow() throws Exception {
+		List<PositionCoordinate> selectedCells;
+		
 		natTable.doCommand(new SelectCellCommand(natTable, 5, 2, NO_SHIFT, NO_CTRL));
 
 		// Note: the co-ordinates from this point on are in selection later co-ordinates
 
 		SWTUtils.pressKey(SWT.ARROW_LEFT, natTable);
-		assertPositionEquals(3, 1, getSelectedCells()[0]);
+		selectedCells = selectionLayer.getSelectedCellPositions();
+		assertPositionEquals(3, 1, selectedCells.get(0));
 		assertSelectionAnchorEquals(3, 1);
 
 		SWTUtils.pressKey(SWT.ARROW_LEFT, SWT.SHIFT, natTable);
+		selectedCells = selectionLayer.getSelectedCellPositions();
 		assertSelectCellsCount(2);
-		assertPositionEquals(2, 1, getSelectedCells()[0]);
-		assertPositionEquals(3, 1, getSelectedCells()[1]);
+		assertPositionEquals(2, 1, selectedCells.get(0));
+		assertPositionEquals(3, 1, selectedCells.get(1));
 		assertSelectionAnchorEquals(3, 1);
 
 		SWTUtils.pressKey(SWT.ARROW_LEFT, SWT.MOD1, natTable);
+		selectedCells = selectionLayer.getSelectedCellPositions();
 		assertSelectCellsCount(1);
-		assertPositionEquals(0, 1, getSelectedCells()[0]);
+		assertPositionEquals(0, 1, selectedCells.get(0));
 		assertSelectionAnchorEquals(0, 1);
 	}
 
@@ -83,7 +92,7 @@
 
 		SWTUtils.pressKey(SWT.ARROW_RIGHT, SWT.MOD1, natTable);
 		assertSelectCellsCount(1);
-		assertPositionEquals(9, 1, selectionLayer.getSelectedCellPositions()[0]);
+		assertPositionEquals(9, 1, selectionLayer.getSelectedCellPositions().get(0));
 		assertPositionEquals(9, 1, selectionLayer.getLastSelectedCellPosition());
 		assertSelectionAnchorEquals(9, 1);
 	}
@@ -109,7 +118,7 @@
 		SWTUtils.pressKey(SWT.ARROW_DOWN, SWT.MOD1, natTable);
 		assertSelectCellsCount(1);
 		int lastRow = selectionLayer.getRowCount() - 1;
-		assertPositionEquals(4, lastRow, selectionLayer.getSelectedCellPositions()[0]);
+		assertPositionEquals(4, lastRow, selectionLayer.getSelectedCellPositions().get(0));
 		assertPositionEquals(4, lastRow, selectionLayer.getLastSelectedCellPosition());
 		assertSelectionAnchorEquals(4, lastRow);
 	}
@@ -121,7 +130,7 @@
 		// Note: the co-ordinates from this point on are in selection later co-ordinates
 
 		SWTUtils.pressKey(SWT.ARROW_UP, natTable);
-		assertPositionEquals(4, 2, selectionLayer.getSelectedCellPositions()[0]);
+		assertPositionEquals(4, 2, selectionLayer.getSelectedCellPositions().get(0));
 		assertSelectionAnchorEquals(4, 2);
 
 		SWTUtils.pressKey(SWT.ARROW_UP, SWT.SHIFT, natTable);
@@ -138,7 +147,7 @@
 		SWTUtils.pressKey(SWT.ARROW_UP, SWT.MOD1, natTable);
 		assertSelectCellsCount(1);
 		int lastRow = 0;
-		assertPositionEquals(4, lastRow, selectionLayer.getSelectedCellPositions()[0]);
+		assertPositionEquals(4, lastRow, selectionLayer.getSelectedCellPositions().get(0));
 		assertPositionEquals(4, lastRow, selectionLayer.getLastSelectedCellPosition());
 		assertSelectionAnchorEquals(4, lastRow);
 	}
@@ -178,7 +187,7 @@
 	// Convenience asserts
 
 	private void assertCellSelected(int column, int row){
-		PositionCoordinate[] selectedCells = selectionLayer.getSelectedCellPositions();
+		List<PositionCoordinate> selectedCells = selectionLayer.getSelectedCellPositions();
 		boolean selected  = false;
 
 		for (PositionCoordinate positionCoordinate : selectedCells) {
@@ -191,12 +200,8 @@
 		Assert.assertTrue(selected);
 	}
 
-	private PositionCoordinate[] getSelectedCells(){
-		return selectionLayer.getSelectedCellPositions();
-	}
-
 	private void assertSelectCellsCount(int count) {
-		assertEquals(count, selectionLayer.getSelectedCellPositions().length);
+		assertEquals(count, selectionLayer.getSelectedCellPositions().size());
 	}
 
 	private void assertSelectionAnchorEquals(int column, int row) {
diff --git a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/copy/command/CopyDataCommandHandler.java b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/copy/command/CopyDataCommandHandler.java
index 07d4f87..4bd968f 100644
--- a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/copy/command/CopyDataCommandHandler.java
+++ b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/copy/command/CopyDataCommandHandler.java
@@ -10,13 +10,9 @@
  ******************************************************************************/
 package org.eclipse.nebula.widgets.nattable.copy.command;
 
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-import java.util.Set;
-
 import org.eclipse.nebula.widgets.nattable.command.AbstractLayerCommandHandler;
-import org.eclipse.nebula.widgets.nattable.coordinate.Range;
+import org.eclipse.nebula.widgets.nattable.coordinate.IValueIterator;
+import org.eclipse.nebula.widgets.nattable.coordinate.RangeList;
 import org.eclipse.nebula.widgets.nattable.copy.serializing.CopyDataToClipboardSerializer;
 import org.eclipse.nebula.widgets.nattable.copy.serializing.CopyFormattedTextToClipboardSerializer;
 import org.eclipse.nebula.widgets.nattable.layer.ILayer;
@@ -105,94 +101,87 @@
 
 	/**
 	 * Collects and assembles the selected data that should be copied to the clipboard.
+	 * 
+	 * Creates the two dimensional array whose dimensions are calculated based on the selection
+	 * within the {@link SelectionLayer} and the configured column and row headers.
+	 * 
 	 * @return A two dimensional array containing the selected cells to copy to the clipboard.
 	 * 			The first level of this array represent the row positions of the cells, while the
 	 * 			second level contains the cells itself based on the column position.
 	 */
 	protected ILayerCell[][] assembleCopiedDataStructure() {
-		final Set<Range> selectedRows = selectionLayer.getSelectedRowPositions();
-		final ILayerCell[][] copiedCells = assembleColumnHeaders();
+		final RangeList selectedRowPositions = selectionLayer.getSelectedRowPositions();
+		final RangeList selectedColumnPositions = selectionLayer.getSelectedColumnPositions();
 		
-		//cleanup the row positions to copy
-		//this is needed because taking only the Range.start into account leads to overriding
-		//values in the array instead of adding if there are multiple Ranges returned
-		List<Integer> selectedRowPositions = new ArrayList<Integer>();
-		for (Range range : selectedRows) {
-			for (int rowPosition = range.start; rowPosition < range.end; rowPosition++) {
-				selectedRowPositions.add(rowPosition);
-			}
-		}
-		//ensure the correct order as a Set is not ordered at all and we want to paste the values
-		//in the same order we copied them.
-		Collections.sort(selectedRowPositions);
+		final int rowOffset = (columnHeaderDataLayer != null) ? columnHeaderDataLayer.getRowCount() : 0;
+		final int columnOffset = (rowHeaderDataLayer != null) ? rowHeaderDataLayer.getColumnCount() : 0;
 		
-		final int rowOffset = columnHeaderDataLayer != null ? columnHeaderDataLayer.getRowCount() : 0;
-		for (int i = 0; i < selectedRowPositions.size(); i++) {
-			Integer rowPos = selectedRowPositions.get(i);
-			copiedCells[i+rowOffset] = assembleBody(rowPos);
+		final ILayerCell[][] cells = new ILayerCell[selectedRowPositions.values().size() + rowOffset][];
+		
+		int cellsIdx = 0;
+		while (cellsIdx < rowOffset) {
+			cells[cellsIdx++] = assembleColumnHeader(selectedColumnPositions, columnOffset, cellsIdx);
 		}
-
-		return copiedCells;
+		for (final IValueIterator rowIter = selectedRowPositions.values().iterator(); rowIter.hasNext(); ) {
+			final int rowPosition = rowIter.nextValue();
+			cells[cellsIdx++] = assembleBody(selectedColumnPositions, columnOffset, rowPosition);
+		}
+		
+		return cells;
 	}
-
+	
 	/**
-	 * Creates the two dimensional array whose dimensions are calculated based on the selection
-	 * within the {@link SelectionLayer} and the configured column and row headers.
-	 * If there is a column header configured for this handler, the column header information
-	 * will be added to the resulting array in here. If there is no column header configured
-	 * an empty array with the matching dimensions will be returned.
-	 * @return A two dimensional array with the dimensions to store the selected data to copy
-	 * 			to the clipboard. Will also contain the column header information for the copy
-	 * 			operation if there is one configured.
+	 * Collects and assembles the column header information for the specified column header row.
+	 * 
+	 * If there is no column header configured an empty array with the matching dimensions will be returned.
+	 * 
+	 * @param selectedColumnPositions The column positions of which the information should be collected
+	 * @param columnOffset The column offset of table body
+	 * @param headerRowPosition The row position in the column header of which the information should be collected
+	 * @return An array containing the column header information
 	 */
-	protected ILayerCell[][] assembleColumnHeaders() {
-		// Add offset to rows, remember they need to include the column header rows
-		final int rowOffset = columnHeaderDataLayer != null ? columnHeaderDataLayer.getRowCount() : 0;
-		final int columnOffset = rowHeaderDataLayer != null ? rowHeaderDataLayer.getColumnCount() : 0;
-
-		final ILayerCell[][] copiedCells = new ILayerCell[selectionLayer.getSelectedRowCount() + rowOffset][1];
+	protected ILayerCell[] assembleColumnHeader(final RangeList selectedColumnPositions, final int columnOffset,
+			final int headerRowPosition) {
+		final ILayerCell[] headerCells = new ILayerCell[selectedColumnPositions.values().size() + columnOffset];
 		
+		int headerIdx = columnOffset;
 		if (columnHeaderDataLayer != null) {
-			int[] selectedColumnPositions = selectionLayer.getSelectedColumnPositions();
-			for (int i = 0; i < rowOffset; i++) {
-				final ILayerCell[] cells = new ILayerCell[selectedColumnPositions.length + columnOffset];
-				for (int columnPosition = 0; columnPosition < selectedColumnPositions.length; columnPosition++) {
-					// Pad the width of the vertical layer
-					cells[columnPosition + columnOffset] = 
-							columnHeaderDataLayer.getCellByPosition(selectedColumnPositions[columnPosition], i);
-				}
-				
-				copiedCells[i] = cells;
+			for (final IValueIterator columnIter = selectedColumnPositions.values().iterator(); columnIter.hasNext(); headerIdx++) {
+				final int columnPosition = columnIter.nextValue();
+				headerCells[headerIdx] = columnHeaderDataLayer.getCellByPosition(columnPosition, headerRowPosition);
 			}
 		}
 		
-		return copiedCells;
+		return headerCells;
 	}
 	
 	/**
 	 * Collects and assembles the selected data per row position that should be copied to the clipboard.
 	 * If there is a row header layer configured for this handler, the row header cells of the selected
 	 * row position are also added to the resulting array.
-	 * @param currentRowPosition The row position of which the selected cells should be collected.
-	 * @return An array containing the selected cells that should be copied to the clipboard. 
+	 * 
+	 * @param selectedColumnPositions The column positions of which the information should be collected
+	 * @param columnOffset The column offset of table body
+	 * @param currentRowPosition The row position of which the selected cells should be collected
+	 * @return An array containing the specified cells
 	 */
-	protected ILayerCell[] assembleBody(int currentRowPosition) {		
-		final int[] selectedColumns = selectionLayer.getSelectedColumnPositions();
-		final int columnOffset = rowHeaderDataLayer != null ? rowHeaderDataLayer.getColumnCount() : 0;
-		final ILayerCell[] bodyCells = new ILayerCell[selectedColumns.length + columnOffset];
+	protected ILayerCell[] assembleBody(final RangeList selectedColumnPositions,  final int columnOffset,
+			final int currentRowPosition) {
+		final ILayerCell[] bodyCells = new ILayerCell[selectedColumnPositions.values().size() + columnOffset];
 		
+		int bodyIdx = 0;
 		if (rowHeaderDataLayer != null) {
-			for (int i = 0; i < rowHeaderDataLayer.getColumnCount(); i++) {
-				bodyCells[i] = rowHeaderDataLayer.getCellByPosition(i, currentRowPosition);
+			for (; bodyIdx < columnOffset; bodyIdx++) {
+				bodyCells[bodyIdx] = rowHeaderDataLayer.getCellByPosition(bodyIdx, currentRowPosition);
+			}
+		}
+		for (final IValueIterator columnIter = selectedColumnPositions.values().iterator(); columnIter.hasNext(); bodyIdx++) {
+			final int columnPosition = columnIter.nextValue();
+			if (selectionLayer.isCellPositionSelected(columnPosition, currentRowPosition)) {
+				bodyCells[bodyIdx] = selectionLayer.getCellByPosition(columnPosition, currentRowPosition);
 			}
 		}
 		
-		for (int columnPosition = 0; columnPosition < selectedColumns.length; columnPosition++) {
-			final int selectedColumnPosition = selectedColumns[columnPosition];
-			if (selectionLayer.isCellPositionSelected(selectedColumnPosition, currentRowPosition)) {
-				bodyCells[columnPosition + columnOffset] = selectionLayer.getCellByPosition(selectedColumnPosition, currentRowPosition);
-			}
-		}
 		return bodyCells;
 	}
 	
diff --git a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/edit/command/EditUtils.java b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/edit/command/EditUtils.java
index d140eef..7222280 100644
--- a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/edit/command/EditUtils.java
+++ b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/edit/command/EditUtils.java
@@ -124,7 +124,7 @@
 	 * 			configured.
 	 */
 	public static boolean isEditorSame(SelectionLayer selectionLayer, IConfigRegistry configRegistry) {
-		PositionCoordinate[] selectedCells = selectionLayer.getSelectedCellPositions();
+		List<PositionCoordinate> selectedCells = selectionLayer.getSelectedCellPositions();
 		ICellEditor lastSelectedCellEditor = null;
 		for (PositionCoordinate selectedCell : selectedCells) {
 			LabelStack labelStack = selectionLayer.getConfigLabelsByPosition(
@@ -162,7 +162,7 @@
 	 */
 	@SuppressWarnings("rawtypes")
 	public static boolean isConverterSame(SelectionLayer selectionLayer, IConfigRegistry configRegistry){
-		PositionCoordinate[] selectedCells = selectionLayer.getSelectedCellPositions();
+		List<PositionCoordinate> selectedCells = selectionLayer.getSelectedCellPositions();
 		Set<Class> converterSet = new HashSet<Class>();
 		
 		for (PositionCoordinate selectedCell : selectedCells) {
diff --git a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/grid/layer/event/ColumnHeaderSelectionEvent.java b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/grid/layer/event/ColumnHeaderSelectionEvent.java
index 5667e6c..9815473 100644
--- a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/grid/layer/event/ColumnHeaderSelectionEvent.java
+++ b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/grid/layer/event/ColumnHeaderSelectionEvent.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2012 Original authors and others.
+ * Copyright (c) 2012, 2013 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
@@ -10,7 +10,6 @@
  ******************************************************************************/
 package org.eclipse.nebula.widgets.nattable.grid.layer.event;
 
-import java.util.Arrays;
 import java.util.Collection;
 
 import org.eclipse.nebula.widgets.nattable.coordinate.Range;
@@ -19,14 +18,7 @@
 
 
 public class ColumnHeaderSelectionEvent extends ColumnVisualChangeEvent {
-
-	public ColumnHeaderSelectionEvent(ILayer layer, int columnPosition) {
-		this(layer, new Range(columnPosition, columnPosition + 1));
-	}
 	
-	public ColumnHeaderSelectionEvent(ILayer layer, Range...columnPositionRanges) {
-		this(layer, Arrays.asList(columnPositionRanges));
-	}
 	
 	public ColumnHeaderSelectionEvent(ILayer layer, Collection<Range> columnPositionRanges) {
 		super(layer, columnPositionRanges);
@@ -36,6 +28,7 @@
 		super(event);
 	}
 	
+	@Override
 	public ColumnHeaderSelectionEvent cloneEvent() {
 		return new ColumnHeaderSelectionEvent(this);
 	}
diff --git a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/group/RowGroupHeaderLayer.java b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/group/RowGroupHeaderLayer.java
index 8f16c19..18c5614 100644
--- a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/group/RowGroupHeaderLayer.java
+++ b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/group/RowGroupHeaderLayer.java
@@ -10,11 +10,12 @@
  ******************************************************************************/
 package org.eclipse.nebula.widgets.nattable.group;
 
-import java.util.ArrayList;
 import java.util.List;
 import java.util.Properties;
 
 import org.eclipse.nebula.widgets.nattable.NatTable;
+import org.eclipse.nebula.widgets.nattable.coordinate.IValueIterator;
+import org.eclipse.nebula.widgets.nattable.coordinate.RangeList;
 import org.eclipse.nebula.widgets.nattable.grid.GridRegion;
 import org.eclipse.nebula.widgets.nattable.group.config.DefaultRowGroupHeaderLayerConfiguration;
 import org.eclipse.nebula.widgets.nattable.group.model.IRowGroup;
@@ -269,10 +270,13 @@
 	@Override
 	public LabelStack getConfigLabelsByPosition(int columnPosition, int rowPosition) {
 		int rowIndex = getRowIndexByPosition(rowPosition);
-		if( columnPosition == 0 && RowGroupUtils.isPartOfAGroup(model, rowIndex) ) {
-			List<Integer> selectedRowIndexes = convertToRowIndexes(selectionLayer.getFullySelectedRowPositions());
-			if (selectedRowIndexes.contains(rowIndex)) {
-				return new LabelStack(SelectionStyleLabels.ROW_FULLY_SELECTED_STYLE, GridRegion.ROW_GROUP_HEADER);
+		if (columnPosition == 0 && RowGroupUtils.isPartOfAGroup(model, rowIndex) ) {
+			final RangeList fullySelectedRowPositions = selectionLayer.getFullySelectedRowPositions();
+			for (final IValueIterator rowIter = fullySelectedRowPositions.values().iterator(); rowIter.hasNext(); ) {
+				int index = this.selectionLayer.getRowIndexByPosition(rowIter.nextValue());
+				if (rowIndex == index) {
+					return new LabelStack(SelectionStyleLabels.ROW_FULLY_SELECTED_STYLE, GridRegion.ROW_GROUP_HEADER);
+				}
 			}
 			return new LabelStack(GridRegion.ROW_GROUP_HEADER);
 		} else {
@@ -280,14 +284,6 @@
 		}
 	}
 	
-	private List<Integer> convertToRowIndexes(final int[] rowPositions) {
-		final List <Integer> rowIndexes = new ArrayList<Integer>();
-		for(final Integer rowPosition : rowPositions){
-			rowIndexes.add(this.selectionLayer.getRowIndexByPosition(rowPosition));
-		}
-		return rowIndexes;
-	}
-	
 	@Override
 	public Object getDataValueByPosition(int columnPosition, int rowPosition) {
 		int rowIndex = getRowIndexByPosition(rowPosition);
diff --git a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/group/command/ColumnGroupsCommandHandler.java b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/group/command/ColumnGroupsCommandHandler.java
index 50c7253..c0aa867 100644
--- a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/group/command/ColumnGroupsCommandHandler.java
+++ b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/group/command/ColumnGroupsCommandHandler.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2012 Original authors and others.
+ * Copyright (c) 2012, 2013 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,16 +11,20 @@
 package org.eclipse.nebula.widgets.nattable.group.command;
 
 import java.util.ArrayList;
-import java.util.Collection;
 import java.util.HashMap;
-import java.util.Iterator;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 
+import org.eclipse.swt.graphics.Point;
+import org.eclipse.swt.graphics.Rectangle;
+import org.eclipse.swt.widgets.Display;
+
 import org.eclipse.nebula.widgets.nattable.Messages;
 import org.eclipse.nebula.widgets.nattable.columnRename.ColumnRenameDialog;
 import org.eclipse.nebula.widgets.nattable.command.AbstractLayerCommandHandler;
+import org.eclipse.nebula.widgets.nattable.coordinate.IValueIterator;
+import org.eclipse.nebula.widgets.nattable.coordinate.RangeList;
 import org.eclipse.nebula.widgets.nattable.group.ColumnGroupHeaderLayer;
 import org.eclipse.nebula.widgets.nattable.group.ColumnGroupModel;
 import org.eclipse.nebula.widgets.nattable.group.ColumnGroupModel.ColumnGroup;
@@ -29,9 +33,6 @@
 import org.eclipse.nebula.widgets.nattable.group.event.UngroupColumnsEvent;
 import org.eclipse.nebula.widgets.nattable.reorder.command.MultiColumnReorderCommand;
 import org.eclipse.nebula.widgets.nattable.selection.SelectionLayer;
-import org.eclipse.swt.graphics.Point;
-import org.eclipse.swt.graphics.Rectangle;
-import org.eclipse.swt.widgets.Display;
 
 
 public class ColumnGroupsCommandHandler extends AbstractLayerCommandHandler<IColumnGroupCommand>  {
@@ -57,7 +58,7 @@
 		} else if (command instanceof OpenCreateColumnGroupDialog) {
 			OpenCreateColumnGroupDialog openDialogCommand = (OpenCreateColumnGroupDialog) command;
 			loadSelectedColumnsIndexesWithPositions();
-			if (selectionLayer.getFullySelectedColumnPositions().length > 0 && columnIndexesToPositionsMap.size() > 0) {
+			if (!selectionLayer.getFullySelectedColumnPositions().isEmpty() && columnIndexesToPositionsMap.size() > 0) {
 				openDialogCommand.openDialog(contextLayer);
 			} else {				
 				openDialogCommand.openErrorBox(Messages.getString("ColumnGroups.selectNonGroupedColumns"));				 //$NON-NLS-1$
@@ -101,24 +102,20 @@
 	
 	protected void loadSelectedColumnsIndexesWithPositions() {
 		columnIndexesToPositionsMap = new LinkedHashMap<Integer, Integer>();
-		int[] fullySelectedColumns = selectionLayer.getFullySelectedColumnPositions();
+		final RangeList fullySelectedColumns = selectionLayer.getFullySelectedColumnPositions();
 		
-		if (fullySelectedColumns.length > 0) {
-			for (int index = 0; index < fullySelectedColumns.length; index++) {
-				final int columnPosition = fullySelectedColumns[index];
-				int columnIndex = selectionLayer.getColumnIndexByPosition(columnPosition);
-				if (model.isPartOfAGroup(columnIndex)){
-					columnIndexesToPositionsMap.clear();
-					break;
-				}
-				columnIndexesToPositionsMap.put(Integer.valueOf(columnIndex), Integer.valueOf(columnPosition));
+		for (final IValueIterator columnIter = fullySelectedColumns.values().iterator(); columnIter.hasNext(); ) {
+			final int position = columnIter.nextValue();
+			int index = selectionLayer.getColumnIndexByPosition(position);
+			if (model.isPartOfAGroup(index)) {
+				columnIndexesToPositionsMap.clear();
+				break;
 			}
-			
+			columnIndexesToPositionsMap.put(Integer.valueOf(index), Integer.valueOf(position));
 		}
 	}
 
 	public void handleGroupColumnsCommand(String columnGroupName) {
-			
 		try {
 			List<Integer> selectedPositions = new ArrayList<Integer>();
 			int[] fullySelectedColumns = new int[columnIndexesToPositionsMap.size()];
@@ -137,27 +134,24 @@
 
 	public void handleUngroupCommand() {
 		// Grab fully selected column positions
-		int[] fullySelectedColumns = selectionLayer.getFullySelectedColumnPositions();
+		final RangeList fullySelectedColumns = selectionLayer.getFullySelectedColumnPositions();
 		Map<String, Integer> toColumnPositions = new HashMap<String, Integer>();
-		if (fullySelectedColumns.length > 0) {
 		
-		// Pick the ones which belong to a group and remove them from the group
-			for (int index = 0; index < fullySelectedColumns.length; index++) {
-				final int columnPosition = fullySelectedColumns[index];
-				int columnIndex = selectionLayer.getColumnIndexByPosition(columnPosition);
-				if (model.isPartOfAGroup(columnIndex) && !model.isPartOfAnUnbreakableGroup(columnIndex)){
-					handleRemovalFromGroup(toColumnPositions, columnIndex);
-				}
+		for (final IValueIterator columnIter = fullySelectedColumns.values().iterator(); columnIter.hasNext(); ) {
+			// Pick the ones which belong to a group and remove them from the group
+			final int position = columnIter.nextValue();
+			int index = selectionLayer.getColumnIndexByPosition(position);
+			if (model.isPartOfAGroup(index) && !model.isPartOfAnUnbreakableGroup(index)) {
+				handleRemovalFromGroup(toColumnPositions, index);
 			}
-		// The groups which were affected should be reordered to the start position, this should group all columns together
-			Collection<Integer> values = toColumnPositions.values();
-			final Iterator<Integer> toColumnPositionsIterator = values.iterator();
-			while(toColumnPositionsIterator.hasNext()) {
-				Integer toColumnPosition = toColumnPositionsIterator.next();
-				selectionLayer.doCommand(new ReorderColumnGroupCommand(selectionLayer, toColumnPosition.intValue(), toColumnPosition.intValue()));
+		}
+		if (!toColumnPositions.isEmpty()) {
+			// The groups which were affected should be reordered to the start position, this should group all columns together
+			for (final Integer position : toColumnPositions.values()) {
+				selectionLayer.doCommand(new ReorderColumnGroupCommand(selectionLayer, position, position));
 			}
 			selectionLayer.clear();
-		} 
+		}
 		
 		contextLayer.fireLayerEvent(new UngroupColumnsEvent(contextLayer));
 	}
diff --git a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/resize/command/InitializeAutoResizeColumnsCommand.java b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/resize/command/InitializeAutoResizeColumnsCommand.java
index d5e1b59..123f4ab 100644
--- a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/resize/command/InitializeAutoResizeColumnsCommand.java
+++ b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/resize/command/InitializeAutoResizeColumnsCommand.java
@@ -71,11 +71,6 @@
 		return sourceLayer;
 	}
 
-	@Deprecated
-	public void setSelectedColumnPositions(final int[] selectedColumnPositions) {
-		setSelectedColumnPositions(new RangeList(selectedColumnPositions));
-	}
-
 	public void setSelectedColumnPositions(final Collection<Range> selectedColumnPositions) {
 		this.selectedColumnPositions = selectedColumnPositions;
 	}
diff --git a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/resize/command/InitializeAutoResizeRowsCommand.java b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/resize/command/InitializeAutoResizeRowsCommand.java
index 9d7926c..3470735 100644
--- a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/resize/command/InitializeAutoResizeRowsCommand.java
+++ b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/resize/command/InitializeAutoResizeRowsCommand.java
@@ -66,11 +66,6 @@
 		return sourceLayer;
 	}
 
-	@Deprecated
-	public void setSelectedRowPositions(final int[] selectedRowPositions) {
-		setSelectedRowPositions(new RangeList(selectedRowPositions));
-	}
-
 	public void setSelectedRowPositions(final Collection<Range> selectedRowPositions) {
 		this.selectedRowPositions = selectedRowPositions;
 	}
diff --git a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/search/strategy/CellDisplayValueSearchUtil.java b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/search/strategy/CellDisplayValueSearchUtil.java
index e4c1f98..17d3f74 100644
--- a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/search/strategy/CellDisplayValueSearchUtil.java
+++ b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/search/strategy/CellDisplayValueSearchUtil.java
@@ -11,7 +11,6 @@
 package org.eclipse.nebula.widgets.nattable.search.strategy;
 
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.Comparator;
 import java.util.List;
 
@@ -23,6 +22,7 @@
 import org.eclipse.nebula.widgets.nattable.layer.cell.ILayerCell;
 import org.eclipse.nebula.widgets.nattable.style.DisplayMode;
 
+
 public class CellDisplayValueSearchUtil {
 	
 	static List<PositionCoordinate> getCellCoordinates(ILayer contextLayer, int startingColumnPosition, int startingRowPosition, int width, int height) {
@@ -51,14 +51,13 @@
 	
 	
 	@SuppressWarnings("unchecked")
-	static PositionCoordinate findCell(final ILayer layer, final IConfigRegistry configRegistry, final PositionCoordinate[] cellsToSearch, final Object valueToMatch, final Comparator comparator, final boolean caseSensitive) {	
-		final List<PositionCoordinate> cellCoordinates = Arrays.asList(cellsToSearch);		
+	static PositionCoordinate findCell(final ILayer layer, final IConfigRegistry configRegistry, List<PositionCoordinate> cellsToSearch, final Object valueToMatch, final Comparator comparator, final boolean caseSensitive) {	
 		// Find cell
 		PositionCoordinate targetCoordinate = null;
 		
 		String stringValue = caseSensitive ? valueToMatch.toString() : valueToMatch.toString().toLowerCase();
-		for (int cellIndex = 0; cellIndex < cellCoordinates.size(); cellIndex++) {
-			final PositionCoordinate cellCoordinate = cellCoordinates.get(cellIndex);
+		for (int cellIndex = 0; cellIndex < cellsToSearch.size(); cellIndex++) {
+			final PositionCoordinate cellCoordinate = cellsToSearch.get(cellIndex);
 			final int columnPosition = cellCoordinate.columnPosition;
 			final int rowPosition = cellCoordinate.rowPosition;
 			
@@ -84,4 +83,5 @@
 		
 		return targetCoordinate;
 	}
+	
 }
diff --git a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/search/strategy/ColumnSearchStrategy.java b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/search/strategy/ColumnSearchStrategy.java
index 22b8d0e..e78c389 100644
--- a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/search/strategy/ColumnSearchStrategy.java
+++ b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/search/strategy/ColumnSearchStrategy.java
@@ -49,7 +49,7 @@
 		this.columnPositions = columnPositions;
 	}
 	
-	protected PositionCoordinate[] getColumnCellsToSearch(ILayer contextLayer) {
+	protected List<PositionCoordinate> getColumnCellsToSearch(ILayer contextLayer) {
 		List<PositionCoordinate> cellsToSearch = new ArrayList<PositionCoordinate>();
 		int rowPosition = startingRowPosition;
 		// See how many rows we can add, depends on where the search is starting from
@@ -72,6 +72,7 @@
 			height = rowCount;
 			// After first column is set, start the next column from the top
 		}
-		return cellsToSearch.toArray(new PositionCoordinate[0]);
+		return cellsToSearch;
 	}
+	
 }
diff --git a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/search/strategy/RowSearchStrategy.java b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/search/strategy/RowSearchStrategy.java
index 097988f..f02ee86 100644
--- a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/search/strategy/RowSearchStrategy.java
+++ b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/search/strategy/RowSearchStrategy.java
@@ -40,7 +40,7 @@
 		return CellDisplayValueSearchUtil.findCell(getContextLayer(), configRegistry, getRowCellsToSearch(getContextLayer()), valueToMatch, getComparator(), isCaseSensitive());
 	}
 
-	protected PositionCoordinate[] getRowCellsToSearch(ILayer contextLayer) {
+	protected List<PositionCoordinate> getRowCellsToSearch(ILayer contextLayer) {
 		List<PositionCoordinate> cellsToSearch = new ArrayList<PositionCoordinate>();
 		for (int rowPosition : rowPositions) {
 			cellsToSearch.addAll(CellDisplayValueSearchUtil.getCellCoordinates(getContextLayer(), 0, rowPosition, contextLayer.getColumnCount(), 1));
@@ -48,6 +48,7 @@
 		if (searchDirection.equals(ISearchDirection.SEARCH_BACKWARDS)) {
 			Collections.reverse(cellsToSearch);
 		}
-		return cellsToSearch.toArray(new PositionCoordinate[0]);
+		return cellsToSearch;
 	}
+	
 }
diff --git a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/search/strategy/SelectionSearchStrategy.java b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/search/strategy/SelectionSearchStrategy.java
index 1c13d2f..2b0828f 100644
--- a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/search/strategy/SelectionSearchStrategy.java
+++ b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/search/strategy/SelectionSearchStrategy.java
@@ -10,7 +10,6 @@
  ******************************************************************************/
 package org.eclipse.nebula.widgets.nattable.search.strategy;
 
-import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
 
@@ -45,14 +44,10 @@
 		return coordinate;
 	}
 
-	protected PositionCoordinate[] getSelectedCells(SelectionLayer selectionLayer) {
-		PositionCoordinate[] selectedCells = null;
+	protected List<PositionCoordinate> getSelectedCells(SelectionLayer selectionLayer) {
+		List<PositionCoordinate> selectedCells = selectionLayer.getSelectedCellPositions();
 		if (searchDirection.equals(ISearchDirection.SEARCH_BACKWARDS)) {
-			List<PositionCoordinate> coordinates = Arrays.asList(selectionLayer.getSelectedCellPositions());
-			Collections.reverse(coordinates);
-			selectedCells = coordinates.toArray(new PositionCoordinate[0]);
-		} else {
-			selectedCells = selectionLayer.getSelectedCellPositions();
+			Collections.reverse(selectedCells);
 		}
 		return selectedCells;
 	}
diff --git a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/selection/ISelectionModel.java b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/selection/ISelectionModel.java
index 090735e..1bcdcd7 100644
--- a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/selection/ISelectionModel.java
+++ b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/selection/ISelectionModel.java
@@ -8,71 +8,157 @@
  * Contributors:
  *     Original authors and others - initial API and implementation
  ******************************************************************************/
+
 package org.eclipse.nebula.widgets.nattable.selection;
 
 import java.util.List;
-import java.util.Set;
 
+import org.eclipse.nebula.widgets.nattable.coordinate.RangeList;
+import org.eclipse.nebula.widgets.nattable.coordinate.Rectangle;
 
-import org.eclipse.nebula.widgets.nattable.coordinate.Range;
-import org.eclipse.swt.graphics.Rectangle;
 
 /**
  * Tracks the selections made in the table.
+ * <p>
+ * A column or row is <i>selected</i>, if any cells in that column/row are selected.
+ * A column or row is <i>fully selected</i>, if all cells in that column/row are selected.
+ * A column or row is not selected and not fully selected, if the selection layer is empty
+ * (any dim has size 0).</p>
  */
 public interface ISelectionModel {
 	
-	public boolean isMultipleSelectionAllowed();
 	
-	public void setMultipleSelectionAllowed(boolean multipleSelectionAllowed);
-
-	public void addSelection(int columnPosition, int rowPosition);
-
-	public void addSelection(final Rectangle range);
-
-	public void clearSelection();
-
-	public void clearSelection(int columnPosition, int rowPosition);
-
-	public void clearSelection(Rectangle removedSelection);
-
-	public boolean isEmpty();
-
-	public List<Rectangle> getSelections();
+	boolean isMultipleSelectionAllowed();
 	
-	// Cell features
-
-	public boolean isCellPositionSelected(int columnPosition, int rowPosition);
+	void setMultipleSelectionAllowed(boolean multipleSelectionAllowed);
 	
-	// Column features
-
-	public int[] getSelectedColumnPositions();
-
-	public boolean isColumnPositionSelected(int columnPosition);
-
+	
 	/**
-	 * @param columnHeight the number of rows in a fully selected column
+	 * Adds the specified position to the selection.
+	 * 
+	 * @param columnPosition the column position in the selection layer
+	 * @param rowPosition the row position in the selection layer
 	 */
-	public int[] getFullySelectedColumnPositions(int columnHeight);
-
-	/**
-	 * @param columnHeight the number of rows in a fully selected column
-	 */
-	public boolean isColumnPositionFullySelected(int columnPosition, int columnHeight);
-
-	// Row features
-
-	public int getSelectedRowCount();
+	void addSelection(int columnPosition, int rowPosition);
 	
-	public Set<Range> getSelectedRowPositions();
-	
-	public boolean isRowPositionSelected(int rowPosition);
-
 	/**
-	 * @param rowWidth the number of columns in a fully selected row
+	 * Adds the specified position rectangle to the selection.
+	 * 
+	 * @param rect the position rectangle in the selection layer
 	 */
-	public int[] getFullySelectedRowPositions(int rowWidth);
-
-	public boolean isRowPositionFullySelected(int rowPosition, int rowWidth);
+	void addSelection(Rectangle positions);
+	
+	/**
+	 * Clears the selection completely.
+	 */
+	void clearSelection();
+	
+	/**
+	 * Removes the specified position from the selection.
+	 * 
+	 * @param columnPosition the column position in the selection layer
+	 * @param rowPosition the row position in the selection layer
+	 */
+	void clearSelection(int columnPosition, int rowPosition);
+	
+	/**
+	 * Removes the specified position rectangle from the selection.
+	 * 
+	 * @param rect the position rectangle in the selection layer
+	 */
+	void clearSelection(Rectangle positions);
+	
+	/**
+	 * Returns if the selection is empty.
+	 * 
+	 * @return <code>true</code> if the selection is empty, otherwise <code>false</code>
+	 */
+	boolean isEmpty();
+	
+	/**
+	 * Returns a collection of rectangles of selected positions. If a position is inside a
+	 * rectangle of the list, it is selected, otherwise it is not selected.
+	 * 
+	 * @return a list of position rectangles
+	 */
+	List<Rectangle> getSelections();
+	
+	//-- Cell features --//
+	
+	/**
+	 * Returns if the specified position is selected.
+	 * 
+	 * @param columnPosition the column position in the selection layer
+	 * @param rowPosition the row position in the selection layer
+	 * @return <code>true</code> if the position is selected, otherwise <code>false</code>
+	 */
+	boolean isCellPositionSelected(int columnPosition, int rowPosition);
+	
+	//-- Column features --//
+	
+	/**
+	 * Returns the positions of all selected columns. 
+	 * 
+	 * @return the positions of selected columns as ordered and disjoint list of position ranges
+	 */
+	RangeList getSelectedColumnPositions();
+	
+	/**
+	 * Returns if the specified column position is selected. A column is selected, if any cell in 
+	 * the column is selected.
+	 * 
+	 * @param columnPosition the column position in the selection layer
+	 * @return <code>true</code> if the column is selected, otherwise <code>false</code>
+	 */
+	boolean isColumnPositionSelected(int columnPosition);
+	
+	/**
+	 * Returns the positions of all fully selected columns. 
+	 * 
+	 * @return the positions of fully selected columns as ordered and disjoint list of position ranges
+	 */
+	RangeList getFullySelectedColumnPositions();
+	
+	/**
+	 * Returns if the specified column position is fully selected.
+	 * 
+	 * @param columnPosition the column position in the selection layer
+	 * @return <code>true</code> if the column is fully selected, otherwise <code>false</code>
+	 */
+	boolean isColumnPositionFullySelected(int columnPosition);
+	
+	//-- Row features --//
+	
+	int getSelectedRowCount();
+	
+	/**
+	 * Returns the positions of all selected rows. 
+	 * 
+	 * @return the positions of selected rows as ordered and disjoint list of position ranges
+	 */
+	RangeList getSelectedRowPositions();
+	
+	/**
+	 * Returns if the specified row position is selected.
+	 * 
+	 * @param rowPosition the row position in the selection layer
+	 * @return <code>true</code> if the row is selected, otherwise <code>false</code>
+	 */
+	boolean isRowPositionSelected(int rowPosition);
+	
+	/**
+	 * Returns the positions of all fully selected rows. 
+	 * 
+	 * @return the positions of fully selected rows as ordered and disjoint list of position ranges
+	 */
+	RangeList getFullySelectedRowPositions();
+	
+	/**
+	 * Returns if the specified row position is fully selected.
+	 * 
+	 * @param rowPosition the row position in the selection layer
+	 * @return <code>true</code> if the row is fully selected, otherwise <code>false</code>
+	 */
+	boolean isRowPositionFullySelected(int rowPosition);
 	
 }
diff --git a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/selection/RowSelectionModel.java b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/selection/RowSelectionModel.java
index b96f848..67b2df5 100644
--- a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/selection/RowSelectionModel.java
+++ b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/selection/RowSelectionModel.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2012 Original authors and others.
+ * Copyright (c) 2012, 2013 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,7 +13,6 @@
 import java.io.Serializable;
 import java.util.ArrayList;
 import java.util.HashMap;
-import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
@@ -21,14 +20,18 @@
 import java.util.concurrent.locks.ReentrantReadWriteLock;
 
 import org.eclipse.nebula.widgets.nattable.coordinate.Range;
+import org.eclipse.nebula.widgets.nattable.coordinate.RangeList;
+import org.eclipse.nebula.widgets.nattable.coordinate.Rectangle;
 import org.eclipse.nebula.widgets.nattable.data.IRowDataProvider;
 import org.eclipse.nebula.widgets.nattable.data.IRowIdAccessor;
+import org.eclipse.nebula.widgets.nattable.layer.IUniqueIndexLayer;
 import org.eclipse.nebula.widgets.nattable.layer.cell.ILayerCell;
-import org.eclipse.swt.graphics.Rectangle;
+
 
 public class RowSelectionModel<R> implements IRowSelectionModel<R> {
-
-	protected final SelectionLayer selectionLayer;
+	
+	protected final IUniqueIndexLayer selectionLayer;
+	
 	protected final IRowDataProvider<R> rowDataProvider;
 	protected final IRowIdAccessor<R> rowIdAccessor;
 	private boolean multipleSelectionAllowed;
@@ -37,179 +40,183 @@
 	protected Rectangle lastSelectedRange;  // *live* reference to last range parameter used in addSelection(range)
 	protected Set<Serializable> lastSelectedRowIds;
 	protected final ReadWriteLock selectionsLock;
-
-	public RowSelectionModel(SelectionLayer selectionLayer, IRowDataProvider<R> rowDataProvider, IRowIdAccessor<R> rowIdAccessor) {
+	
+	
+	public RowSelectionModel(/*@NotNull*/ final IUniqueIndexLayer selectionLayer,
+			final IRowDataProvider<R> rowDataProvider, final IRowIdAccessor<R> rowIdAccessor) {
 		this(selectionLayer, rowDataProvider, rowIdAccessor, true);
 	}
 	
-	public RowSelectionModel(SelectionLayer selectionLayer, IRowDataProvider<R> rowDataProvider, IRowIdAccessor<R> rowIdAccessor, boolean multipleSelectionAllowed) {
+	public RowSelectionModel(/*@NotNull*/ final IUniqueIndexLayer selectionLayer,
+			final IRowDataProvider<R> rowDataProvider, final IRowIdAccessor<R> rowIdAccessor,
+			final boolean multipleSelectionAllowed) {
+		if (selectionLayer == null) {
+			throw new NullPointerException("selectionLayer"); //$NON-NLS-1$
+		}
 		this.selectionLayer = selectionLayer;
 		this.rowDataProvider = rowDataProvider;
 		this.rowIdAccessor = rowIdAccessor;
 		this.multipleSelectionAllowed = multipleSelectionAllowed;
 		
-		selectedRows = new HashMap<Serializable, R>();
-		selectionsLock = new ReentrantReadWriteLock();
+		this.selectedRows = new HashMap<Serializable, R>();
+		this.selectionsLock = new ReentrantReadWriteLock();
 	}
 	
+	
 	@Override
 	public boolean isMultipleSelectionAllowed() {
-		return multipleSelectionAllowed;
+		return this.multipleSelectionAllowed;
 	}
 	
 	@Override
-	public void setMultipleSelectionAllowed(boolean multipleSelectionAllowed) {
+	public void setMultipleSelectionAllowed(final boolean multipleSelectionAllowed) {
 		this.multipleSelectionAllowed = multipleSelectionAllowed;
 	}
-
+	
+	
 	@Override
-	public void addSelection(int columnPosition, int rowPosition) {
-		selectionsLock.writeLock().lock();
-		
+	public void addSelection(final int columnPosition, final int rowPosition) {
+		this.selectionsLock.writeLock().lock();
 		try {
-			if (!multipleSelectionAllowed) {
-				selectedRows.clear();
+			if (!this.multipleSelectionAllowed) {
+				this.selectedRows.clear();
 			}
 			
-			R rowObject = getRowObjectByPosition(rowPosition);
+			final R rowObject = getRowObjectByPosition(rowPosition);
 			if (rowObject != null) {
-				Serializable rowId = rowIdAccessor.getRowId(rowObject);
-				selectedRows.put(rowId, rowObject);
+				final Serializable rowId = this.rowIdAccessor.getRowId(rowObject);
+				this.selectedRows.put(rowId, rowObject);
 			}
 		} finally {
-			selectionsLock.writeLock().unlock();
+			this.selectionsLock.writeLock().unlock();
 		}
 	}
-
+	
 	@Override
-	public void addSelection(Rectangle range) {
-		selectionsLock.writeLock().lock();
-		
+	public void addSelection(final Rectangle positions) {
+		this.selectionsLock.writeLock().lock();
 		try {
-			if (multipleSelectionAllowed) {
-				if (range.equals(lastSelectedRange)) {
+			if (this.multipleSelectionAllowed) {
+				if (positions.equals(this.lastSelectedRange)) {
 					// Unselect all previously selected rowIds
-					if (lastSelectedRowIds != null) {
-						for (Serializable rowId : lastSelectedRowIds) {
-							selectedRows.remove(rowId);
+					if (this.lastSelectedRowIds != null) {
+						for (final Serializable rowId : this.lastSelectedRowIds) {
+							this.selectedRows.remove(rowId);
 						}
 					}
 				}
 			} else {
-				selectedRows.clear();
+				this.selectedRows.clear();
 				//as no multiple selection is allowed, ensure that only one row 
 				//will be selected
-				range.height = 1;
+				positions.height = 1;
 			}
 			
-			Map<Serializable, R> rowsToSelect = new HashMap<Serializable, R>();
+			final Map<Serializable, R> rowsToSelect = new HashMap<Serializable, R>();
 			
-			int maxY = Math.min(range.y + range.height, selectionLayer.getRowCount());
-			for (int rowPosition = range.y; rowPosition < maxY; rowPosition++) {
-				R rowObject = getRowObjectByPosition(rowPosition);
+			final int maxY = Math.min(positions.y + positions.height, this.selectionLayer.getRowCount());
+			for (int rowPosition = positions.y; rowPosition < maxY; rowPosition++) {
+				final R rowObject = getRowObjectByPosition(rowPosition);
 				if (rowObject != null) {
-					Serializable rowId = rowIdAccessor.getRowId(rowObject);
+					final Serializable rowId = this.rowIdAccessor.getRowId(rowObject);
 					rowsToSelect.put(rowId, rowObject);
 				}
 			}
 			
-			selectedRows.putAll(rowsToSelect);
+			this.selectedRows.putAll(rowsToSelect);
 			
-			if (range.equals(lastSelectedRange)) {
-				lastSelectedRowIds = rowsToSelect.keySet();
+			if (positions.equals(this.lastSelectedRange)) {
+				this.lastSelectedRowIds = rowsToSelect.keySet();
 			} else {
-				lastSelectedRowIds = null;
+				this.lastSelectedRowIds = null;
 			}
 			
-			lastSelectedRange = range;
+			this.lastSelectedRange = positions;
 		} finally {
-			selectionsLock.writeLock().unlock();
+			this.selectionsLock.writeLock().unlock();
 		}
 	}
 	
 	@Override
 	public void clearSelection() {
-		selectionsLock.writeLock().lock();
+		this.selectionsLock.writeLock().lock();
 		try {
-			selectedRows.clear();
+			this.selectedRows.clear();
 		} finally {
-			selectionsLock.writeLock().unlock();
+			this.selectionsLock.writeLock().unlock();
 		}
 	}
-
+	
 	@Override
-	public void clearSelection(int columnPosition, int rowPosition) {
-		selectionsLock.writeLock().lock();
-		
+	public void clearSelection(final int columnPosition, final int rowPosition) {
+		this.selectionsLock.writeLock().lock();
 		try {
-			Serializable rowId = getRowIdByPosition(rowPosition);
-			selectedRows.remove(rowId);
+			final Serializable rowId = getRowIdByPosition(rowPosition);
+			this.selectedRows.remove(rowId);
 		} finally {
-			selectionsLock.writeLock().unlock();
+			this.selectionsLock.writeLock().unlock();
 		}
 	}
-
+	
 	@Override
-	public void clearSelection(Rectangle removedSelection) {
-		selectionsLock.writeLock().lock();
-		
+	public void clearSelection(final Rectangle positions) {
+		this.selectionsLock.writeLock().lock();
 		try {
-			int maxY = Math.min(removedSelection.y + removedSelection.height, selectionLayer.getRowCount());
-			for (int rowPosition = removedSelection.y; rowPosition < maxY; rowPosition++) {
+			final int maxY = Math.min(positions.y + positions.height, this.selectionLayer.getRowCount());
+			for (int rowPosition = positions.y; rowPosition < maxY; rowPosition++) {
 				clearSelection(0, rowPosition);
 			}
 		} finally {
-			selectionsLock.writeLock().unlock();
+			this.selectionsLock.writeLock().unlock();
 		}
 	}
-
+	
 	@Override
-	public void clearSelection(R rowObject) {
-		selectionsLock.writeLock().lock();
+	public void clearSelection(final R rowObject) {
+		this.selectionsLock.writeLock().lock();
 		
 		try {
-			selectedRows.values().remove(rowObject);
+			this.selectedRows.values().remove(rowObject);
 		} finally {
-			selectionsLock.writeLock().unlock();
+			this.selectionsLock.writeLock().unlock();
 		}
-	};
+	}
+	
 	
 	@Override
 	public boolean isEmpty() {
-		selectionsLock.readLock().lock();
-		
+		this.selectionsLock.readLock().lock();
 		try {
-			return selectedRows.isEmpty();
+			return this.selectedRows.isEmpty();
 		} finally {
-			selectionsLock.readLock().unlock();
+			this.selectionsLock.readLock().unlock();
 		}
 	}
-
+	
 	@Override
 	public List<Rectangle> getSelections() {
-		List<Rectangle> selectionRectangles = new ArrayList<Rectangle>();
-		
-		selectionsLock.readLock().lock();
-		
+		this.selectionsLock.readLock().lock();
 		try {
-			int width = selectionLayer.getColumnCount();
-			for (Serializable rowId : selectedRows.keySet()) {
-				int rowPosition = getRowPositionById(rowId);
+			final List<Rectangle> selectionRectangles = new ArrayList<Rectangle>();
+			final int width = this.selectionLayer.getColumnCount();
+			
+			for (final Serializable rowId : this.selectedRows.keySet()) {
+				final int rowPosition = getRowPositionById(rowId);
 				selectionRectangles.add(new Rectangle(0, rowPosition, width, 1));
 			}
+			
+			return selectionRectangles;
 		} finally {
-			selectionsLock.readLock().unlock();
+			this.selectionsLock.readLock().unlock();
 		}
-		
-		return selectionRectangles;
 	}
 	
 	// Cell features
-
+	
 	@Override
-	public boolean isCellPositionSelected(int columnPosition, int rowPosition) {
-		ILayerCell cell = selectionLayer.getCellByPosition(columnPosition, rowPosition);
-		int cellOriginRowPosition = cell.getOriginRowPosition();
+	public boolean isCellPositionSelected(final int columnPosition, final int rowPosition) {
+		final ILayerCell cell = this.selectionLayer.getCellByPosition(columnPosition, rowPosition);
+		final int cellOriginRowPosition = cell.getOriginRowPosition();
 		for (int testRowPosition = cellOriginRowPosition; testRowPosition < cellOriginRowPosition + cell.getRowSpan(); testRowPosition++) {
 			if (isRowPositionSelected(testRowPosition)) {
 				return true;
@@ -219,194 +226,178 @@
 	}
 	
 	// Column features
-
+	
 	@Override
-	public int[] getSelectedColumnPositions() {
-		if (!isEmpty()) {
-			selectionsLock.readLock().lock();
+	public RangeList getSelectedColumnPositions() {
+		this.selectionsLock.readLock().lock();
+		try {
+			final RangeList selected = new RangeList();
 			
-			int columnCount;
-			
-			try {
-				columnCount = selectionLayer.getColumnCount();
-			} finally {
-				selectionsLock.readLock().unlock();
+			if (!this.selectedRows.isEmpty()) {
+				selected.add(new Range(0, this.selectionLayer.getColumnCount()));
 			}
 			
-			int[] columns = new int[columnCount];
-			for (int i = 0; i < columnCount; i++) {
-				columns[i] = i;
-			}
-			return columns;
+			return selected;
+		} finally {
+			this.selectionsLock.readLock().unlock();
 		}
-		return new int[] {};
 	}
 	
 	@Override
-	public boolean isColumnPositionSelected(int columnPosition) {
-		selectionsLock.readLock().lock();
-
+	public boolean isColumnPositionSelected(final int columnPosition) {
+		this.selectionsLock.readLock().lock();
 		try {
-			return !selectedRows.isEmpty();
+			return !this.selectedRows.isEmpty();
 		} finally {
-			selectionsLock.readLock().unlock();
+			this.selectionsLock.readLock().unlock();
 		}
 	}
-
+	
 	@Override
-	public int[] getFullySelectedColumnPositions(int fullySelectedColumnRowCount) {
-		selectionsLock.readLock().lock();
-		
+	public RangeList getFullySelectedColumnPositions() {
+		this.selectionsLock.readLock().lock();
 		try {
-			if (isColumnPositionFullySelected(0, fullySelectedColumnRowCount)) {
-				return getSelectedColumnPositions();
+			final RangeList selected = new RangeList();
+			
+			if (isFullySelected()) {
+				selected.add(new Range(0, this.selectionLayer.getColumnCount()));
 			}
+			
+			return selected;
 		} finally {
-			selectionsLock.readLock().unlock();
+			this.selectionsLock.readLock().unlock();
 		}
-		
-		return new int[] {};
 	}
-
+	
 	@Override
-	public boolean isColumnPositionFullySelected(int columnPosition, int fullySelectedColumnRowCount) {
-		selectionsLock.readLock().lock();
-		
+	public boolean isColumnPositionFullySelected(final int columnPosition) {
+		this.selectionsLock.readLock().lock();
 		try {
-			int selectedRowCount = selectedRows.size();
-			
-			if (selectedRowCount == 0) {
-				return false;
-			}
-			
-			return selectedRowCount == fullySelectedColumnRowCount;
+			return isFullySelected();
 		} finally {
-			selectionsLock.readLock().unlock();
+			this.selectionsLock.readLock().unlock();
 		}
 	}
 	
+	private boolean isFullySelected() {
+		final int rowCount = this.selectionLayer.getRowCount();
+		final int selectedRowCount = this.selectedRows.size();
+		
+		return (rowCount > 0 && selectedRowCount == rowCount);
+	}
+	
 	// Row features
 	
 	@Override
 	public List<R> getSelectedRowObjects() {
-		final List<R> rowObjects = new ArrayList<R>();
-
 		this.selectionsLock.readLock().lock();
 		try {
-			rowObjects.addAll(this.selectedRows.values());
+			return new ArrayList<R>(this.selectedRows.values());
 		} finally {
 			this.selectionsLock.readLock().unlock();
 		}
-
-		return rowObjects;
 	}
-
+	
 	@Override
 	public int getSelectedRowCount() {
-		selectionsLock.readLock().lock();
-		
+		this.selectionsLock.readLock().lock();
 		try {
-			return selectedRows.size();
+			return this.selectedRows.size();
 		} finally {
-			selectionsLock.readLock().unlock();
+			this.selectionsLock.readLock().unlock();
 		}
 	}
-
+	
 	@Override
-	public Set<Range> getSelectedRowPositions() {
-		Set<Range> selectedRowRanges = new HashSet<Range>();
-		
-		selectionsLock.readLock().lock();
-		
+	public RangeList getSelectedRowPositions() {
+		this.selectionsLock.readLock().lock();
 		try {
-			for (Serializable rowId : selectedRows.keySet()) {
-				int rowPosition = getRowPositionById(rowId);
-				selectedRowRanges.add(new Range(rowPosition, rowPosition + 1));
+			final RangeList selected = new RangeList();
+			
+			for (final Serializable rowId : this.selectedRows.keySet()) {
+				selected.values().add(getRowPositionById(rowId));
 			}
+			
+			return selected;
 		} finally {
-			selectionsLock.readLock().unlock();
+			this.selectionsLock.readLock().unlock();
 		}
-		
-		return selectedRowRanges;
 	}
-
+	
 	@Override
-	public boolean isRowPositionSelected(int rowPosition) {
-		selectionsLock.readLock().lock();
-		
+	public boolean isRowPositionSelected(final int rowPosition) {
+		this.selectionsLock.readLock().lock();
 		try {
-			Serializable rowId = getRowIdByPosition(rowPosition);
-			return selectedRows.containsKey(rowId);
+			final Serializable rowId = getRowIdByPosition(rowPosition);
+			
+			return this.selectedRows.containsKey(rowId);
 		} finally {
-			selectionsLock.readLock().unlock();
+			this.selectionsLock.readLock().unlock();
 		}
 	}
-
+	
 	@Override
-	public int[] getFullySelectedRowPositions(int rowWidth) {
-		selectionsLock.readLock().lock();
-		
-		try {
-			int selectedRowCount = selectedRows.size();
-			int[] selectedRowPositions = new int[selectedRowCount];
-			int i = 0;
-			for (Serializable rowId : selectedRows.keySet()) {
-				selectedRowPositions[i] = getRowPositionById(rowId);
-				i++;
-			}
-			return selectedRowPositions;
-		} finally {
-			selectionsLock.readLock().unlock();
-		}
+	public RangeList getFullySelectedRowPositions() {
+		return getSelectedRowPositions();
 	}
-
+	
 	@Override
-	public boolean isRowPositionFullySelected(int rowPosition, int rowWidth) {
+	public boolean isRowPositionFullySelected(final int rowPosition) {
 		return isRowPositionSelected(rowPosition);
 	}
-
-	private Serializable getRowIdByPosition(int rowPosition) {
-		R rowObject = getRowObjectByPosition(rowPosition);
+	
+	private Serializable getRowIdByPosition(final int rowPosition) {
+		final R rowObject = getRowObjectByPosition(rowPosition);
 		if (rowObject != null) {
-			Serializable rowId = rowIdAccessor.getRowId(rowObject);
+			final Serializable rowId = this.rowIdAccessor.getRowId(rowObject);
 			return rowId;
 		}
 		return null;
 	}
-
-	private R getRowObjectByPosition(int rowPosition) {
-		selectionsLock.readLock().lock();
-		
+	
+	private R getRowObjectByPosition(final int rowPosition) {
+		this.selectionsLock.readLock().lock();
 		try {
-			int rowIndex = selectionLayer.getRowIndexByPosition(rowPosition);
+			final int rowIndex = this.selectionLayer.getRowIndexByPosition(rowPosition);
 			if (rowIndex >= 0) {
 				try {
-					R rowObject = rowDataProvider.getRowObject(rowIndex);
+					final R rowObject = this.rowDataProvider.getRowObject(rowIndex);
 					return rowObject;
-				} catch (Exception e) {
+				} catch (final Exception e) {
 					// row index is invalid for the data provider
 				}
 			}
 		} finally {
-			selectionsLock.readLock().unlock();
+			this.selectionsLock.readLock().unlock();
 		}
 		
 		return null;
 	}
 	
-	private int getRowPositionById(Serializable rowId) {
-		selectionsLock.readLock().lock();
-		
+	private int getRowPositionById(final Serializable rowId) {
+		this.selectionsLock.readLock().lock();
 		try {
-			R rowObject = selectedRows.get(rowId);
-			int rowIndex = rowDataProvider.indexOfRowObject(rowObject);
-			if(rowIndex == -1){
+			final R rowObject = this.selectedRows.get(rowId);
+			final int rowIndex = this.rowDataProvider.indexOfRowObject(rowObject);
+			if (rowIndex < 0) {
 				return -1;
 			}
-			int rowPosition = selectionLayer.getRowPositionByIndex(rowIndex);
-			return rowPosition;
+			
+			return this.selectionLayer.getRowPositionByIndex(rowIndex);
 		} finally {
-			selectionsLock.readLock().unlock();
+			this.selectionsLock.readLock().unlock();
+		}
+	}
+	
+	//-- Object methods --//
+	
+	@Override
+	public String toString() {
+		this.selectionsLock.readLock().lock();
+		try {
+			return this.selectedRows.toString();
+		} finally {
+			this.selectionsLock.readLock().unlock();
 		}
 	}
 	
diff --git a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/selection/RowSelectionProvider.java b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/selection/RowSelectionProvider.java
index cfacfe9..db91399 100644
--- a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/selection/RowSelectionProvider.java
+++ b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/selection/RowSelectionProvider.java
@@ -23,7 +23,7 @@
 import org.eclipse.jface.viewers.SelectionChangedEvent;
 import org.eclipse.jface.viewers.StructuredSelection;
 
-import org.eclipse.nebula.widgets.nattable.coordinate.Range;
+import org.eclipse.nebula.widgets.nattable.coordinate.IValueIterator;
 import org.eclipse.nebula.widgets.nattable.coordinate.RangeList;
 import org.eclipse.nebula.widgets.nattable.data.IRowDataProvider;
 import org.eclipse.nebula.widgets.nattable.layer.ILayerListener;
@@ -208,17 +208,10 @@
 		List<RowObjectIndexHolder<Object>> rows = new ArrayList<RowObjectIndexHolder<Object>>();
 
 		if (selectionLayer != null) {
-			if (fullySelectedRowsOnly) {
-				for (int rowPosition : selectionLayer.getFullySelectedRowPositions()) {
-					addToSelection(rows, rowPosition, selectionLayer, rowDataProvider);
-				}
-			} else {
-				Set<Range> rowRanges = selectionLayer.getSelectedRowPositions();
-				for (Range rowRange : rowRanges) {
-					for (int rowPosition = rowRange.start; rowPosition < rowRange.end; rowPosition++) {
-						addToSelection(rows, rowPosition, selectionLayer, rowDataProvider);
-					}
-				}
+			final RangeList selectedRows = (fullySelectedRowsOnly) ?
+					selectionLayer.getFullySelectedRowPositions() : selectionLayer.getSelectedRowPositions();
+			for (final IValueIterator rowIter = selectedRows.values().iterator(); rowIter.hasNext(); ) {
+				addToSelection(rows, rowIter.nextValue(), selectionLayer, rowDataProvider);
 			}
 		}
 		Collections.sort(rows);
diff --git a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/selection/SelectCellCommandHandler.java b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/selection/SelectCellCommandHandler.java
index 79da883..56a56cc 100644
--- a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/selection/SelectCellCommandHandler.java
+++ b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/selection/SelectCellCommandHandler.java
@@ -13,10 +13,11 @@
 import static org.eclipse.nebula.widgets.nattable.selection.SelectionUtils.isControlOnly;
 
 import org.eclipse.nebula.widgets.nattable.command.ILayerCommandHandler;
+import org.eclipse.nebula.widgets.nattable.coordinate.Rectangle;
 import org.eclipse.nebula.widgets.nattable.layer.ILayer;
 import org.eclipse.nebula.widgets.nattable.layer.cell.ILayerCell;
 import org.eclipse.nebula.widgets.nattable.selection.command.SelectCellCommand;
-import org.eclipse.swt.graphics.Rectangle;
+
 
 public class SelectCellCommandHandler implements ILayerCommandHandler<SelectCellCommand> {
 
@@ -68,7 +69,7 @@
 			selectionLayer.setLastSelectedCell(cell.getOriginColumnPosition(), cell.getOriginRowPosition());
 			
 			// Shift pressed + row selected
-			if (selectionLayer.getSelectionModel().isMultipleSelectionAllowed() 
+			if (selectionLayer.getSelectionModel().isMultipleSelectionAllowed()
 					&& withShiftMask 
 					&& selectionLayer.lastSelectedRegion != null 
 					&& selectionLayer.hasRowSelection()
diff --git a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/selection/SelectColumnCommandHandler.java b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/selection/SelectColumnCommandHandler.java
index 7e3897f..63322b0 100644
--- a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/selection/SelectColumnCommandHandler.java
+++ b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/selection/SelectColumnCommandHandler.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2012 Original authors and others.
+ * Copyright (c) 2012, 2013 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
@@ -16,10 +16,11 @@
 import static org.eclipse.nebula.widgets.nattable.selection.SelectionUtils.noShiftOrControl;
 
 import org.eclipse.nebula.widgets.nattable.command.ILayerCommandHandler;
+import org.eclipse.nebula.widgets.nattable.coordinate.RangeList;
+import org.eclipse.nebula.widgets.nattable.coordinate.Rectangle;
 import org.eclipse.nebula.widgets.nattable.layer.ILayer;
 import org.eclipse.nebula.widgets.nattable.selection.command.SelectColumnCommand;
 import org.eclipse.nebula.widgets.nattable.selection.event.ColumnSelectionEvent;
-import org.eclipse.swt.graphics.Rectangle;
 
 
 public class SelectColumnCommandHandler implements ILayerCommandHandler<SelectColumnCommand> {
@@ -57,7 +58,8 @@
 		selectionLayer.lastSelectedCell.columnPosition = columnPosition;
 		selectionLayer.lastSelectedCell.rowPosition = rowPosition;
 
-		selectionLayer.fireLayerEvent(new ColumnSelectionEvent(selectionLayer, columnPosition));
+		selectionLayer.fireLayerEvent(new ColumnSelectionEvent(selectionLayer,
+				new RangeList(columnPosition) ));
 	}
 
 	private void selectColumnWithCtrlKey(int columnPosition, int rowPosition) {
diff --git a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/selection/SelectRowCommandHandler.java b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/selection/SelectRowCommandHandler.java
index d458bb1..97d333a 100644
--- a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/selection/SelectRowCommandHandler.java
+++ b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/selection/SelectRowCommandHandler.java
@@ -19,13 +19,12 @@
 import java.util.HashSet;
 import java.util.Set;
 
-import org.eclipse.swt.graphics.Rectangle;
-
 import org.eclipse.nebula.widgets.nattable.command.ILayerCommandHandler;
 import org.eclipse.nebula.widgets.nattable.coordinate.IValueIterator;
 import org.eclipse.nebula.widgets.nattable.coordinate.Range;
 import org.eclipse.nebula.widgets.nattable.coordinate.RangeList;
 import org.eclipse.nebula.widgets.nattable.coordinate.RangeList.ValueIterator;
+import org.eclipse.nebula.widgets.nattable.coordinate.Rectangle;
 import org.eclipse.nebula.widgets.nattable.layer.ILayer;
 import org.eclipse.nebula.widgets.nattable.selection.command.SelectRowsCommand;
 import org.eclipse.nebula.widgets.nattable.selection.event.RowSelectionEvent;
@@ -49,19 +48,13 @@
 	}
 
 	protected void selectRows(int columnPosition, Collection<Range> rowPositions, boolean withShiftMask, boolean withControlMask, int rowPositionToMoveIntoViewport) {
-		final RangeList changedRowRanges = new RangeList();
+		final RangeList changedRows = new RangeList();
 		
 		for (final IValueIterator rowIter = new ValueIterator(rowPositions); rowIter.hasNext(); ) {
-			changedRowRanges.addAll(internalSelectRow(columnPosition, rowIter.nextValue(),
+			changedRows.addAll(internalSelectRow(columnPosition, rowIter.nextValue(),
 					withShiftMask, withControlMask ));
 		}
-
-		Set<Integer> changedRows = new HashSet<Integer>();
-		for (Range range : changedRowRanges) {
-			for (int i = range.start; i < range.end; i++) {
-				changedRows.add(Integer.valueOf(i));
-			}
-		}
+		
 		selectionLayer.fireLayerEvent(new RowSelectionEvent(selectionLayer, changedRows, rowPositionToMoveIntoViewport));
 	}
 
diff --git a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/selection/SelectRowGroupCommandHandler.java b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/selection/SelectRowGroupCommandHandler.java
index 9411cb3..96dc1cf 100644
--- a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/selection/SelectRowGroupCommandHandler.java
+++ b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/selection/SelectRowGroupCommandHandler.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2012 Original authors and others.
+ * Copyright (c) 2012, 2013 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
@@ -22,13 +22,15 @@
 
 import org.eclipse.nebula.widgets.nattable.command.AbstractLayerCommandHandler;
 import org.eclipse.nebula.widgets.nattable.coordinate.Range;
+import org.eclipse.nebula.widgets.nattable.coordinate.RangeList;
+import org.eclipse.nebula.widgets.nattable.coordinate.Rectangle;
 import org.eclipse.nebula.widgets.nattable.group.RowGroupHeaderLayer;
 import org.eclipse.nebula.widgets.nattable.group.RowGroupUtils;
 import org.eclipse.nebula.widgets.nattable.group.model.IRowGroupModel;
 import org.eclipse.nebula.widgets.nattable.selection.command.SelectRowGroupsCommand;
 import org.eclipse.nebula.widgets.nattable.selection.event.RowSelectionEvent;
 import org.eclipse.nebula.widgets.nattable.util.ObjectUtils;
-import org.eclipse.swt.graphics.Rectangle;
+
 
 public class SelectRowGroupCommandHandler<T> extends AbstractLayerCommandHandler<SelectRowGroupsCommand> {
 
@@ -56,18 +58,12 @@
 	}
 	
 	protected void selectRows(int columnPosition, List<Integer> rowPositions, boolean withShiftMask, boolean withControlMask, int rowPositionToMoveIntoViewport, boolean moveAnchorToTopOfGroup) {
-		Set<Range> changedRowRanges = new HashSet<Range>();
+		RangeList changedRows = new RangeList();
 		
-		if( rowPositions.size() > 0 ) {
-			changedRowRanges.addAll(internalSelectRow(columnPosition, rowPositions.get(0), rowPositions.size(), withShiftMask, withControlMask, moveAnchorToTopOfGroup));
+		if (rowPositions.size() > 0) {
+			changedRows.addAll(internalSelectRow(columnPosition, rowPositions.get(0), rowPositions.size(), withShiftMask, withControlMask, moveAnchorToTopOfGroup));
 		}
-
-		Set<Integer> changedRows = new HashSet<Integer>();
-		for (Range range : changedRowRanges) {
-			for (int i = range.start; i < range.end; i++) {
-				changedRows.add(Integer.valueOf(i));
-			}
-		}
+		
 		selectionLayer.fireLayerEvent(new RowSelectionEvent(selectionLayer, changedRows, rowPositionToMoveIntoViewport));
 	}
 	
@@ -114,28 +110,25 @@
 			selectionLayer.selectRegion(0, rowPosition, selectionLayer.getColumnCount(), rowCount);
 		}
 		
-		return new Range(rowPosition, rowPosition + 1);
+		return new Range(rowPosition);
 	}
 
 	private Range selectRowWithShiftKey(int columnPosition, int rowPosition, int rowCount) {
 		if (selectionLayer.lastSelectedRegion != null) {
 			int start = Math.min(selectionLayer.lastSelectedRegion.y, rowPosition);
 			int end = Math.max(selectionLayer.lastSelectedRegion.y, rowPosition);
-		
-		
-		for(int i = start; i <= end; i++){
-			int index = selectionLayer.getRowIndexByPosition(i);
-			if(RowGroupUtils.isPartOfAGroup(model, index) && !selectionLayer.isRowPositionFullySelected(i)){
-				List <Integer> rowPositions = new ArrayList<Integer>(RowGroupUtils.getRowPositionsInGroup(selectionLayer, RowGroupUtils.getRowIndexesInGroup(model, index)));
-				Collections.sort(rowPositions);
-				selectionLayer.selectRegion(0, rowPositions.get(0), selectionLayer.getColumnCount(), rowPositions.size());
-				i=ObjectUtils.getLastElement(rowPositions);
+			
+			for (int i = start; i <= end; i++){
+				int index = selectionLayer.getRowIndexByPosition(i);
+				if (RowGroupUtils.isPartOfAGroup(model, index) && !selectionLayer.isRowPositionFullySelected(i)){
+					List<Integer> rowPositions = new ArrayList<Integer>(RowGroupUtils.getRowPositionsInGroup(selectionLayer, RowGroupUtils.getRowIndexesInGroup(model, index)));
+					Collections.sort(rowPositions);
+					selectionLayer.selectRegion(0, rowPositions.get(0), selectionLayer.getColumnCount(), rowPositions.size());
+					i=ObjectUtils.getLastElement(rowPositions);
+				}
 			}
 		}
-		
-		
-		}
-		return new Range(rowPosition, rowPosition + 1);
+		return new Range(rowPosition);
 	}
-		
+	
 }
diff --git a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/selection/SelectionLayer.java b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/selection/SelectionLayer.java
index 9d1fa3c..557b009 100644
--- a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/selection/SelectionLayer.java
+++ b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/selection/SelectionLayer.java
@@ -16,15 +16,12 @@
 import java.util.List;
 import java.util.Set;
 
-import org.eclipse.swt.graphics.Point;
-import org.eclipse.swt.graphics.Rectangle;
-
 import org.eclipse.nebula.widgets.nattable.command.ILayerCommand;
 import org.eclipse.nebula.widgets.nattable.coordinate.IValueIterator;
 import org.eclipse.nebula.widgets.nattable.coordinate.PositionCoordinate;
-import org.eclipse.nebula.widgets.nattable.coordinate.Range;
 import org.eclipse.nebula.widgets.nattable.coordinate.RangeList;
 import org.eclipse.nebula.widgets.nattable.coordinate.RangeList.ValueIterator;
+import org.eclipse.nebula.widgets.nattable.coordinate.Rectangle;
 import org.eclipse.nebula.widgets.nattable.copy.command.CopyDataCommandHandler;
 import org.eclipse.nebula.widgets.nattable.edit.command.EditSelectionCommandHandler;
 import org.eclipse.nebula.widgets.nattable.grid.command.InitializeAutoResizeColumnsCommandHandler;
@@ -33,9 +30,9 @@
 import org.eclipse.nebula.widgets.nattable.hideshow.command.MultiColumnHideCommand;
 import org.eclipse.nebula.widgets.nattable.hideshow.command.MultiRowHideCommand;
 import org.eclipse.nebula.widgets.nattable.hideshow.command.RowHideCommand;
-import org.eclipse.nebula.widgets.nattable.layer.AbstractIndexLayerTransform;
 import org.eclipse.nebula.widgets.nattable.layer.IUniqueIndexLayer;
 import org.eclipse.nebula.widgets.nattable.layer.LabelStack;
+import org.eclipse.nebula.widgets.nattable.layer.TransformIndexLayer;
 import org.eclipse.nebula.widgets.nattable.layer.cell.ILayerCell;
 import org.eclipse.nebula.widgets.nattable.painter.layer.ILayerPainter;
 import org.eclipse.nebula.widgets.nattable.resize.command.ColumnResizeCommand;
@@ -59,7 +56,7 @@
  * @see DefaultSelectionLayerConfiguration
  * @see MoveDirectionEnum
  */
-public class SelectionLayer extends AbstractIndexLayerTransform {
+public class SelectionLayer extends TransformIndexLayer {
 
 	public static final int MOVE_ALL = -1;
 	public static final int NO_SELECTION = -1;
@@ -168,8 +165,7 @@
 		
 		//if the selection anchor is within the selection that is removed
 		//it needs to be cleared also
-		Point anchorPoint = new Point(selectionAnchor.columnPosition, selectionAnchor.rowPosition);
-		if (selection.contains(anchorPoint)) {
+		if (selection.contains(selectionAnchor.columnPosition, selectionAnchor.rowPosition)) {
 			selectionAnchor.columnPosition = -1;
 			selectionAnchor.rowPosition = -1;
 		}
@@ -202,27 +198,27 @@
 	protected PositionCoordinate getCellPositionToMoveFrom(boolean withShiftMask, boolean withControlMask) {
 		return (!withShiftMask && !withControlMask)	? getSelectionAnchor() : getLastSelectedCellPosition();
 	}
-
-	public PositionCoordinate[] getSelectedCellPositions() {
-		int[] selectedColumnPositions = getSelectedColumnPositions();
-		Set<Range> selectedRowPositions = getSelectedRowPositions();
-
-		List<PositionCoordinate> selectedCells = new LinkedList<PositionCoordinate>();
-
-		for (int columnPositionIndex = 0; columnPositionIndex < selectedColumnPositions.length; columnPositionIndex++) {
-			final int columnPosition = selectedColumnPositions[columnPositionIndex];
-
-			for (Range rowIndexRange : selectedRowPositions) {
-				for (int rowPositionIndex = rowIndexRange.start; rowPositionIndex < rowIndexRange.end; rowPositionIndex++) {
-					if (selectionModel.isCellPositionSelected(columnPosition, rowPositionIndex)) {
-						selectedCells.add(new PositionCoordinate(this, columnPosition, rowPositionIndex));
-					}
+	
+	public List<PositionCoordinate> getSelectedCellPositions() {
+		final RangeList selectedColumnPositions = getSelectedColumnPositions();
+		final RangeList selectedRowPositions = getSelectedRowPositions();
+		
+		final List<PositionCoordinate> selectedCells = new LinkedList<PositionCoordinate>();
+		
+		for (final IValueIterator columnIter = selectedColumnPositions.values().iterator(); columnIter.hasNext(); ) {
+			final int columnPosition = columnIter.nextValue();
+			for (final IValueIterator rowIter = selectedRowPositions.values().iterator(); rowIter.hasNext(); ) {
+				final int rowPosition = rowIter.nextValue();
+				
+				if (selectionModel.isCellPositionSelected(columnPosition, rowPosition)) {
+					selectedCells.add(new PositionCoordinate(this, columnPosition, rowPosition));
 				}
 			}
 		}
-		return selectedCells.toArray(new PositionCoordinate[0]);
+		
+		return selectedCells;
 	}
-
+	
 	/**
 	 * Retrieves the ILayerCells out of the SelectionLayer that are currently marked as selected in
 	 * the SelectionModel. Takes spanning into account.
@@ -231,7 +227,7 @@
 	public Collection<ILayerCell> getSelectedCells() {
 		Set<ILayerCell> selectedCells = new HashSet<ILayerCell>();
 
-		PositionCoordinate[] selectedCoords = getSelectedCellPositions();
+		List<PositionCoordinate> selectedCoords = getSelectedCellPositions();
 		for (PositionCoordinate coord : selectedCoords) {
 			selectedCells.add(getCellByPosition(coord.columnPosition, coord.rowPosition));
 		}
@@ -294,7 +290,7 @@
 		return lastSelectedCell.columnPosition != NO_SELECTION;
 	}
 
-	public int[] getSelectedColumnPositions() {
+	public RangeList getSelectedColumnPositions() {
 		return selectionModel.getSelectedColumnPositions();
 	}
 
@@ -302,12 +298,12 @@
 		return selectionModel.isColumnPositionSelected(columnPosition);
 	}
 
-	public int[] getFullySelectedColumnPositions() {
-		return selectionModel.getFullySelectedColumnPositions(getRowCount());
+	public RangeList getFullySelectedColumnPositions() {
+		return selectionModel.getFullySelectedColumnPositions();
 	}
 
 	public boolean isColumnPositionFullySelected(int columnPosition) {
-		return selectionModel.isColumnPositionFullySelected(columnPosition, getRowCount());
+		return selectionModel.isColumnPositionFullySelected(columnPosition);
 	}
 
 	public void selectColumn(int columnPosition, int rowPosition, boolean withShiftMask, boolean withControlMask) {
@@ -324,7 +320,7 @@
 		return selectionModel.getSelectedRowCount();
 	}
 
-	public Set<Range> getSelectedRowPositions() {
+	public RangeList getSelectedRowPositions() {
 		return selectionModel.getSelectedRowPositions();
 	}
 
@@ -332,12 +328,12 @@
 		return selectionModel.isRowPositionSelected(rowPosition);
 	}
 
-	public int[] getFullySelectedRowPositions() {
-		return selectionModel.getFullySelectedRowPositions(getColumnCount());
+	public RangeList getFullySelectedRowPositions() {
+		return selectionModel.getFullySelectedRowPositions();
 	}
 
 	public boolean isRowPositionFullySelected(int rowPosition) {
-		return selectionModel.isRowPositionFullySelected(rowPosition, getColumnCount());
+		return selectionModel.isRowPositionFullySelected(rowPosition);
 	}
 
 	public void selectRow(int columnPosition, int rowPosition, boolean withShiftMask, boolean withControlMask) {
@@ -361,8 +357,7 @@
 		
 		ILayerCell cell = getCellByPosition(columnPosition, rowPosition);
 		if (cell != null) {
-			Rectangle cellRectangle =
-					new Rectangle(
+			Rectangle cellRectangle = new Rectangle(
 							cell.getOriginColumnPosition(),
 							cell.getOriginRowPosition(),
 							cell.getColumnSpan(),
@@ -418,10 +413,8 @@
 
 	public void fireCellSelectionEvent(int columnPosition, int rowPosition,
 			boolean forcingEntireCellIntoViewport, boolean withShiftMask, boolean withControlMask) {
-
-		final CellSelectionEvent selectionEvent = new CellSelectionEvent(this, columnPosition, rowPosition,
-				withShiftMask, withControlMask);
-		fireLayerEvent(selectionEvent);
+		fireLayerEvent(new CellSelectionEvent(this, columnPosition, rowPosition,
+				withShiftMask, withControlMask ));
 	}
 	
 	// command transformations
@@ -443,8 +436,8 @@
 	 */
 	protected boolean handleColumnHideCommand(ColumnHideCommand command) {
 		if (isColumnPositionFullySelected(command.getColumnPosition())) {
-			return handleMultiColumnHideCommand(
-					new MultiColumnHideCommand(this, new RangeList(getFullySelectedColumnPositions())));
+			return handleMultiColumnHideCommand(new MultiColumnHideCommand(this,
+					getFullySelectedColumnPositions()) );
 		} else {
 			return super.doCommand(command);
 		}
@@ -487,8 +480,8 @@
 	 */
 	protected boolean handleRowHideCommand(RowHideCommand command) {
 		if (isRowPositionFullySelected(command.getRowPosition())) {
-			return handleMultiRowHideCommand(
-					new MultiRowHideCommand(this, new RangeList(getFullySelectedRowPositions())));
+			return handleMultiRowHideCommand(new MultiRowHideCommand(this,
+					getFullySelectedRowPositions()) );
 		} else {
 			return super.doCommand(command);
 		}
@@ -530,8 +523,8 @@
 	 */
 	protected boolean handleColumnResizeCommand(ColumnResizeCommand command) {
 		if (isColumnPositionFullySelected(command.getColumnPosition())) {
-			return super.doCommand(
-					new MultiColumnResizeCommand(this, new RangeList(selectionModel.getFullySelectedColumnPositions(getRowCount())), command.getNewColumnWidth()));
+			return super.doCommand(new MultiColumnResizeCommand(this,
+					selectionModel.getFullySelectedColumnPositions(), command.getNewColumnWidth()));
 		} else {
 			return super.doCommand(command);
 		}
@@ -553,8 +546,8 @@
 	 */
 	protected boolean handleRowResizeCommand(RowResizeCommand command) {
 		if (isRowPositionFullySelected(command.getRowPosition())) {
-			return super.doCommand(
-					new MultiRowResizeCommand(this, new RangeList(selectionModel.getFullySelectedRowPositions(getColumnCount())), command.getNewHeight()));
+			return super.doCommand(new MultiRowResizeCommand(this,
+					selectionModel.getFullySelectedRowPositions(), command.getNewHeight()) );
 		} else {
 			return super.doCommand(command);
 		}
diff --git a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/selection/SelectionModel.java b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/selection/SelectionModel.java
index 1dbb3c2..ddc9ba6 100644
--- a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/selection/SelectionModel.java
+++ b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/selection/SelectionModel.java
@@ -11,21 +11,17 @@
 package org.eclipse.nebula.widgets.nattable.selection;
 
 import java.util.ArrayList;
-import java.util.Collections;
-import java.util.Comparator;
-import java.util.HashSet;
 import java.util.LinkedList;
 import java.util.List;
-import java.util.Set;
-import java.util.TreeSet;
 import java.util.concurrent.locks.ReadWriteLock;
 import java.util.concurrent.locks.ReentrantReadWriteLock;
 
-import org.apache.commons.lang.ArrayUtils;
 import org.eclipse.nebula.widgets.nattable.coordinate.Range;
+import org.eclipse.nebula.widgets.nattable.coordinate.RangeList;
+import org.eclipse.nebula.widgets.nattable.coordinate.Rectangle;
+import org.eclipse.nebula.widgets.nattable.layer.ILayer;
 import org.eclipse.nebula.widgets.nattable.layer.cell.ILayerCell;
-import org.eclipse.nebula.widgets.nattable.util.ObjectUtils;
-import org.eclipse.swt.graphics.Rectangle;
+
 
 /**
  * Tracks the selections made in the table. All selections are tracked in terms of
@@ -39,65 +35,110 @@
  * @see SelectionLayer
  */
 public class SelectionModel implements ISelectionModel {
-
-	private final SelectionLayer selectionLayer;
+	
+	
+	//-- Utility --//
+	
+	private static final Rectangle getLeftSelection(final Rectangle intersection, final Rectangle selection) {
+		if (intersection.x > selection.x) {
+			return new Rectangle(selection.x, selection.y,
+					intersection.x - selection.x, selection.height);
+		}
+		return null;
+	}
+	
+	private static final Rectangle getRightSelection(final Rectangle intersection, final Rectangle selection) {
+		final int newX = intersection.x + intersection.width;
+		if (newX < selection.x + selection.width) {
+			return new Rectangle(newX, selection.y,
+					selection.x + selection.width - newX, selection.height);
+		}
+		return null;
+	}
+	
+	private static final Rectangle getTopSelection(final Rectangle intersection, final Rectangle selection) {
+		if (intersection.y > selection.y) {
+			return new Rectangle(selection.x, selection.y,
+					selection.width, intersection.y - selection.y);
+		}
+		return null;
+	}
+	
+	private static final Rectangle getBottomSelection(final Rectangle intersection, final Rectangle selection) {
+		final int newY = intersection.y + intersection.height;
+		if (newY < selection.y + selection.height) {
+			return new Rectangle(selection.x, newY,
+					selection.width, selection.y + selection.height - newY);
+		}
+		return null;
+	}
+	
+	
+	private final ILayer selectionLayer;
+	
 	private boolean multipleSelectionAllowed;
 	
 	private final List<Rectangle> selections;
 	private final ReadWriteLock selectionsLock;
-
-	public SelectionModel(SelectionLayer selectionLayer) {
+	
+	
+	public SelectionModel(/*@NotNull*/ final ILayer selectionLayer) {
 		this(selectionLayer, true);
 	}
 	
-	public SelectionModel(SelectionLayer selectionLayer, boolean multipleSelectionAllowed) {
+	public SelectionModel(/*@NotNull*/ final ILayer selectionLayer, final boolean multipleSelectionAllowed) {
+		if (selectionLayer == null) {
+			throw new NullPointerException("selectionLayer"); //$NON-NLS-1$
+		}
 		this.selectionLayer = selectionLayer;
 		this.multipleSelectionAllowed = multipleSelectionAllowed;
 		
-		selections = new LinkedList<Rectangle>();
-		selectionsLock = new ReentrantReadWriteLock();
+		this.selections = new LinkedList<Rectangle>();
+		this.selectionsLock = new ReentrantReadWriteLock();
 	}
-
+	
+	
 	@Override
 	public boolean isMultipleSelectionAllowed() {
-		return multipleSelectionAllowed;
+		return this.multipleSelectionAllowed;
 	}
 	
 	@Override
-	public void setMultipleSelectionAllowed(boolean multipleSelectionAllowed) {
+	public void setMultipleSelectionAllowed(final boolean multipleSelectionAllowed) {
 		this.multipleSelectionAllowed = multipleSelectionAllowed;
 	}
 	
+	
 	@Override
-	public void addSelection(int columnPosition, int rowPosition) {
+	public void addSelection(final int columnPosition, final int rowPosition) {
 		addSelectionIntoList(new Rectangle(columnPosition, rowPosition, 1, 1));
 	}
-
+	
 	@Override
-	public void addSelection(final Rectangle range) {
-		if (range != null) {
-			addSelectionIntoList(range);
+	public void addSelection(final Rectangle positions) {
+		if (positions != null) {
+			addSelectionIntoList(positions);
 		}
-
 	}
-
-	private void addSelectionIntoList(Rectangle selection) {
-		selectionsLock.writeLock().lock();
+	
+	private void addSelectionIntoList(final Rectangle selection) {
+		this.selectionsLock.writeLock().lock();
 		try {
-			if (multipleSelectionAllowed) {
+			if (this.multipleSelectionAllowed) {
 				ArrayList<Rectangle> itemsToRemove = null;
-				for (Rectangle r : selections) {
+				for (final Rectangle r : this.selections) {
 					if (selection.intersects(r)) {
 						if (r.equals(selection)) {
 							break;
 						}
-	
-						Rectangle intersection = selection.intersection(r);
+						
+						final Rectangle intersection = selection.intersection(r);
 						if (intersection.equals(r)) {
 							// r is a subset of intersection
-							if (itemsToRemove == null)
+							if (itemsToRemove == null) {
 								itemsToRemove = new ArrayList<Rectangle>();
-	
+							}
+							
 							itemsToRemove.add(r);
 						} else if (intersection.equals(selection)) {
 							// selection is a subset of r
@@ -105,461 +146,336 @@
 						}
 					}
 				}
-	
+				
 				if (itemsToRemove != null) {
-					selections.removeAll(itemsToRemove);
+					this.selections.removeAll(itemsToRemove);
 				}
 			} else {
-				selections.clear();
+				this.selections.clear();
 				//as no multiple selection is allowed, ensure that only one column 
 				//and one row will be selected
 				selection.height = 1;
 				selection.width = 1;
 			}
-
-			selections.add(selection);
+			
+			this.selections.add(selection);
 		} finally {
-			selectionsLock.writeLock().unlock();
+			this.selectionsLock.writeLock().unlock();
 		}
-
 	}
-
+	
 	@Override
 	public void clearSelection() {
-		selectionsLock.writeLock().lock();
+		this.selectionsLock.writeLock().lock();
 		try {
-			selections.clear();
+			this.selections.clear();
 		} finally {
-			selectionsLock.writeLock().unlock();
+			this.selectionsLock.writeLock().unlock();
 		}
 	}
-
+	
 	@Override
-	public void clearSelection(int columnPosition, int rowPosition) {
+	public void clearSelection(final int columnPosition, final int rowPosition) {
 		clearSelection(new Rectangle(columnPosition, rowPosition, 1, 1));
 	}
-
+	
 	@Override
-	public void clearSelection(Rectangle removedSelection) {
-
-		List<Rectangle> removedItems = new LinkedList<Rectangle>();
-		List<Rectangle> addedItems = new LinkedList<Rectangle>();
-
-		selectionsLock.readLock().lock();
-
+	public void clearSelection(final Rectangle positions) {
+		final List<Rectangle> removedItems = new LinkedList<Rectangle>();
+		final List<Rectangle> addedItems = new LinkedList<Rectangle>();
+		
+		this.selectionsLock.readLock().lock();
 		try {
-			for (Rectangle r : selections) {
-				if (r.intersects(removedSelection)) {
-					Rectangle intersection = removedSelection.intersection(r);
+			for (final Rectangle r : this.selections) {
+				if (r.intersects(positions)) {
+					final Rectangle intersection = positions.intersection(r);
 					removedItems.add(r);
-
-					Rectangle topSelection = getTopSelection(intersection, r);
+					
+					final Rectangle topSelection = getTopSelection(intersection, r);
 					if (topSelection != null) {
 						addedItems.add(topSelection);
 					}
-
-					Rectangle rightSelection = getRightSelection(intersection, r);
-					if (rightSelection != null)
+					final Rectangle rightSelection = getRightSelection(intersection, r);
+					if (rightSelection != null) {
 						addedItems.add(rightSelection);
-
-					Rectangle leftSelection = getLeftSelection(intersection, r);
-					if (leftSelection != null)
+					}
+					final Rectangle leftSelection = getLeftSelection(intersection, r);
+					if (leftSelection != null) {
 						addedItems.add(leftSelection);
-
-					Rectangle bottomSelection = getBottomSelection(intersection, r);
-					if (bottomSelection != null)
+					}
+					final Rectangle bottomSelection = getBottomSelection(intersection, r);
+					if (bottomSelection != null) {
 						addedItems.add(bottomSelection);
+					}
 				}
 			}
 		} finally {
-			selectionsLock.readLock().unlock();
+			this.selectionsLock.readLock().unlock();
 		}
-
+		
 		if (removedItems.size() > 0) {
-			selectionsLock.writeLock().lock();
+			this.selectionsLock.writeLock().lock();
 			try {
-				selections.removeAll(removedItems);
+				this.selections.removeAll(removedItems);
 			} finally {
-				selectionsLock.writeLock().unlock();
+				this.selectionsLock.writeLock().unlock();
 			}
-
+			
 			removedItems.clear();
 		}
-
+		
 		if (addedItems.size() > 0) {
-			selectionsLock.writeLock().lock();
+			this.selectionsLock.writeLock().lock();
 			try {
-				selections.addAll(addedItems);
+				this.selections.addAll(addedItems);
 			} finally {
-				selectionsLock.writeLock().unlock();
+				this.selectionsLock.writeLock().unlock();
 			}
-
+			
 			addedItems.clear();
 		}
-
 	}
-
+	
+	
 	@Override
 	public boolean isEmpty() {
-		selectionsLock.readLock().lock();
+		this.selectionsLock.readLock().lock();
 		try {
-			return selections.isEmpty();
+			return this.selections.isEmpty();
 		} finally {
-			selectionsLock.readLock().unlock();
+			this.selectionsLock.readLock().unlock();
 		}
 	}
-
+	
 	@Override
 	public List<Rectangle> getSelections() {
-		return selections;
+		return this.selections;
 	}
 	
 	// Cell features
-
+	
 	@Override
-	public boolean isCellPositionSelected(int columnPosition, int rowPosition) {
-		selectionsLock.readLock().lock();
-
+	public boolean isCellPositionSelected(final int columnPosition, final int rowPosition) {
+		this.selectionsLock.readLock().lock();
 		try {
-			ILayerCell cell = selectionLayer.getCellByPosition(columnPosition, rowPosition);
-			Rectangle cellRectangle =
-					new Rectangle(
-							cell.getOriginColumnPosition(),
-							cell.getOriginRowPosition(),
-							cell.getColumnSpan(),
-							cell.getRowSpan());
+			final ILayerCell cell = this.selectionLayer.getCellByPosition(columnPosition, rowPosition);
+			final Rectangle cellRectangle = new Rectangle(
+					cell.getOriginColumnPosition(),
+					cell.getOriginRowPosition(),
+					cell.getColumnSpan(),
+					cell.getRowSpan());
 			
-			for (Rectangle selectionRectangle : selections) {
-				if (selectionRectangle.intersects(cellRectangle))
+			for (final Rectangle selectionRectangle : this.selections) {
+				if (selectionRectangle.intersects(cellRectangle)) {
 					return true;
+				}
 			}
+			
+			return false;
 		} finally {
-			selectionsLock.readLock().unlock();
+			this.selectionsLock.readLock().unlock();
 		}
-
-		return false;
 	}
 	
 	// Column features
-
-	@Override
-	public int[] getSelectedColumnPositions() {
-		TreeSet<Integer> selectedColumns = new TreeSet<Integer>();
-
-		selectionsLock.readLock().lock();
-
-		int columnCount = selectionLayer.getColumnCount();
-		try {
-			for (Rectangle r : selections) {
-				int startColumn = r.x;
-				if (startColumn < columnCount) {
-					int numColumns = (r.x + r.width <= columnCount) ? r.width : columnCount - r.x;
 	
-					// Change from row < startRow to row < startRow+numRows
-					for (int column = startColumn; column < startColumn + numColumns; column++) {
-						selectedColumns.add(Integer.valueOf(column));
-					}
+	@Override
+	public RangeList getSelectedColumnPositions() {
+		this.selectionsLock.readLock().lock();
+		try {
+			final RangeList selected = new RangeList();
+			final int columnCount = this.selectionLayer.getColumnCount();
+			
+			for (final Rectangle r : this.selections) {
+				if (r.x < columnCount) {
+					selected.add(new Range(r.x, Math.min(r.x + r.width, columnCount)));
 				}
 			}
+			
+			return selected;
 		} finally {
-			selectionsLock.readLock().unlock();
+			this.selectionsLock.readLock().unlock();
 		}
-
-		// Convert to array
-		return ObjectUtils.asIntArray(selectedColumns);
 	}
 	
 	@Override
-	public boolean isColumnPositionSelected(int columnPosition) {
-		selectionsLock.readLock().lock();
-
+	public boolean isColumnPositionSelected(final int columnPosition) {
+		this.selectionsLock.readLock().lock();
 		try {
-			for (int column : getSelectedColumnPositions()) {
-				if (column == columnPosition) {
-					return true;
-				}
-			}
-		} finally {
-			selectionsLock.readLock().unlock();
-		}
-
-		return false;
-	}
-
-	@Override
-	public int[] getFullySelectedColumnPositions(int columnHeight) {
-		final int[] selectedColumns = getSelectedColumnPositions();
-		int[] columnsToHide = new int[selectedColumns.length];
-		int index = 0;
-		for (int columnPosition : selectedColumns) {
-			if (isColumnPositionFullySelected(columnPosition, columnHeight)) {
-				columnsToHide[index++] = columnPosition;
-			}
-		}
-
-		return index > 0  ? ArrayUtils.subarray(columnsToHide, 0, index) : new int[0];
-	}
-
-	/**
-	 * Are all cells in this column selected?
-	 * Different selection rectangles might aggregate to cover the entire column.
-	 * We need to take into account any overlapping selections or any selection rectangles
-	 * contained within each other.
-	 * 
-	 * See the related tests for a better understanding.
-	 */
-	@Override
-	public boolean isColumnPositionFullySelected(int columnPosition, int columnHeight) {
-		selectionsLock.readLock().lock();
-
-		try {
-			// Aggregate all rectangles in the column which are in the selection model
-			List<Rectangle> selectedRectanglesInColumn = new ArrayList<Rectangle>();
-
-			// If X is same add up the height of the selected area
-			for (Rectangle r : selections) {
-				// Column is within the bounds of the selcted rectangle
-				if (columnPosition >= r.x && columnPosition < r.x + r.width) {
-					selectedRectanglesInColumn.add(new Rectangle(columnPosition, r.y, 1, r.height));
-				}
-			}
-			if (selectedRectanglesInColumn.isEmpty()) {
-				return false;
-			}
-			sortByY(selectedRectanglesInColumn);
-			Rectangle finalRectangle = new Rectangle(columnPosition, selectedRectanglesInColumn.get(0).y, 0, 0);
-
-			// Ensure that selections in the column are contiguous and cover the entire column
-			for (int i = 0; i < selectedRectanglesInColumn.size(); i++) {
-				Rectangle rectangle = selectedRectanglesInColumn.get(i);
-				if(contains(finalRectangle, rectangle)){
-					continue;
-				}
-				if (i > 0) {
-					Rectangle previousRect = selectedRectanglesInColumn.get(i - 1);
-					if (rectangle.union(previousRect).height > (rectangle.height + previousRect.height)) {
-						// Rectangles not contiguous
-						return false;
+			final int columnCount = this.selectionLayer.getColumnCount();
+			
+			if (columnPosition >= 0 && columnPosition < columnCount) {
+				for (final Rectangle r : this.selections) {
+					if (columnPosition >= r.x && columnPosition < r.x + r.width) {
+						return true;
 					}
 				}
-				// Union will resolve any overlaping area
-				finalRectangle = finalRectangle.union(rectangle);
 			}
-			return finalRectangle.height >= columnHeight;
+			
+			return false;
 		} finally {
-			selectionsLock.readLock().unlock();
+			this.selectionsLock.readLock().unlock();
 		}
 	}
 	
+	@Override
+	public RangeList getFullySelectedColumnPositions() {
+		this.selectionsLock.readLock().lock();
+		try {
+			final RangeList selected = new RangeList();
+			final int rowCount = this.selectionLayer.getRowCount();
+			
+			if (rowCount > 0) {
+				final RangeList selectedColumns = getSelectedColumnPositions();
+				for (final Range range : selectedColumns) {
+					for (int position = range.start; position < range.end; position++) {
+						if (isColumnPositionFullySelected(position, rowCount)) {
+							selected.values().add(position);
+						}
+					}
+				}
+			}
+			
+			return selected;
+		} finally {
+			this.selectionsLock.readLock().unlock();
+		}
+	}
+	
+	@Override
+	public boolean isColumnPositionFullySelected(final int columnPosition) {
+		this.selectionsLock.readLock().lock();
+		try {
+			final int rowCount = this.selectionLayer.getRowCount();
+			
+			return ((rowCount > 0)
+					&& isColumnPositionFullySelected(columnPosition, rowCount) );
+		} finally {
+			this.selectionsLock.readLock().unlock();
+		}
+	}
+	
+	private boolean isColumnPositionFullySelected(final int columnPosition, final int rowCount) {
+		// Aggregate all rows of selection rectangles including the column
+		final RangeList selectedRowsInColumn = new RangeList();
+		
+		for (final Rectangle r : this.selections) {
+			if (columnPosition >= r.x && columnPosition < r.x + r.width) {
+				selectedRowsInColumn.add(new Range(r.y, r.y + r.height));
+			}
+		}
+		
+		final Range range = selectedRowsInColumn.values().getRangeOf(0);
+		return (range != null && range.end >= rowCount);
+	}
+	
 	// Row features
-
+	
 	@Override
 	public int getSelectedRowCount() {
-		Set<Range> selectedRows = getSelectedRowPositions();
-		int count = 0;
-		for (Range range : selectedRows) {
-			count += range.end - range.start;
-		}
-		return count;
+		return getSelectedRowPositions().values().size();
 	}
-
+	
 	@Override
-	public Set<Range> getSelectedRowPositions() {
-		Set<Range> selectedRowsRange = new HashSet<Range>();
-
-		selectionsLock.readLock().lock();
-
-		int rowCount = selectionLayer.getRowCount();
+	public RangeList getSelectedRowPositions() {
+		this.selectionsLock.readLock().lock();
 		try {
-			for (Rectangle r : selections) {
+			final RangeList selected = new RangeList();
+			final int rowCount = this.selectionLayer.getRowCount();
+			
+			for (final Rectangle r : this.selections) {
 				if (r.y < rowCount) {
-					int height = (r.y + r.height <= rowCount) ? r.height : rowCount - r.y;
-					selectedRowsRange.add(new Range(r.y, r.y + height));
+					selected.add(new Range(r.y, Math.min(r.y + r.height, rowCount)));
 				}
 			}
+			
+			return selected;
 		} finally {
-			selectionsLock.readLock().unlock();
+			this.selectionsLock.readLock().unlock();
 		}
-
-		ArrayList<Range> ranges = new ArrayList<Range>(selectedRowsRange);
-		Range.sortByStart(ranges);
-		List<Range> uniqueRanges = new ArrayList<Range>();
-
-		// Adjust for overlaps - between consecutive selections
-		for (int i = 0; i < ranges.size(); i++) {
-			if (i > 0) {
-				Range previousRange = ranges.get(i - 1);
-				Range currentRange = ranges.get(i);
-				if (previousRange.overlap(currentRange) || (previousRange.end == currentRange.start)) {
-					int largerRangeEnd = (previousRange.end > currentRange.end) ? previousRange.end : currentRange.end;
-					uniqueRanges.get(uniqueRanges.size() - 1).end = largerRangeEnd;
-					ranges.get(i).end = largerRangeEnd;
-				} else {
-					uniqueRanges.add(ranges.get(i));
-				}
-			} else {
-				uniqueRanges.add(ranges.get(i));
-			}
-		}
-		return new HashSet<Range>(uniqueRanges);
 	}
-
+	
 	@Override
-	public boolean isRowPositionSelected(int rowPosition) {
-		selectionsLock.readLock().lock();
-
+	public boolean isRowPositionSelected(final int rowPosition) {
+		this.selectionsLock.readLock().lock();
 		try {
-			for (Range rowRange : getSelectedRowPositions()) {
-				if (rowRange.contains(rowPosition)) {
-					return true;
-				}
-			}
-		} finally {
-			selectionsLock.readLock().unlock();
-		}
-
-		return false;
-	}
-
-	@Override
-	public int[] getFullySelectedRowPositions(int rowWidth) {
-		final Set<Range> selectedRows = getSelectedRowPositions();
-		int[] fullySelectedRows = new int[getSelectedRowCount()];
-		int index = 0;
-
-		for (Range rowRange : selectedRows) {
-			for (int i = rowRange.start; i < rowRange.end; i++) {
-				if (isRowPositionFullySelected(i, rowWidth)) {
-					fullySelectedRows[index++] = i;
-				}
-			}
-		}
-
-		return index > 0 ? ArrayUtils.subarray(fullySelectedRows, 0, index) : new int[0];
-	}
-
-	@Override
-	public boolean isRowPositionFullySelected(int rowPosition, int rowWidth) {
-		selectionsLock.readLock().lock();
-
-		try {
-			// Aggregate all rectangles in the row which are in the selection model
-			List<Rectangle> selectedRectanglesInRow = new ArrayList<Rectangle>();
-
-			// If X is same add up the width of the selected area
-			for (Rectangle r : selections) {
-				// Row is within the bounds of the selcted rectangle
-				if (rowPosition >= r.y && rowPosition < r.y + r.height) {
-					selectedRectanglesInRow.add(new Rectangle(r.x, rowPosition, r.width, 1));
-				}
-			}
-			if (selectedRectanglesInRow.isEmpty()) {
-				return false;
-			}
-			sortByX(selectedRectanglesInRow);
-			Rectangle finalRectangle = new Rectangle(selectedRectanglesInRow.get(0).x, rowPosition, 0, 0);
-
-			// Ensure that selections in the row are contiguous and cover the entire row
-			for (int i = 0; i < selectedRectanglesInRow.size(); i++) {
-				Rectangle rectangle = selectedRectanglesInRow.get(i);
-				if(contains(finalRectangle, rectangle)){
-					continue;
-				}
-				if (i > 0) {
-					Rectangle previousRect = selectedRectanglesInRow.get(i - 1);
-					if (rectangle.union(previousRect).width > (rectangle.width + previousRect.width)) {
-						// Rectangles not contiguous
-						return false;
+			final int rowCount = this.selectionLayer.getRowCount();
+			
+			if (rowPosition >= 0 && rowPosition < rowCount) {
+				for (final Rectangle r : this.selections) {
+					if (rowPosition >= r.y && rowPosition < r.y + r.height) {
+						return true;
 					}
 				}
-				// Union will resolve any overlaping area
-				finalRectangle = finalRectangle.union(rectangle);
 			}
-			return finalRectangle.width >= rowWidth;
+			
+			return false;
 		} finally {
-			selectionsLock.readLock().unlock();
+			this.selectionsLock.readLock().unlock();
 		}
 	}
-
-	protected boolean contains(Rectangle containerRectangle, Rectangle rectangle) {
-		Rectangle union = containerRectangle.union(rectangle);
-		return union.equals(containerRectangle); 
-	}
-
-	protected void sortByX(List<Rectangle> selectionRectanglesInRow) {
-		Collections.sort(selectionRectanglesInRow, new Comparator<Rectangle>(){
-			@Override
-			public int compare(Rectangle rectangle1, Rectangle rectangle2) {
-				return new Integer(rectangle1.x).compareTo(new Integer(rectangle2.x)) ;
+	
+	@Override
+	public RangeList getFullySelectedRowPositions() {
+		this.selectionsLock.readLock().lock();
+		try {
+			final RangeList selected = new RangeList();
+			final int columnCount = this.selectionLayer.getColumnCount();
+			
+			if (columnCount > 0) {
+				final RangeList selectedRows = getSelectedRowPositions();
+				for (final Range range : selectedRows) {
+					for (int position = range.start; position < range.end; position++) {
+						if (isRowPositionFullySelected(position, columnCount)) {
+							selected.values().add(position);
+						}
+					}
+				}
 			}
-		});
+			
+			return selected;
+		}
+		finally {
+			this.selectionsLock.readLock().unlock();
+		}
 	}
-
-	protected void sortByY(List<Rectangle> selectionRectanglesInColumn) {
-		Collections.sort(selectionRectanglesInColumn, new Comparator<Rectangle>(){
-			@Override
-			public int compare(Rectangle rectangle1, Rectangle rectangle2) {
-				return new Integer(rectangle1.y).compareTo(new Integer(rectangle2.y)) ;
+	
+	@Override
+	public boolean isRowPositionFullySelected(final int rowPosition) {
+		this.selectionsLock.readLock().lock();
+		try {
+			final int columnCount = this.selectionLayer.getColumnCount();
+			
+			return ((columnCount > 0)
+					&& isRowPositionFullySelected(rowPosition, columnCount) );
+		} finally {
+			this.selectionsLock.readLock().unlock();
+		}
+	}
+	
+	private boolean isRowPositionFullySelected(final int rowPosition, final int columnCount) {
+		// Aggregate all columns of selection rectangles including the row
+		final RangeList selectedColumnsInRow = new RangeList();
+		
+		for (final Rectangle r : this.selections) {
+			if (rowPosition >= r.y && rowPosition < r.y + r.height) {
+				selectedColumnsInRow.add(new Range(r.x, r.x + r.width));
 			}
-		});
-	}
-
-	private Rectangle getLeftSelection(Rectangle intersection, Rectangle selection) {
-		if (intersection.x > selection.x) {
-			Rectangle leftSelection = new Rectangle(selection.x, selection.y,
-					intersection.x - selection.x, selection.height);
-			return leftSelection;
 		}
-
-		return null;
+		
+		final Range range = selectedColumnsInRow.values().getRangeOf(0);
+		return (range != null && range.end >= columnCount);
 	}
-
-	private Rectangle getRightSelection(Rectangle intersection, Rectangle selection) {
-		int newX = intersection.x + intersection.width;
-
-		if (newX < selection.x + selection.width) {
-			Rectangle rightSelection = new Rectangle(newX, selection.y,
-					selection.x + selection.width - newX, selection.height);
-
-			return rightSelection;
-		}
-
-		return null;
-	}
-
-	private Rectangle getTopSelection(Rectangle intersection,
-			Rectangle selectoin) {
-		if (intersection.y > selectoin.y) {
-			Rectangle topSelection = new Rectangle(selectoin.x, selectoin.y,
-					selectoin.width, intersection.y - selectoin.y);
-			return topSelection;
-		}
-		return null;
-	}
-
-	private Rectangle getBottomSelection(Rectangle intersection,
-			Rectangle selection) {
-		int newY = intersection.y + intersection.height;
-
-		if (newY < selection.y + selection.height) {
-			Rectangle bottomSelection = new Rectangle(selection.x, newY,
-					selection.width, selection.y + selection.height - newY);
-			return bottomSelection;
-		}
-
-		return null;
-	}
-
-	// Object methods
-
+	
+	//-- Object methods --//
+	
 	@Override
 	public String toString() {
-		selectionsLock.readLock().lock();
-
+		this.selectionsLock.readLock().lock();
 		try {
-			return selections.toString();
+			return this.selections.toString();
 		} finally {
-			selectionsLock.readLock().unlock();
+			this.selectionsLock.readLock().unlock();
 		}
 	}
 	
diff --git a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/selection/event/ColumnSelectionEvent.java b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/selection/event/ColumnSelectionEvent.java
index b49db61..5912acf 100644
--- a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/selection/event/ColumnSelectionEvent.java
+++ b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/selection/event/ColumnSelectionEvent.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2012 Original authors and others.
+ * Copyright (c) 2012, 2013 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
@@ -10,16 +10,20 @@
  ******************************************************************************/
 package org.eclipse.nebula.widgets.nattable.selection.event;
 
+import java.util.Collection;
+
 import org.eclipse.nebula.widgets.nattable.coordinate.Range;
 import org.eclipse.nebula.widgets.nattable.layer.event.ColumnVisualChangeEvent;
 import org.eclipse.nebula.widgets.nattable.selection.SelectionLayer;
 
+
 public class ColumnSelectionEvent extends ColumnVisualChangeEvent implements ISelectionEvent {
 
 	private final SelectionLayer selectionLayer;
 	
-	public ColumnSelectionEvent(SelectionLayer selectionLayer, int columnPosition) {
-		super(selectionLayer, new Range(columnPosition, columnPosition + 1));
+	
+	public ColumnSelectionEvent(SelectionLayer selectionLayer, Collection<Range> columnPositions) {
+		super(selectionLayer, columnPositions);
 		this.selectionLayer = selectionLayer;
 	}
 	
@@ -28,12 +32,15 @@
 		this.selectionLayer = event.selectionLayer;
 	}
 	
-	public SelectionLayer getSelectionLayer() {
-		return selectionLayer;
-	}
-	
+	@Override
 	public ColumnSelectionEvent cloneEvent() {
 		return new ColumnSelectionEvent(this);
 	}
 	
+	
+	@Override
+	public SelectionLayer getSelectionLayer() {
+		return selectionLayer;
+	}
+	
 }
diff --git a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/selection/event/RowSelectionEvent.java b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/selection/event/RowSelectionEvent.java
index d649f67..ab51770 100644
--- a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/selection/event/RowSelectionEvent.java
+++ b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/selection/event/RowSelectionEvent.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2012 Original authors and others.
+ * Copyright (c) 2012, 2013 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
@@ -12,7 +12,7 @@
 
 import java.util.Collection;
 
-import org.eclipse.nebula.widgets.nattable.coordinate.PositionUtil;
+import org.eclipse.nebula.widgets.nattable.coordinate.Range;
 import org.eclipse.nebula.widgets.nattable.layer.ILayer;
 import org.eclipse.nebula.widgets.nattable.layer.event.RowVisualChangeEvent;
 import org.eclipse.nebula.widgets.nattable.selection.SelectionLayer;
@@ -22,9 +22,10 @@
 
 	private final SelectionLayer selectionLayer;
 	private int rowPositionToMoveIntoViewport;
-
-	public RowSelectionEvent(SelectionLayer selectionLayer, Collection<Integer> rowPositions, int rowPositionToMoveIntoViewport) {
-		super(selectionLayer, PositionUtil.getRanges(rowPositions));
+	
+	
+	public RowSelectionEvent(SelectionLayer selectionLayer, Collection<Range> rowPositions, int rowPositionToMoveIntoViewport) {
+		super(selectionLayer, rowPositions);
 		this.selectionLayer = selectionLayer;
 		this.rowPositionToMoveIntoViewport = rowPositionToMoveIntoViewport;
 	}
@@ -36,6 +37,12 @@
 		this.rowPositionToMoveIntoViewport = event.rowPositionToMoveIntoViewport;
 	}
 	
+	@Override
+	public RowSelectionEvent cloneEvent() {
+		return new RowSelectionEvent(this);
+	}
+	
+	
 	public SelectionLayer getSelectionLayer() {
 		return selectionLayer;
 	}
@@ -51,8 +58,4 @@
 		return super.convertToLocal(localLayer);
 	}
 	
-	public RowSelectionEvent cloneEvent() {
-		return new RowSelectionEvent(this);
-	}
-	
 }
diff --git a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/selection/event/SelectionLayerStructuralChangeEventHandler.java b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/selection/event/SelectionLayerStructuralChangeEventHandler.java
index 9e3b326..25d44a6 100644
--- a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/selection/event/SelectionLayerStructuralChangeEventHandler.java
+++ b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/selection/event/SelectionLayerStructuralChangeEventHandler.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2012 Original authors and others.
+ * Copyright (c) 2012, 2013 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,16 +11,18 @@
 package org.eclipse.nebula.widgets.nattable.selection.event;
 
 import java.util.Collection;
-import java.util.Set;
+
+import org.eclipse.swt.graphics.Rectangle;
 
 import org.eclipse.nebula.widgets.nattable.coordinate.Range;
+import org.eclipse.nebula.widgets.nattable.coordinate.RangeList;
 import org.eclipse.nebula.widgets.nattable.layer.event.ILayerEventHandler;
 import org.eclipse.nebula.widgets.nattable.layer.event.IStructuralChangeEvent;
 import org.eclipse.nebula.widgets.nattable.layer.event.StructuralDiff;
 import org.eclipse.nebula.widgets.nattable.layer.event.StructuralDiff.DiffTypeEnum;
 import org.eclipse.nebula.widgets.nattable.selection.ISelectionModel;
 import org.eclipse.nebula.widgets.nattable.selection.SelectionLayer;
-import org.eclipse.swt.graphics.Rectangle;
+
 
 public class SelectionLayerStructuralChangeEventHandler implements ILayerEventHandler<IStructuralChangeEvent> {
 
@@ -71,8 +73,8 @@
 	}
 	
 	private boolean selectedRowModified(Range changedRange){
-		Set<Range> selectedRows = selectionModel.getSelectedRowPositions();
-		for (Range rowRange : selectedRows) {
+		final RangeList selectedRows = selectionModel.getSelectedRowPositions();
+		for (final Range rowRange : selectedRows) {
 			if (rowRange.overlap(changedRange)){
 				return true;
 			}
diff --git a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/sort/event/SortColumnEvent.java b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/sort/event/SortColumnEvent.java
index b2ab09b..f5d2507 100644
--- a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/sort/event/SortColumnEvent.java
+++ b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/sort/event/SortColumnEvent.java
@@ -17,13 +17,14 @@
 public class SortColumnEvent extends ColumnVisualChangeEvent {
 
 	public SortColumnEvent(ILayer layer, int columnPosition) {
-		super(layer, new Range(columnPosition, columnPosition + 1));
+		super(layer, new Range(columnPosition));
 	}
 	
 	protected SortColumnEvent(SortColumnEvent event) {
 		super(event);
 	}
 	
+	@Override
 	public SortColumnEvent cloneEvent() {
 		return new SortColumnEvent(this);
 	}
diff --git a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/style/editor/command/DisplayColumnStyleEditorCommandHandler.java b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/style/editor/command/DisplayColumnStyleEditorCommandHandler.java
index 91169e0..d9e1aee 100644
--- a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/style/editor/command/DisplayColumnStyleEditorCommandHandler.java
+++ b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/style/editor/command/DisplayColumnStyleEditorCommandHandler.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2012 Original authors and others.
+ * Copyright (c) 2012, 2013 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
@@ -18,9 +18,12 @@
 import java.util.Properties;
 import java.util.Set;
 
+import org.eclipse.swt.widgets.Display;
 
 import org.eclipse.nebula.widgets.nattable.command.AbstractLayerCommandHandler;
 import org.eclipse.nebula.widgets.nattable.config.IConfigRegistry;
+import org.eclipse.nebula.widgets.nattable.coordinate.IValueIterator;
+import org.eclipse.nebula.widgets.nattable.coordinate.RangeList;
 import org.eclipse.nebula.widgets.nattable.layer.LabelStack;
 import org.eclipse.nebula.widgets.nattable.layer.cell.ColumnOverrideLabelAccumulator;
 import org.eclipse.nebula.widgets.nattable.persistence.IPersistable;
@@ -29,7 +32,6 @@
 import org.eclipse.nebula.widgets.nattable.style.CellStyleAttributes;
 import org.eclipse.nebula.widgets.nattable.style.Style;
 import org.eclipse.nebula.widgets.nattable.style.editor.ColumnStyleEditorDialog;
-import org.eclipse.swt.widgets.Display;
 
 /**
  * 
@@ -73,26 +75,18 @@
 			return true;
 		}
 		
-		applySelectedStyleToColumns(command, getSelectedColumnIndeces());
+		applySelectedStyleToColumns(command, selectionLayer.getSelectedColumnPositions());
 		return true;
 	}
 
-	private int[] getSelectedColumnIndeces() {
-		int[] selectedColumnPositions = selectionLayer.getSelectedColumnPositions();
-		int[] selectedColumnIndeces = new int[selectedColumnPositions.length];
-		for (int i=0; i<selectedColumnPositions.length; i++) {
-			selectedColumnIndeces[i] = selectionLayer.getColumnIndexByPosition(selectedColumnPositions[i]);
-		}
-		return selectedColumnIndeces;
-	}
-
 	public Class<DisplayColumnStyleEditorCommand> getCommandClass() {
 		return DisplayColumnStyleEditorCommand.class;
 	}
 
-	protected void applySelectedStyleToColumns(DisplayColumnStyleEditorCommand command, int[] columnIndeces) {
-		for (int i=0; i<columnIndeces.length; i++) {
-			final int columnIndex = columnIndeces[i];
+	protected void applySelectedStyleToColumns(DisplayColumnStyleEditorCommand command,
+			final RangeList columnPositions) {
+		for (final IValueIterator columnIter = columnPositions.values().iterator(); columnIter.hasNext(); ) {
+			final int columnIndex = selectionLayer.getColumnIndexByPosition(columnIter.nextValue());
 			// Read the edited styles
 			Style newColumnCellStyle = dialog.getNewColumnCellStyle(); 
 			
diff --git a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/tickupdate/command/TickUpdateCommandHandler.java b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/tickupdate/command/TickUpdateCommandHandler.java
index 02fd05f..03838ab 100644
--- a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/tickupdate/command/TickUpdateCommandHandler.java
+++ b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/tickupdate/command/TickUpdateCommandHandler.java
@@ -10,8 +10,11 @@
  ******************************************************************************/
 package org.eclipse.nebula.widgets.nattable.tickupdate.command;
 
+import java.util.List;
+
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
+
 import org.eclipse.nebula.widgets.nattable.command.AbstractLayerCommandHandler;
 import org.eclipse.nebula.widgets.nattable.config.IConfigRegistry;
 import org.eclipse.nebula.widgets.nattable.config.IEditableRule;
@@ -49,11 +52,11 @@
 
 	@Override
 	public boolean doCommand(TickUpdateCommand command) {
-		PositionCoordinate[] selectedPositions = selectionLayer.getSelectedCellPositions();
+		List<PositionCoordinate> selectedPositions = selectionLayer.getSelectedCellPositions();
 		IConfigRegistry configRegistry = command.getConfigRegistry();
 		
 		// Tick update for multiple cells in selection 
-		if (selectedPositions.length > 1) {
+		if (selectedPositions.size() > 1) {
 			// Can all cells be updated ?
 			if (EditUtils.allCellsEditable(selectionLayer, configRegistry)
 					&& EditUtils.isEditorSame(selectionLayer, configRegistry) 
diff --git a/org.eclipse.nebula.widgets.nattable.extension.glazedlists.test/src/org/eclipse/nebula/widgets/nattable/extension/glazedlists/test/integration/HideMultipleColumnsIntegrationTest.java b/org.eclipse.nebula.widgets.nattable.extension.glazedlists.test/src/org/eclipse/nebula/widgets/nattable/extension/glazedlists/test/integration/HideMultipleColumnsIntegrationTest.java
index befc6e7..cb96ba9 100644
--- a/org.eclipse.nebula.widgets.nattable.extension.glazedlists.test/src/org/eclipse/nebula/widgets/nattable/extension/glazedlists/test/integration/HideMultipleColumnsIntegrationTest.java
+++ b/org.eclipse.nebula.widgets.nattable.extension.glazedlists.test/src/org/eclipse/nebula/widgets/nattable/extension/glazedlists/test/integration/HideMultipleColumnsIntegrationTest.java
@@ -15,6 +15,11 @@
 import org.junit.Assert;
 import org.junit.Test;
 
+import ca.odell.glazedlists.GlazedLists;
+
+import org.junit.Assert;
+import org.junit.Test;
+
 import org.eclipse.nebula.widgets.nattable.config.ConfigRegistry;
 import org.eclipse.nebula.widgets.nattable.coordinate.RangeList;
 import org.eclipse.nebula.widgets.nattable.data.ReflectiveColumnPropertyAccessor;
diff --git a/org.eclipse.nebula.widgets.nattable.extension.glazedlists.test/src/org/eclipse/nebula/widgets/nattable/extension/glazedlists/test/integration/RowSelectionIntegrationTest.java b/org.eclipse.nebula.widgets.nattable.extension.glazedlists.test/src/org/eclipse/nebula/widgets/nattable/extension/glazedlists/test/integration/RowSelectionIntegrationTest.java
index e40b797..0d8e293 100644
--- a/org.eclipse.nebula.widgets.nattable.extension.glazedlists.test/src/org/eclipse/nebula/widgets/nattable/extension/glazedlists/test/integration/RowSelectionIntegrationTest.java
+++ b/org.eclipse.nebula.widgets.nattable.extension.glazedlists.test/src/org/eclipse/nebula/widgets/nattable/extension/glazedlists/test/integration/RowSelectionIntegrationTest.java
@@ -12,11 +12,18 @@
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.fail;
+import ca.odell.glazedlists.EventList;
+import ca.odell.glazedlists.GlazedLists;
 
 import java.io.Serializable;
 import java.util.Collection;
 
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
 import org.eclipse.jface.viewers.StructuredSelection;
+
 import org.eclipse.nebula.widgets.nattable.NatTable;
 import org.eclipse.nebula.widgets.nattable.config.ConfigRegistry;
 import org.eclipse.nebula.widgets.nattable.config.IConfigRegistry;
@@ -36,13 +43,7 @@
 import org.eclipse.nebula.widgets.nattable.test.fixture.NatTableFixture;
 import org.eclipse.nebula.widgets.nattable.test.fixture.data.RowDataFixture;
 import org.eclipse.nebula.widgets.nattable.test.fixture.data.RowDataListFixture;
-import org.eclipse.nebula.widgets.nattable.util.ArrayUtil;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
 
-import ca.odell.glazedlists.EventList;
-import ca.odell.glazedlists.GlazedLists;
 
 public class RowSelectionIntegrationTest {
 
@@ -91,10 +92,10 @@
 
 	@Test
 	public void shouldPreserveRowSelectionOnDataUpdates() throws Exception {
-		assertEquals(0, selectionLayer.getFullySelectedRowPositions().length);
+		assertEquals(0, selectionLayer.getFullySelectedRowPositions().values().size());
 
 		nattable.doCommand(new SelectRowsCommand(nattable, 1, 1, false, false));
-		assertEquals(1, selectionLayer.getFullySelectedRowPositions().length);
+		assertEquals(1, selectionLayer.getFullySelectedRowPositions().values().size());
 
 		// Ford motor at top and selected
 		assertEquals("B Ford Motor", nattable.getDataValueByPosition(2, 1).toString());
@@ -112,7 +113,7 @@
 
 	@Test
 	public void shouldPreserveRowSelectionOnSort() throws Exception {
-		assertEquals(0, selectionLayer.getFullySelectedRowPositions().length);
+		assertEquals(0, selectionLayer.getFullySelectedRowPositions().values().size());
 
 		// Unsorted order - Ford motor at top
 		assertEquals("B Ford Motor", nattable.getDataValueByPosition(2, 1).toString());
@@ -142,28 +143,28 @@
 		selectionLayer.clear();
 		selectionLayer.doCommand(new SelectCellCommand(selectionLayer, 1, 0, false, true));
 
-		Collection<PositionCoordinate> cells = ArrayUtil.asCollection(selectionLayer.getSelectedCellPositions());
+		Collection<PositionCoordinate> cells = selectionLayer.getSelectedCellPositions();
 		Assert.assertEquals(selectionLayer.getColumnCount(), cells.size());
 		Assert.assertEquals(1, selectionLayer.getSelectedRowCount());
 
 		//select another cell with control mask
 		selectionLayer.doCommand(new SelectCellCommand(selectionLayer, 2, 1, false, true));
 
-		cells = ArrayUtil.asCollection(selectionLayer.getSelectedCellPositions());
+		cells = selectionLayer.getSelectedCellPositions();
 		Assert.assertEquals(selectionLayer.getColumnCount(), cells.size());
 		Assert.assertEquals(1, selectionLayer.getSelectedRowCount());
 
 		//select additional cells with shift mask
 		selectionLayer.doCommand(new SelectCellCommand(selectionLayer, 2, 10, true, false));
 
-		cells = ArrayUtil.asCollection(selectionLayer.getSelectedCellPositions());
+		cells = selectionLayer.getSelectedCellPositions();
 		Assert.assertEquals(selectionLayer.getColumnCount(), cells.size());
 		Assert.assertEquals(1, selectionLayer.getSelectedRowCount());
 
 		//select additional cells with shift mask
 		selectionLayer.doCommand(new SelectCellCommand(selectionLayer, 10, 0, true, false));
 
-		cells = ArrayUtil.asCollection(selectionLayer.getSelectedCellPositions());
+		cells = selectionLayer.getSelectedCellPositions();
 		Assert.assertEquals(selectionLayer.getColumnCount(), cells.size());
 		Assert.assertEquals(1, selectionLayer.getSelectedRowCount());
 	}
@@ -190,7 +191,7 @@
 		selectionProvider.setSelection(new StructuredSelection(
 				new RowDataFixture[] { eventListFixture.get(1) }));
 		
-		assertEquals(1, selectionLayer.getFullySelectedRowPositions().length);
+		assertEquals(1, selectionLayer.getFullySelectedRowPositions().values().size());
 	}
 	
 	@Test
@@ -198,12 +199,12 @@
 		selectionProvider.setSelection(new StructuredSelection(
 				new RowDataFixture[] { eventListFixture.get(1), eventListFixture.get(3) }));
 		
-		assertEquals(2, selectionLayer.getFullySelectedRowPositions().length);
+		assertEquals(2, selectionLayer.getFullySelectedRowPositions().values().size());
 
 		selectionProvider.setSelection(new StructuredSelection(
 				new RowDataFixture[] { eventListFixture.get(5), eventListFixture.get(7) }));
 		
-		assertEquals(2, selectionLayer.getFullySelectedRowPositions().length);
+		assertEquals(2, selectionLayer.getFullySelectedRowPositions().values().size());
 	}
 	
 	@Test
@@ -213,12 +214,12 @@
 		selectionProvider.setSelection(new StructuredSelection(
 				new RowDataFixture[] { eventListFixture.get(1), eventListFixture.get(3) }));
 		
-		assertEquals(2, selectionLayer.getFullySelectedRowPositions().length);
+		assertEquals(2, selectionLayer.getFullySelectedRowPositions().values().size());
 
 		selectionProvider.setSelection(new StructuredSelection(
 				new RowDataFixture[] { eventListFixture.get(5), eventListFixture.get(7) }));
 		
-		assertEquals(4, selectionLayer.getFullySelectedRowPositions().length);
+		assertEquals(4, selectionLayer.getFullySelectedRowPositions().values().size());
 	}
 	
 	private RowDataFixture getSelected() {