refactoring axis api: origin pixel location & pixel size of segment
position
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
