diff --git a/org.eclipse.nebula.widgets.nattable.core.example/src/org/eclipse/nebula/widgets/nattable/core/example/impl/MultiViewportExample.xtend b/org.eclipse.nebula.widgets.nattable.core.example/src/org/eclipse/nebula/widgets/nattable/core/example/impl/MultiViewportExample.xtend
index 69d9f96..edda874 100644
--- a/org.eclipse.nebula.widgets.nattable.core.example/src/org/eclipse/nebula/widgets/nattable/core/example/impl/MultiViewportExample.xtend
+++ b/org.eclipse.nebula.widgets.nattable.core.example/src/org/eclipse/nebula/widgets/nattable/core/example/impl/MultiViewportExample.xtend
@@ -18,7 +18,7 @@
 						new AxisImpl(4, 150),  // Horizontal axis
 						new AxisImpl(10, 100)  // Vertical axis
 					)
-					horizontalAxis.minPixelOrigin = 0
+					horizontalAxis.minPixelLocation = 0
 					horizontalAxis.maxPixelSize = 150
 				]
 			addRow(
diff --git a/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/core/layer/AxisTest.xtend b/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/core/layer/AxisTest.xtend
index ee4bb1b..ed85614 100644
--- a/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/core/layer/AxisTest.xtend
+++ b/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/core/layer/AxisTest.xtend
@@ -10,22 +10,39 @@
 
 class AxisTest {
 	
-	def static testAxis(Axis axis, List<? extends Serializable> expectedIds, List<Double> expectedPixels) {
-		testAxis("", axis, expectedIds, expectedPixels)
+	def static testAxis(Axis axis, List<? extends Serializable> expectedIds, List<Double> expectedStartPixels) {
+		testAxis(axis, expectedIds, expectedStartPixels, expectedStartPixels, null)
 	}
 	
-	def static testAxis(String axisName, Axis axis, List<? extends Serializable> expectedIds, List<Double> expectedPixels) {
-		// Segment count
+	def static testAxis(Axis axis, List<? extends Serializable> expectedIds, List<Double> expectedStartPixels, List<Double> expectedOriginPixels, List<Double> expectedPixelSizes) {
+		testAxis("", axis, expectedIds, expectedStartPixels, expectedOriginPixels, expectedPixelSizes)
+	}
+	
+	def static testAxis(String axisName, Axis axis, List<? extends Serializable> expectedIds, List<Double> expectedStartPixels) {
+		testAxis(axisName, axis, expectedIds, expectedStartPixels, expectedStartPixels, null)
+	}
+	
+	def static testAxis(String axisName, Axis axis, List<? extends Serializable> expectedIds, List<Double> expectedStartPixels, List<Double> expectedOriginPixels, List<Double> expectedPixelSizes) {
+		// Axis segment count
 		assertEquals('''«axisName» getSegmentCount''', expectedIds.size, axis.segmentCount)
 		
 		// Start pixel of segment position
 		for (segmentPosition : 0 .. expectedIds.size)
-			assertEquals('''«axisName» getStartPixelOfSegmentPosition(«segmentPosition»)''', expectedPixels.get(segmentPosition), axis.getStartPixelOfSegmentPosition(segmentPosition), 0)
+			assertEquals('''«axisName» getStartPixelOfSegmentPosition(«segmentPosition»)''', expectedStartPixels.get(segmentPosition), axis.getStartPixelOfSegmentPosition(segmentPosition), 0)
+		
+		// Origin pixel of segment position
+		for (segmentPosition : 0 ..< expectedIds.size)
+			assertEquals('''«axisName» getOriginPixelOfSegmentPosition(«segmentPosition»)''', expectedOriginPixels.get(segmentPosition), axis.getOriginPixelOfSegmentPosition(segmentPosition), 0)
+		
+		// Pixel size of segment position
+		if (expectedPixelSizes != null)
+			for (segmentPosition : 0 ..< expectedIds.size)
+				assertEquals('''«axisName» getPixelSizeOfSegmentPosition(«segmentPosition»)''', expectedPixelSizes.get(segmentPosition), axis.getPixelSizeOfSegmentPosition(segmentPosition), 0)
 		
 		// Segment position of pixel location
-		assertEquals('''«axisName» < range getSegmentPositionOfPixelLocation(«expectedPixels.get(0) - 1»)''', -1, axis.getSegmentPositionOfPixelLocation(expectedPixels.get(0) - 1))
+		assertEquals('''«axisName» < range getSegmentPositionOfPixelLocation(«expectedOriginPixels.get(0) - 1»)''', -1, axis.getSegmentPositionOfPixelLocation(expectedOriginPixels.get(0) - 1))
 		for (segmentPosition : 0 ..< expectedIds.size) {
-			val pixelLocation = expectedPixels.get(segmentPosition)
+			val pixelLocation = expectedStartPixels.get(segmentPosition)
 			assertEquals('''«axisName» getSegmentPositionOfPixelLocation(«pixelLocation»)''', segmentPosition, axis.getSegmentPositionOfPixelLocation(pixelLocation))
 		}
 		assertEquals('''«axisName» > range getSegmentPositionOfPixelLocation(«axis.pixelSize»)''', axis.segmentCount, axis.getSegmentPositionOfPixelLocation(axis.pixelSize))
@@ -38,8 +55,8 @@
 		for (segmentId : expectedIds)
 			assertEquals('''«axisName» getSegmentPositionOfId(«segmentId»)''', expectedIds.indexOf(segmentId), axis.getSegmentPositionOfId(segmentId))
 		
-		// Pixel size
-		assertEquals('''«axisName» pixelSize''', expectedPixels.get(expectedPixels.size - 1) - expectedPixels.get(0), axis.pixelSize, 0)
+		// Axis pixel size
+		assertEquals('''«axisName» pixelSize''', expectedStartPixels.get(expectedStartPixels.size - 1) - expectedStartPixels.get(0), axis.pixelSize, 0)
 	}
 	
 }
\ No newline at end of file
diff --git a/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/core/layer/impl/viewport/ViewportAxisTest.xtend b/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/core/layer/impl/viewport/ViewportAxisTest.xtend
index d7b98ce..3e4113c 100644
--- a/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/core/layer/impl/viewport/ViewportAxisTest.xtend
+++ b/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/core/layer/impl/viewport/ViewportAxisTest.xtend
@@ -38,12 +38,11 @@
 			#[ 0.0, 2.0, 5.0, 12.0, 25.0 ]
 		)
 		
-		// By default, viewport visible pixel size is 10
 		testAxis(
 			"viewportAxis",
 			viewportAxis,
-			#[ 0, 1, 2 ],
-			#[ 0.0, 2.0, 5.0, 12.0 ]
+			#[ 0, 1, 2, 3 ],
+			#[ 0.0, 2.0, 5.0, 12.0, 25.0 ]
 		)
 		
 		viewportAxis.visiblePixelSize = underlyingAxis.pixelSize
@@ -62,7 +61,7 @@
 		//   segment position: | 0 |  1  |      2      |            3            |
 		//     pixel location:  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4
 		// visible pixel size: |---------|
-		viewportAxis.pixelOrigin = 0
+		viewportAxis.viewportOrigin = 0
 		viewportAxis.visiblePixelSize = 5
 		testAxis(
 			viewportAxis,
@@ -77,7 +76,7 @@
 		//     pixel location:  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4
 		// visible pixel size:     |---------------------------------------------|
 		//                         |0 1 2|3 4 5 6 7 8 9|0 1 2 3 4 5 6 7 8 9 0 1 2|
-		viewportAxis.pixelOrigin = 2
+		viewportAxis.viewportOrigin = 2
 		viewportAxis.visiblePixelSize = 23
 		testAxis(
 			viewportAxis,
@@ -92,7 +91,7 @@
 		//     pixel location:  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4
 		// visible pixel size:     |-------------------|
 		//                         |0 1 2|3 4 5 6 7 8 9|
-		viewportAxis.pixelOrigin = 2
+		viewportAxis.viewportOrigin = 2
 		viewportAxis.visiblePixelSize = 10
 		testAxis(
 			viewportAxis,
@@ -107,7 +106,7 @@
 		//     pixel location:  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4
 		// visible pixel size: |---------------|
 		//                     |0 1|2 3 4|5 6 7 8 9 0 1|
-		viewportAxis.pixelOrigin = 0
+		viewportAxis.viewportOrigin = 0
 		viewportAxis.visiblePixelSize = 8
 		testAxis(
 			viewportAxis,
@@ -122,12 +121,14 @@
 		//     pixel location:  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4
 		// visible pixel size:                 |---------------------------------|
 		//                               |3 2 1 0 1 2 3|4 5 6 7 8 9 0 1 2 3 4 5 6|
-		viewportAxis.pixelOrigin = 8
+		viewportAxis.viewportOrigin = 8
 		viewportAxis.visiblePixelSize = 17
 		testAxis(
 			viewportAxis,
 			#[ 2, 3 ],
-			#[ -3.0, 4.0, 17.0 ]
+			#[ -0.0, 4.0, 17.0 ],
+			#[ -3.0, 4.0 ],
+			#[ 7.0, 13.0 ]
 		)
 	}
 	
@@ -137,12 +138,14 @@
 		//     pixel location:  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4
 		// visible pixel size:                                   |-------------------|
 		//                                             |4 5 6 7 8 9 0 1 2 3 4 5 6|
-		viewportAxis.pixelOrigin = 17
+		viewportAxis.viewportOrigin = 17
 		viewportAxis.visiblePixelSize = 10
 		testAxis(
 			viewportAxis,
 			#[ 3 ],
-			#[ -5.0, 8.0 ]
+			#[ -0.0, 8.0 ],
+			#[ -5.0 ],
+			#[ 13.0 ]
 		)
 	}
 	
@@ -152,12 +155,14 @@
 		//     pixel location:  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4
 		// visible pixel size:         |-----------------------------|
 		//                         |2 1 0|1 2 3 4 5 6 7|8 9 0 1 2 3 4 5 6 7 8 9 0|
-		viewportAxis.pixelOrigin = 4
+		viewportAxis.viewportOrigin = 4
 		viewportAxis.visiblePixelSize = 15
 		testAxis(
 			viewportAxis,
 			#[ 1, 2, 3 ],
-			#[ -2.0, 1.0, 8.0, 21.0 ]
+			#[ 0.0, 1.0, 8.0, 21.0 ],
+			#[ -2.0, 1.0, 8.0 ],
+			#[ 3.0, 7.0, 13.0 ]
 		)
 	}
 	
@@ -167,13 +172,15 @@
 		//     pixel location:  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4
 		// visible pixel size:         |-------------|+++++|
 		//                         |2 1 0|1 2 3 4 5 6 7|8 9 0 1 2 3 4 5 6 7 8 9 0|
-		viewportAxis.pixelOrigin = 4
+		viewportAxis.viewportOrigin = 4
 		viewportAxis.visiblePixelSize = 7
 		testAxis(
 			"before expand",
 			viewportAxis,
 			#[ 1, 2 ],
-			#[ -2.0, 1.0, 8.0 ]
+			#[ -0.0, 1.0, 8.0 ],
+			#[ -2.0, 1.0 ],
+			#[ 3.0, 7.0 ]
 		)
 		
 		//   segment position: | 0 |  1  |      2      |            3            |
@@ -186,7 +193,9 @@
 			"after expand",
 			viewportAxis,
 			#[ 1, 2, 3 ],
-			#[ -2.0, 1.0, 8.0, 21.0 ]
+			#[ 0.0, 1.0, 8.0, 21.0 ],
+			#[ -2.0, 1.0, 8.0 ],
+			#[ 3.0, 7.0, 13.0 ]
 		)
 	}
 	
@@ -196,13 +205,15 @@
 		//     pixel location:  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4
 		// visible pixel size:         |-------------|+++++++++++++++++++++++++++++++++|
 		//                         |2 1 0|1 2 3 4 5 6 7|8 9 0 1 2 3 4 5 6 7 8 9 0|1 2 3
-		viewportAxis.pixelOrigin = 4
+		viewportAxis.viewportOrigin = 4
 		viewportAxis.visiblePixelSize = 7
 		testAxis(
 			"before expand",
 			viewportAxis,
 			#[ 1, 2 ],
-			#[ -2.0, 1.0, 8.0 ]
+			#[ 0.0, 1.0, 8.0 ],
+			#[ -2.0, 1.0 ],
+			#[ 3.0, 7.0 ]
 		)
 		
 		//   segment position: | 0 |  1  |      2      |            3            |
@@ -215,7 +226,9 @@
 			"after expand",
 			viewportAxis,
 			#[ 0, 1, 2, 3 ],
-			#[ -1.0, 1.0, 4.0, 11.0, 24.0 ]
+			#[ 0.0, 1.0, 4.0, 11.0, 24.0 ],
+			#[ -1.0, 1.0, 4.0, 11.0 ],
+			#[ 2.0, 3.0, 7.0, 13.0 ]
 		)
 	}
 	
diff --git a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/core/big/layer/axis/BigAxis.xtend b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/core/big/layer/axis/BigAxis.xtend
index a83c3ca..306da69 100644
--- a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/core/big/layer/axis/BigAxis.xtend
+++ b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/core/big/layer/axis/BigAxis.xtend
@@ -17,10 +17,12 @@
 	def BigInteger getSegmentCount()
 	
 	/**
-	 * Gets the start pixel location of the segment at the given position. This function must be defined for all valid segment position
-	 * values and <em>also</em> for segment position = segment count. Technically the segment count is not a valid segment position because
-	 * segment positions are 0-indexed and range from 0 to segment count - 1. However, the 'start' pixel location of the segment position after
-	 * the last segment is used to calculate the pixel size of the last segment, and also the overall pixel size of the axis.
+	 * Gets the start pixel location of the segment at the given position. The start pixel locations of the segments determine the pixel geometry of the axis.
+	 * 
+	 * This function must be defined for all valid segment position values and <em>also</em> for segment position = segment count.
+	 * Technically the segment count is not a valid segment position because segment positions are 0-indexed and range from 0 to segment count - 1.
+	 * However, the 'start' pixel location of the segment position after the last segment is used to calculate the pixel size of the last segment,
+	 * and also the overall pixel size of the axis.
 	 * 
 	 * @param segmentPosition
 	 * @return The start pixel location of the given segment position.
@@ -28,6 +30,24 @@
 	def BigDecimal getStartPixelOfSegmentPosition(BigInteger segmentPosition)
 	
 	/**
+	 * Gets the origin pixel location of the segment at the given position. The is the pixel location to be used when rendering the cell.
+	 * This is normally the same as getStartPixelOfSegmentPosition(segmentPosition).
+	 * 
+	 * @param segmentPosition
+	 * @return The origin pixel location of the given segment position.
+	 */
+	def BigDecimal getOriginPixelOfSegmentPosition(BigInteger segmentPosition)
+	
+	/**
+	 * Gets the pixel size of the segment at the given position. This is the size to be used when rendering the cell.
+	 * This is normally the same as getStartPixelOfSegmentPosition(segmentPosition + 1) - getStartPixelOfSegmentPosition(segmentPosition).
+	 * 
+	 * @param segmentPosition
+	 * @return The pixel size of the given segment position.
+	 */
+	def BigDecimal getPixelSizeOfSegmentPosition(BigInteger segmentPosition)
+	
+	/**
 	 * Gets the position of the segment that is nearest to the the given pixel location.
 	 * 
 	 * @param pixelLocation
diff --git a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/core/big/layer/axis/impl/AbstractBigAxis.xtend b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/core/big/layer/axis/impl/AbstractBigAxis.xtend
new file mode 100644
index 0000000..e922404
--- /dev/null
+++ b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/core/big/layer/axis/impl/AbstractBigAxis.xtend
@@ -0,0 +1,17 @@
+package org.eclipse.nebula.widgets.nattable.core.big.layer.axis.impl
+
+import java.math.BigInteger
+import org.eclipse.nebula.widgets.nattable.core.big.layer.axis.BigAxis
+import org.eclipse.nebula.widgets.nattable.core.event.AbstractEventSourceSink
+
+abstract class AbstractBigAxis extends AbstractEventSourceSink implements BigAxis {
+
+	override getOriginPixelOfSegmentPosition(BigInteger segmentPosition) {
+		getStartPixelOfSegmentPosition(segmentPosition)
+	}
+	
+	override getPixelSizeOfSegmentPosition(BigInteger segmentPosition) {
+		getStartPixelOfSegmentPosition(segmentPosition + BigInteger::ONE) - getStartPixelOfSegmentPosition(segmentPosition)
+	}
+	
+}
\ No newline at end of file
diff --git a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/core/big/layer/axis/impl/BigAxisImpl.xtend b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/core/big/layer/axis/impl/BigAxisImpl.xtend
index 03fd39d..c8945a2 100644
--- a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/core/big/layer/axis/impl/BigAxisImpl.xtend
+++ b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/core/big/layer/axis/impl/BigAxisImpl.xtend
@@ -3,15 +3,13 @@
 import java.io.Serializable
 import java.math.BigDecimal
 import java.math.BigInteger
-import org.eclipse.nebula.widgets.nattable.core.big.layer.axis.BigAxis
-import org.eclipse.nebula.widgets.nattable.core.event.AbstractEventSourceSink
 
 import static extension org.eclipse.nebula.widgets.nattable.core.big.layer.axis.BigAxisInvariants.*
 
 /**
  * A simple Axis implementation.
  */
-class BigAxisImpl extends AbstractEventSourceSink implements BigAxis {
+class BigAxisImpl extends AbstractBigAxis {
 	
 	BigInteger segmentCount
 	BigDecimal defaultSegmentSize
@@ -43,6 +41,10 @@
 		else return new BigDecimal(segmentPosition) * defaultSegmentSize
 	}
 	
+	override getOriginPixelOfSegmentPosition(BigInteger segmentPosition) {
+		
+	}
+	
 	override getSegmentPositionOfPixelLocation(BigDecimal pixelLocation) {
 		if (pixelLocation < BigDecimal::ZERO) return -BigInteger::ONE
 		else if (pixelLocation == BigDecimal::ZERO) return BigInteger::ZERO
diff --git a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/core/big/layer/axis/impl/NotSoBigAxis.xtend b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/core/big/layer/axis/impl/NotSoBigAxis.xtend
index c25b6ef..55f2ae5 100644
--- a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/core/big/layer/axis/impl/NotSoBigAxis.xtend
+++ b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/core/big/layer/axis/impl/NotSoBigAxis.xtend
@@ -3,14 +3,13 @@
 import java.io.Serializable
 import java.math.BigDecimal
 import java.math.BigInteger
-import org.eclipse.nebula.widgets.nattable.core.big.layer.axis.BigAxis
 import org.eclipse.nebula.widgets.nattable.core.event.Event
 import org.eclipse.nebula.widgets.nattable.core.event.EventListener
 import org.eclipse.nebula.widgets.nattable.core.layer.axis.Axis
 
 import static extension org.eclipse.nebula.widgets.nattable.core.big.math.BigIntegerExtensions.*
 
-class NotSoBigAxis implements BigAxis {
+class NotSoBigAxis extends AbstractBigAxis {
 	
 	val Axis axis
 	
diff --git a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/core/layer/LayerInvariants.xtend b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/core/layer/LayerInvariants.xtend
index ce743d2..04ea1bf 100644
--- a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/core/layer/LayerInvariants.xtend
+++ b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/core/layer/LayerInvariants.xtend
@@ -24,7 +24,11 @@
 		layer.horizontalAxis.getStartPixelOfSegmentPosition(columnPosition)
 	}
 	
-	def static getPixelWidthOfColumn(Layer layer, int columnPosition) {
+	def static getOriginXPixelOfColumnPosition(Layer layer, int columnPosition) {
+		layer.horizontalAxis.getOriginPixelOfSegmentPosition(columnPosition)
+	}
+	
+	def static getPixelWidthOfColumnPosition(Layer layer, int columnPosition) {
 		layer.horizontalAxis.getPixelSizeOfSegmentPosition(columnPosition)
 	}
 	
@@ -50,7 +54,11 @@
 		layer.verticalAxis.getStartPixelOfSegmentPosition(rowPosition)
 	}
 	
-	def static getPixelHeightOfRow(Layer layer, int rowPosition) {
+	def static getOriginYPixelOfRowPosition(Layer layer, int rowPosition) {
+		layer.verticalAxis.getOriginPixelOfSegmentPosition(rowPosition)
+	}
+	
+	def static getPixelHeightOfRowPosition(Layer layer, int rowPosition) {
 		layer.verticalAxis.getPixelSizeOfSegmentPosition(rowPosition)
 	}
 	
diff --git a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/core/layer/axis/Axis.xtend b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/core/layer/axis/Axis.xtend
index 9a6499d..f7721c7 100644
--- a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/core/layer/axis/Axis.xtend
+++ b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/core/layer/axis/Axis.xtend
@@ -15,10 +15,12 @@
 	def int getSegmentCount()
 	
 	/**
-	 * Gets the start pixel location of the segment at the given position. This function must be defined for all valid segment position
-	 * values and <em>also</em> for segment position = segment count. Technically the segment count is not a valid segment position because
-	 * segment positions are 0-indexed and range from 0 to segment count - 1. However, the 'start' pixel location of the segment position after
-	 * the last segment is used to calculate the pixel size of the last segment, and also the overall pixel size of the axis.
+	 * Gets the start pixel location of the segment at the given position. The start pixel locations of the segments determine the pixel geometry of the axis.
+	 * 
+	 * This function must be defined for all valid segment position values and <em>also</em> for segment position = segment count.
+	 * Technically the segment count is not a valid segment position because segment positions are 0-indexed and range from 0 to segment count - 1.
+	 * However, the 'start' pixel location of the segment position after the last segment is used to calculate the pixel size of the last segment,
+	 * and also the overall pixel size of the axis.
 	 * 
 	 * @param segmentPosition
 	 * @return The start pixel location of the given segment position.
@@ -26,14 +28,22 @@
 	def double getStartPixelOfSegmentPosition(int segmentPosition)
 	
 	/**
-	 * Gets the minimum pixel location of this axis. This is normally the same as getStartPixelOfSegmentPosition(0).
+	 * Gets the origin pixel location of the segment at the given position. The is the pixel location to be used when rendering the cell.
+	 * This is normally the same as getStartPixelOfSegmentPosition(segmentPosition).
+	 * 
+	 * @param segmentPosition
+	 * @return The origin pixel location of the given segment position.
 	 */
-	def double getMinPixelLocation()
+	def double getOriginPixelOfSegmentPosition(int segmentPosition)
 	
 	/**
-	 * Gets the maximum pixel size of this axis. This is normally the same as getStartPixelOfSegmentPosition(getSegmentCount()) - getMinPixelLocation().
+	 * Gets the pixel size of the segment at the given position. This is the size to be used when rendering the cell.
+	 * This is normally the same as getStartPixelOfSegmentPosition(segmentPosition + 1) - getStartPixelOfSegmentPosition(segmentPosition).
+	 * 
+	 * @param segmentPosition
+	 * @return The pixel size of the given segment position.
 	 */
-	def double getPixelSize()
+	def double getPixelSizeOfSegmentPosition(int segmentPosition)
 	
 	/**
 	 * Gets the position of the segment that is nearest to the the given pixel location.
diff --git a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/core/layer/axis/AxisInvariants.xtend b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/core/layer/axis/AxisInvariants.xtend
index 7733099..095f00c 100644
--- a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/core/layer/axis/AxisInvariants.xtend
+++ b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/core/layer/axis/AxisInvariants.xtend
@@ -5,8 +5,8 @@
  */
 class AxisInvariants {
 	
-	def static getPixelSizeOfSegmentPosition(Axis axis, int segmentPosition) {
-		axis.getStartPixelOfSegmentPosition(segmentPosition + 1) - axis.getStartPixelOfSegmentPosition(segmentPosition)
+	def static getPixelSize(Axis axis) {
+		axis.getStartPixelOfSegmentPosition(axis.segmentCount) - axis.getStartPixelOfSegmentPosition(0)
 	}
 	
 	def static boolean containsPixelLocation(Axis axis, double pixelLocation) {
diff --git a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/core/layer/axis/impl/AbstractAxis.xtend b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/core/layer/axis/impl/AbstractAxis.xtend
index a11394a..676faa0 100644
--- a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/core/layer/axis/impl/AbstractAxis.xtend
+++ b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/core/layer/axis/impl/AbstractAxis.xtend
@@ -5,12 +5,12 @@
 
 abstract class AbstractAxis extends AbstractEventSourceSink implements Axis {
 
-	override getMinPixelLocation() {
-		getStartPixelOfSegmentPosition(0)
+	override getOriginPixelOfSegmentPosition(int segmentPosition) {
+		getStartPixelOfSegmentPosition(segmentPosition)
 	}
 	
-	override getPixelSize() {
-		getStartPixelOfSegmentPosition(segmentCount) - minPixelLocation
+	override getPixelSizeOfSegmentPosition(int segmentPosition) {
+		getStartPixelOfSegmentPosition(segmentPosition + 1) - getStartPixelOfSegmentPosition(segmentPosition)
 	}
 	
 }
\ No newline at end of file
diff --git a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/core/layer/axis/impl/reorder/ReorderAxis.xtend b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/core/layer/axis/impl/reorder/ReorderAxis.xtend
index a822adc..20f4ff9 100644
--- a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/core/layer/axis/impl/reorder/ReorderAxis.xtend
+++ b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/core/layer/axis/impl/reorder/ReorderAxis.xtend
@@ -6,8 +6,6 @@
 import org.eclipse.nebula.widgets.nattable.core.layer.axis.Axis
 import org.eclipse.nebula.widgets.nattable.core.layer.axis.impl.AbstractAxis
 
-import static extension org.eclipse.nebula.widgets.nattable.core.layer.axis.AxisInvariants.*
-
 /**
  * An axis that allows reordering of its segments.
  * <p>
diff --git a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/core/layer/cell/CellInvariants.xtend b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/core/layer/cell/CellInvariants.xtend
index 9eb45cd..974eebb 100644
--- a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/core/layer/cell/CellInvariants.xtend
+++ b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/core/layer/cell/CellInvariants.xtend
@@ -12,7 +12,19 @@
 	/**
 	 * @return The pixel bounds of the cell relative to its owning layer.
 	 */
-	def static getPixelBounds(Cell cell) {
+	def static getPaintBounds(Cell cell) {
+		val layer = cell.layer
+		val positionBounds = cell.positionBounds
+		
+		val startX = layer.getOriginXPixelOfColumnPosition(positionBounds.columnPosition)
+		val startY = layer.getOriginYPixelOfRowPosition(positionBounds.rowPosition)
+		val width = layer.getPixelWidthOfColumnPosition(positionBounds.columnPosition)
+		val height = layer.getPixelHeightOfRowPosition(positionBounds.rowPosition)
+		
+		new PixelRectangle(startX, startY, width, height)
+	}
+	
+	def static getClipBounds(Cell cell) {
 		val layer = cell.layer
 		val positionBounds = cell.positionBounds
 		
diff --git a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/core/layer/impl/CellLayerPainter.xtend b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/core/layer/impl/CellLayerPainter.xtend
index 16c1302..fa77393 100644
--- a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/core/layer/impl/CellLayerPainter.xtend
+++ b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/core/layer/impl/CellLayerPainter.xtend
@@ -42,10 +42,10 @@
 					
 					gc.pushState
 					
-					val cellPixelBounds = cell.adjustedPixelBounds
-					gc.clipBounds = cellPixelBounds.intersect(layerPixelBounds)
-					gc.translate(cellPixelBounds.x.doubleValue, cellPixelBounds.y.doubleValue)
-					cellPainter.paintCell(cell, new PixelArea(cellPixelBounds.width, cellPixelBounds.height), gc)
+					val cellPaintBounds = cell.adjustedPaintBounds
+					gc.clipBounds = cell.clipBounds.intersect(layerPixelBounds)
+					gc.translate(cellPaintBounds.x.doubleValue, cellPaintBounds.y.doubleValue)
+					cellPainter.paintCell(cell, new PixelArea(cellPaintBounds.width, cellPaintBounds.height), gc)
 					
 					gc.popState
 				}
@@ -54,8 +54,8 @@
 	
 	//
 	
-	def protected getAdjustedPixelBounds(Cell cell) {
-		cell.pixelBounds
+	def protected getAdjustedPaintBounds(Cell cell) {
+		cell.paintBounds
 	}
 	
 }
\ No newline at end of file
diff --git a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/core/layer/impl/GridLineCellLayerPainter.xtend b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/core/layer/impl/GridLineCellLayerPainter.xtend
index 526c9aa..631c317 100644
--- a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/core/layer/impl/GridLineCellLayerPainter.xtend
+++ b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/core/layer/impl/GridLineCellLayerPainter.xtend
@@ -25,8 +25,8 @@
 	
 	// CellLayerPainter methods
 	
-	override protected getAdjustedPixelBounds(Cell cell) {
-		val pixelBounds = super.getAdjustedPixelBounds(cell)
+	override protected getAdjustedPaintBounds(Cell cell) {
+		val pixelBounds = super.getAdjustedPaintBounds(cell)
 		
 		new PixelRectangle(
 			pixelBounds.x,
diff --git a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/core/layer/impl/composite/CompositeAxis.xtend b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/core/layer/impl/composite/CompositeAxis.xtend
index 102da85..f6b08ff 100644
--- a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/core/layer/impl/composite/CompositeAxis.xtend
+++ b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/core/layer/impl/composite/CompositeAxis.xtend
@@ -39,7 +39,7 @@
 			val subSegmentPosition = segmentPosition - segmentOffset
 			
 			if (subSegmentPosition < subAxis.segmentCount)
-				return pixelOffset + Math::max(subAxis.minPixelLocation, subAxis.getStartPixelOfSegmentPosition(subSegmentPosition))
+				return pixelOffset + subAxis.getStartPixelOfSegmentPosition(subSegmentPosition)
 			
 			segmentOffset = segmentOffset + subAxis.segmentCount
 			pixelOffset = pixelOffset + subAxis.pixelSize
@@ -48,6 +48,40 @@
 		pixelOffset
 	}
 	
+	override getOriginPixelOfSegmentPosition(int segmentPosition) {
+		var segmentOffset = 0
+		var pixelOffset = 0.0
+		
+		for (subLayer : subLayers) {
+			val subAxis = subLayer.axis
+			val subSegmentPosition = segmentPosition - segmentOffset
+			
+			if (subSegmentPosition < subAxis.segmentCount)
+				return pixelOffset + subAxis.getOriginPixelOfSegmentPosition(subSegmentPosition)
+			
+			segmentOffset = segmentOffset + subAxis.segmentCount
+			pixelOffset = pixelOffset + subAxis.pixelSize
+		}
+		
+		pixelOffset
+	}
+	
+	override getPixelSizeOfSegmentPosition(int segmentPosition) {
+		var segmentOffset = 0
+		
+		for (subLayer : subLayers) {
+			val subAxis = subLayer.axis
+			val subSegmentPosition = segmentPosition - segmentOffset
+			
+			if (subSegmentPosition < subAxis.segmentCount)
+				return subAxis.getPixelSizeOfSegmentPosition(subSegmentPosition)
+			
+			segmentOffset = segmentOffset + subAxis.segmentCount
+		}
+		
+		0
+	}
+	
 	override getSegmentPositionOfPixelLocation(double pixelLocation) {
 		if (pixelLocation < 0) return -1
 		if (pixelLocation >= pixelSize) return segmentCount
diff --git a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/core/layer/impl/viewport/ViewportAxis.xtend b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/core/layer/impl/viewport/ViewportAxis.xtend
index f2c9b61..ca391f4 100644
--- a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/core/layer/impl/viewport/ViewportAxis.xtend
+++ b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/core/layer/impl/viewport/ViewportAxis.xtend
@@ -14,7 +14,7 @@
 	val BigAxis underlyingAxis
 	val ViewportAxisListener viewportAxisListener
 	
-	BigDecimal minPixelOrigin = BigDecimal::ZERO
+	BigDecimal minPixelLocation = BigDecimal::ZERO
 	BigDecimal maxPixelSize
 	
 	/**
@@ -23,7 +23,7 @@
 	 */
 	BigDecimal visiblePixelSize = -BigDecimal::ONE
 	
-	BigDecimal pixelOrigin = BigDecimal::ZERO
+	BigDecimal viewportOrigin = BigDecimal::ZERO
 	
 	new(BigAxis underlyingAxis, ViewportAxisListener viewportAxisListener) {
 		this.underlyingAxis = underlyingAxis
@@ -32,29 +32,16 @@
 	
 	def getUnderlyingAxis() { underlyingAxis }
 	
-	def setMinPixelOrigin(double minPixelOrigin) { setMinPixelOrigin(new BigDecimal(minPixelOrigin)) }
-	def setMinPixelOrigin(BigDecimal minPixelOrigin) { this.minPixelOrigin = minPixelOrigin }
+	def setMinPixelLocation(double minPixelLocation) { setMinPixelLocation(new BigDecimal(minPixelLocation)) }
+	def setMinPixelLocation(BigDecimal minPixelLocation) { this.minPixelLocation = minPixelLocation }
 	def setMaxPixelSize(double maxPixelSize) { setMaxPixelSize(new BigDecimal(maxPixelSize)) }
 	def setMaxPixelSize(BigDecimal maxPixelSize) { this.maxPixelSize = maxPixelSize }
 	
-	override getMinPixelLocation() {
-		if (minPixelOrigin != null)
-			minPixelOrigin.doubleValue
-		else
-			super.minPixelLocation
-	}
-	
-	override getPixelSize() {
-		if (maxPixelSize != null)
-			maxPixelSize.doubleValue
-		else
-			super.pixelSize
-	}
-	
 	def getVisiblePixelSize() {
 		val pixelSize =
 			if (visiblePixelSize >= BigDecimal::ZERO) visiblePixelSize
 			else underlyingAxis.pixelSize
+		
 		if (maxPixelSize != null)
 			pixelSize.min(maxPixelSize)
 		else
@@ -69,32 +56,32 @@
 		this.visiblePixelSize = visiblePixelSize
 	}
 	
-	def getPixelOrigin() { pixelOrigin }
+	def getViewportOrigin() { viewportOrigin }
 	
-	def void setPixelOrigin(double pixelOrigin) {
-		setPixelOrigin(new BigDecimal(pixelOrigin))
+	def void setViewportOrigin(double viewportOrigin) {
+		setViewportOrigin(new BigDecimal(viewportOrigin))
 	}
 	
-	def void setPixelOrigin(BigDecimal pixelOrigin) {
-		this.pixelOrigin = pixelOrigin
+	def void setViewportOrigin(BigDecimal viewportOrigin) {
+		this.viewportOrigin = viewportOrigin
 		viewportAxisListener?.viewportAxisChanged
 	}
 	
 	def getOriginSegmentPosition() {
-		underlyingAxis.getSegmentPositionOfPixelLocation(pixelOrigin)
+		underlyingAxis.getSegmentPositionOfPixelLocation(viewportOrigin)
 	}
 	
 	def void handleResize() {
 		// If the visible pixel size is greater than the content size, move origin to fill as much content as possible.
-		val additionalSize = pixelOrigin + getVisiblePixelSize - underlyingAxis.pixelSize
+		val additionalSize = viewportOrigin + getVisiblePixelSize - underlyingAxis.pixelSize
 		if (additionalSize > BigDecimal::ZERO)
-			pixelOrigin = BigDecimal::ZERO.max(pixelOrigin - additionalSize)
+			viewportOrigin = BigDecimal::ZERO.max(viewportOrigin - additionalSize)
 	}
 	
 	// Layer interface
 	
 	override getSegmentCount() {
-		val endPixel = pixelOrigin + getVisiblePixelSize
+		val endPixel = viewportOrigin + getVisiblePixelSize
 		val endSegmentPosition = underlyingAxis.getSegmentPositionOfPixelLocation(endPixel)
 		val isEndPixelInsideEndSegment = endPixel > underlyingAxis.getStartPixelOfSegmentPosition(endSegmentPosition) && endPixel < underlyingAxis.getStartPixelOfSegmentPosition(underlyingAxis.segmentCount)
 		val segmentCount = endSegmentPosition - originSegmentPosition
@@ -102,11 +89,27 @@
 	}
 	
 	override getStartPixelOfSegmentPosition(int segmentPosition) {
-		(underlyingAxis.getStartPixelOfSegmentPosition(originSegmentPosition + BigInteger::valueOf(segmentPosition)) - pixelOrigin).doubleValue
+		if (minPixelLocation != null && segmentPosition == 0)
+			minPixelLocation.doubleValue
+		else if (maxPixelSize != null && segmentPosition == segmentCount)
+			getStartPixelOfSegmentPosition(0) + maxPixelSize
+		else
+			(underlyingAxis.getStartPixelOfSegmentPosition(originSegmentPosition + BigInteger::valueOf(segmentPosition)) - viewportOrigin).doubleValue
+	}
+	
+	override getOriginPixelOfSegmentPosition(int segmentPosition) {
+		(underlyingAxis.getOriginPixelOfSegmentPosition(originSegmentPosition + BigInteger::valueOf(segmentPosition)) - viewportOrigin).doubleValue
+	}
+	
+	override getPixelSizeOfSegmentPosition(int segmentPosition) {
+		if (maxPixelSize != null && segmentPosition == segmentCount - 1)
+			maxPixelSize.doubleValue
+		else
+			underlyingAxis.getPixelSizeOfSegmentPosition(originSegmentPosition + BigInteger::valueOf(segmentPosition)).doubleValue
 	}
 	
 	override getSegmentPositionOfPixelLocation(double pixelLocation) {
-		val underlyingPixelLocation = pixelOrigin + BigDecimal::valueOf(pixelLocation)
+		val underlyingPixelLocation = viewportOrigin + BigDecimal::valueOf(pixelLocation)
 		if (underlyingPixelLocation < BigDecimal::ZERO) return -1
 		if (underlyingPixelLocation >= underlyingAxis.pixelSize) return getSegmentCount()
 		(underlyingAxis.getSegmentPositionOfPixelLocation(underlyingPixelLocation) - originSegmentPosition).intValueExact
diff --git a/org.eclipse.nebula.widgets.nattable.renderer.swt.test/src/org/eclipse/nebula/widgets/nattable/renderer/swt/layer/viewport/ScrollBarHandlerRangeLargerThanIntTest.xtend b/org.eclipse.nebula.widgets.nattable.renderer.swt.test/src/org/eclipse/nebula/widgets/nattable/renderer/swt/layer/viewport/ScrollBarHandlerRangeLargerThanIntTest.xtend
index 954346e..c454922 100644
--- a/org.eclipse.nebula.widgets.nattable.renderer.swt.test/src/org/eclipse/nebula/widgets/nattable/renderer/swt/layer/viewport/ScrollBarHandlerRangeLargerThanIntTest.xtend
+++ b/org.eclipse.nebula.widgets.nattable.renderer.swt.test/src/org/eclipse/nebula/widgets/nattable/renderer/swt/layer/viewport/ScrollBarHandlerRangeLargerThanIntTest.xtend
@@ -39,7 +39,7 @@
 	
 	@Test
 	def void viewportAtEnd() {
-		viewportAxis.pixelOrigin = new BigDecimal(200 * QUADRILLION - 1)
+		viewportAxis.viewportOrigin = new BigDecimal(200 * QUADRILLION - 1)
 		scrollBarHandler.recalculateScrollBarSize
 
 		verify(scrollBar).maximum = ScrollBarHandler::MAX_SCROLL_SIZE
@@ -55,7 +55,7 @@
 		scrollBarHandler.updateViewportOrigin
 		
 		val mathContext = new MathContext(15)
-		assertEquals(new BigDecimal((1.0 / (ScrollBarHandler::MAX_SCROLL_SIZE - 10)) * (200 * QUADRILLION - 500)).round(mathContext), viewportAxis.pixelOrigin.round(mathContext))
+		assertEquals(new BigDecimal((1.0 / (ScrollBarHandler::MAX_SCROLL_SIZE - 10)) * (200 * QUADRILLION - 500)).round(mathContext), viewportAxis.viewportOrigin.round(mathContext))
 	}
 	
 	@Test
@@ -63,7 +63,7 @@
 		when(scrollBar.selection).thenReturn(Integer::MAX_VALUE - 10)
 		scrollBarHandler.updateViewportOrigin
 		
-		assertTrue('''viewport origin «viewportAxis.pixelOrigin» + visible pixel size «viewportAxis.visiblePixelSize» should be >= underlying axis pixel size «viewportAxis.underlyingAxis.pixelSize»''', viewportAxis.pixelOrigin + viewportAxis.visiblePixelSize >= new BigDecimal(200 * QUADRILLION))
+		assertTrue('''viewport origin «viewportAxis.viewportOrigin» + visible pixel size «viewportAxis.visiblePixelSize» should be >= underlying axis pixel size «viewportAxis.underlyingAxis.pixelSize»''', viewportAxis.viewportOrigin + viewportAxis.visiblePixelSize >= new BigDecimal(200 * QUADRILLION))
 	}
 	
 }
\ No newline at end of file
diff --git a/org.eclipse.nebula.widgets.nattable.renderer.swt.test/src/org/eclipse/nebula/widgets/nattable/renderer/swt/layer/viewport/ScrollBarHandlerRangeSmallerThanIntTest.xtend b/org.eclipse.nebula.widgets.nattable.renderer.swt.test/src/org/eclipse/nebula/widgets/nattable/renderer/swt/layer/viewport/ScrollBarHandlerRangeSmallerThanIntTest.xtend
index 9029f22..1379404 100644
--- a/org.eclipse.nebula.widgets.nattable.renderer.swt.test/src/org/eclipse/nebula/widgets/nattable/renderer/swt/layer/viewport/ScrollBarHandlerRangeSmallerThanIntTest.xtend
+++ b/org.eclipse.nebula.widgets.nattable.renderer.swt.test/src/org/eclipse/nebula/widgets/nattable/renderer/swt/layer/viewport/ScrollBarHandlerRangeSmallerThanIntTest.xtend
@@ -31,7 +31,7 @@
 	
 	@Test
 	def void viewportAtEnd() {
-		viewportAxis.pixelOrigin = 1999
+		viewportAxis.viewportOrigin = 1999
 		scrollBarHandler.recalculateScrollBarSize
 		
 		verify(scrollBar).maximum = 2000  // axis pixel size
@@ -46,7 +46,7 @@
 		when(scrollBar.selection).thenReturn(1)
 		scrollBarHandler.updateViewportOrigin
 		
-		assertEquals(BigDecimal::ONE, viewportAxis.pixelOrigin)
+		assertEquals(BigDecimal::ONE, viewportAxis.viewportOrigin)
 	}
 	
 	@Test
@@ -54,7 +54,7 @@
 		when(scrollBar.selection).thenReturn(1990)
 		scrollBarHandler.updateViewportOrigin
 		
-		assertTrue('''viewport origin «viewportAxis.pixelOrigin» + visible pixel size «viewportAxis.visiblePixelSize» should be >= underlying axis pixel size «viewportAxis.underlyingAxis.pixelSize»''', viewportAxis.pixelOrigin + viewportAxis.visiblePixelSize >= BigDecimal::valueOf(2000))
+		assertTrue('''viewport origin «viewportAxis.viewportOrigin» + visible pixel size «viewportAxis.visiblePixelSize» should be >= underlying axis pixel size «viewportAxis.underlyingAxis.pixelSize»''', viewportAxis.viewportOrigin + viewportAxis.visiblePixelSize >= BigDecimal::valueOf(2000))
 	}
 	
 }
\ No newline at end of file
diff --git a/org.eclipse.nebula.widgets.nattable.renderer.swt/src/org/eclipse/nebula/widgets/nattable/renderer/swt/layer/viewport/ScrollBarHandler.xtend b/org.eclipse.nebula.widgets.nattable.renderer.swt/src/org/eclipse/nebula/widgets/nattable/renderer/swt/layer/viewport/ScrollBarHandler.xtend
index e1bf49e..54b21dd 100644
--- a/org.eclipse.nebula.widgets.nattable.renderer.swt/src/org/eclipse/nebula/widgets/nattable/renderer/swt/layer/viewport/ScrollBarHandler.xtend
+++ b/org.eclipse.nebula.widgets.nattable.renderer.swt/src/org/eclipse/nebula/widgets/nattable/renderer/swt/layer/viewport/ScrollBarHandler.xtend
@@ -8,7 +8,6 @@
 
 import static extension java.lang.Math.*
 import static extension org.eclipse.nebula.widgets.nattable.core.big.layer.axis.BigAxisInvariants.*
-import static extension org.eclipse.nebula.widgets.nattable.core.layer.axis.AxisInvariants.*
 
 class ScrollBarHandler implements Listener {
 	
@@ -63,7 +62,7 @@
 				else
 					(maxScrollSize - thumbSize) / (maxPixelSize - visiblePixelSize)
 		
-		viewportAxis.pixelOrigin = new BigDecimal(scrollBar.selection) / intPerPixelRatio
+		viewportAxis.viewportOrigin = new BigDecimal(scrollBar.selection) / intPerPixelRatio
 	}
 	
 	/**
@@ -84,7 +83,7 @@
 				else
 					(maxScrollSize - thumbSize) / (maxPixelSize - visiblePixelSize)
 		
-		val viewportOrigin = viewportAxis.pixelOrigin
+		val viewportOrigin = viewportAxis.viewportOrigin
 		
 		if (visiblePixelSize > BigDecimal::ZERO && viewportOrigin < maxPixelSize) {
 			scrollBar.maximum = maxScrollSize.intValue