Introduce OfFloat classes for better scaling eclipse-platform#62

This commit introduces Rectangle.OfFloat and Point.OfFloat classes as an
extension of Rectangle and Point respectively to improve scaling
precision in the DPIUtil by using residuals obtained from rounding.

Contributes to
eclipse-platform#62 and
eclipse-platform#128

Author: amartya4256

bundles/org.eclipse.swt/Eclipse SWT Tests/win32/org/eclipse/swt/widgets/ControlWin32Tests.java

@@ -100,11 +100,11 @@ public void testCorrectScaleUpUsingDifferentSetBoundsMethod() {
 
 		button.setBounds(new Rectangle(0, 47, 200, 47));
 		assertEquals("Control::setBounds(Rectangle) doesn't scale up correctly",
-				new Rectangle(0, 82, 350, 83), button.getBoundsInPixels());
+				new Rectangle(0, 82, 350, 82), button.getBoundsInPixels());
 
 		button.setBounds(0, 47, 200, 47);
 		assertEquals("Control::setBounds(int, int, int, int) doesn't scale up correctly",
-				new Rectangle(0, 82, 350, 83), button.getBoundsInPixels());
+				new Rectangle(0, 82, 350, 82), button.getBoundsInPixels());
 	}
 
 	record FontComparison(int originalFontHeight, int currentFontHeight) {

bundles/org.eclipse.swt/Eclipse SWT/common/org/eclipse/swt/graphics/Point.java

@@ -43,7 +43,7 @@
  * @see <a href="http://www.eclipse.org/swt/">Sample code and further information</a>
  */
 
-public sealed class Point implements Serializable permits Point.WithMonitor {
+public sealed class Point implements Serializable permits Point.OfFloat {
 
 	/**
 	 * the x coordinate of the point
@@ -120,14 +120,56 @@ public String toString () {
 
 /**
  * Instances of this class represent {@link org.eclipse.swt.graphics.Point}
+ * objects with the fields capable of storing more precise value in float.
+ *
+ * @since 3.131
+ * @noreference This class is not intended to be referenced by clients
+ */
+public static sealed class OfFloat extends Point permits Point.WithMonitor {
+
+	private static final long serialVersionUID = -1862062276431597053L;
+
+	public float residualX, residualY;
+
+	public OfFloat(int x, int y) {
+		super(x, y);
+	}
+
+	public OfFloat(float x, float y) {
+		super(Math.round(x), Math.round(y));
+		this.residualX = x - this.x;
+		this.residualY = y - this.y;
+	}
+
+	public float getX() {
+		return x + residualX;
+	}
+
+	public float getY() {
+		return y + residualY;
+	}
+
+	public void setX(float x) {
+		this.x = Math.round(x);
+		this.residualX = x - this.x;
+	}
+
+	public void setY(float y) {
+		this.y = Math.round(y);
+		this.residualY = y - this.y;
+	}
+}
+
+/**
+ * Instances of this class represent {@link org.eclipse.swt.graphics.Point.OfFloat}
  * objects along with the context of the monitor in relation to which they are
  * placed on the display. The monitor awareness makes it easy to scale and
  * translate the points between pixels and points.
  *
  * @since 3.131
  * @noreference This class is not intended to be referenced by clients
  */
-public static final class WithMonitor extends Point {
+public static final class WithMonitor extends Point.OfFloat {
 
 	private static final long serialVersionUID = 6077427420686999194L;
 
@@ -155,4 +197,3 @@ public Monitor getMonitor() {
 }
 
 }
-

bundles/org.eclipse.swt/Eclipse SWT/common/org/eclipse/swt/graphics/Rectangle.java

@@ -46,7 +46,7 @@
  * @see <a href="http://www.eclipse.org/swt/">Sample code and further information</a>
  */
 
-public sealed class Rectangle implements Serializable, Cloneable permits Rectangle.WithMonitor {
+public sealed class Rectangle implements Serializable, Cloneable permits Rectangle.OfFloat {
 
 	/**
 	 * the x coordinate of the rectangle
@@ -375,7 +375,7 @@ public Rectangle union (Rectangle rect) {
  */
 public static Rectangle of(Point topLeft, int width, int height) {
 	if (topLeft instanceof Point.WithMonitor monitorAwareTopLeft) {
-		return new Rectangle.WithMonitor(topLeft.x, topLeft.y, width, height, monitorAwareTopLeft.getMonitor());
+		return new Rectangle.WithMonitor(monitorAwareTopLeft.getX(), monitorAwareTopLeft.getY(), width, height, monitorAwareTopLeft.getMonitor());
 	}
 	return new Rectangle(topLeft.x, topLeft.y, width, height);
 }
@@ -400,14 +400,77 @@ public Rectangle clone() {
 
 /**
  * Instances of this class represent {@link org.eclipse.swt.graphics.Rectangle}
+ * objects which supports values of Float type for it's fields
+ *
+ * @since 3.131
+ * @noreference This class is not intended to be referenced by clients
+ */
+public static sealed class OfFloat extends Rectangle permits Rectangle.WithMonitor {
+
+	private static final long serialVersionUID = -3006999002677468391L;
+
+	private float residualX, residualY, residualWidth, residualHeight;
+
+	public OfFloat(int x, int y, int width, int height) {
+		super(x, y, width, height);
+	}
+
+	public OfFloat(float x, float y, float width, float height) {
+		super(Math.round(x), Math.round(y), Math.round(width), Math.round(height));
+		this.residualX = x - this.x;
+		this.residualY = y - this.y;
+		this.residualWidth = width - this.width;
+		this.residualHeight = height - this.height;
+	}
+
+	public float getX() {
+		return x + residualX;
+	}
+
+	public float getY() {
+		return y + residualY;
+	}
+
+	public float getWidth() {
+		return width + residualWidth;
+	}
+
+	public float getHeight() {
+		return height + residualHeight;
+	}
+
+	public void setX(float x) {
+		this.x = Math.round(x);
+		this.residualX = x - this.x;
+	}
+
+	public void setY(float y) {
+		this.y = Math.round(y);
+		this.residualY = y - this.y;
+	}
+
+	public void setWidth(float width) {
+		this.width = Math.round(width);
+		this.residualWidth = width - this.width;
+	}
+
+	public void setHeight(float height) {
+		this.height = Math.round(height);
+		this.residualHeight = height - this.height;
+	}
+
+}
+
+/**
+ * Instances of this class represent {@link org.eclipse.swt.graphics.Rectangle.OfFloat}
  * objects along with the context of the monitor in relation to which they are
  * placed on the display. The monitor awareness makes it easy to scale and
  * translate the rectangles between pixels and points.
  *
  * @since 3.131
  * @noreference This class is not intended to be referenced by clients
  */
-public static final class WithMonitor extends Rectangle {
+public static final class WithMonitor extends Rectangle.OfFloat {
 
 	private static final long serialVersionUID = 5041911840525116925L;
 
@@ -427,6 +490,11 @@ public WithMonitor(int x, int y, int width, int height, Monitor monitor) {
 		this.monitor = monitor;
 	}
 
+	private WithMonitor(float x, float y, float width, float height, Monitor monitor) {
+		super(x, y, width, height);
+		this.monitor = monitor;
+	}
+
 	/**
 	 * {@return the monitor with whose context the instance is created}
 	 */
@@ -436,8 +504,8 @@ public Monitor getMonitor() {
 
 	@Override
 	public Rectangle.WithMonitor clone() {
-		return new Rectangle.WithMonitor(x, y, width, height, monitor);
+		return new Rectangle.WithMonitor(getX(), getY(), getWidth(), getHeight(), monitor);
 	}
 
 }
-}
+}

bundles/org.eclipse.swt/Eclipse SWT/common/org/eclipse/swt/internal/DPIUtil.java

@@ -228,11 +228,11 @@ public static Point autoScaleDown(Point point) {
 
 public static Point scaleDown(Point point, int zoom) {
 	if (zoom == 100 || point == null) return point;
+	Point.OfFloat fPoint = FloatAwareGeometryFactory.createFrom(point);
 	float scaleFactor = getScalingFactor(zoom);
-	Point scaledPoint = new Point (0,0);
-	scaledPoint.x = Math.round (point.x / scaleFactor);
-	scaledPoint.y = Math.round (point.y / scaleFactor);
-	return scaledPoint;
+	float scaledX = fPoint.getX() / scaleFactor;
+	float scaledY = fPoint.getY() / scaleFactor;
+	return new Point.OfFloat(scaledX, scaledY);
 }
 
 /**
@@ -255,16 +255,7 @@ public static Rectangle autoScaleDown(Rectangle rect) {
 }
 
 public static Rectangle scaleDown(Rectangle rect, int zoom) {
-	if (zoom == 100 || rect == null) return rect;
-	Rectangle scaledRect = new Rectangle (0,0,0,0);
-	Point scaledTopLeft = scaleDown(new Point (rect.x, rect.y), zoom);
-	Point scaledBottomRight = scaleDown(new Point (rect.x + rect.width, rect.y + rect.height), zoom);
-
-	scaledRect.x = scaledTopLeft.x;
-	scaledRect.y = scaledTopLeft.y;
-	scaledRect.width = scaledBottomRight.x - scaledTopLeft.x;
-	scaledRect.height = scaledBottomRight.y - scaledTopLeft.y;
-	return scaledRect;
+	return scaleBounds(rect, 100, zoom);
 }
 /**
  * Returns a new scaled down Rectangle if enabled for Drawable class.
@@ -333,13 +324,13 @@ public static boolean isSmoothScalingEnabled() {
  */
 public static Rectangle scaleBounds (Rectangle rect, int targetZoom, int currentZoom) {
 	if (rect == null || targetZoom == currentZoom) return rect;
+	Rectangle.OfFloat fRect = FloatAwareGeometryFactory.createFrom(rect);
 	float scaleFactor = ((float)targetZoom) / (float)currentZoom;
-	Rectangle returnRect = new Rectangle (0,0,0,0);
-	returnRect.x = Math.round (rect.x * scaleFactor);
-	returnRect.y = Math.round (rect.y * scaleFactor);
-	returnRect.width = Math.round (rect.width * scaleFactor);
-	returnRect.height = Math.round (rect.height * scaleFactor);
-	return returnRect;
+	float scaledX = fRect.getX() * scaleFactor;
+	float scaledY = fRect.getY() * scaleFactor;
+	float scaledWidth = fRect.getWidth() * scaleFactor;
+	float scaledHeight = fRect.getHeight() * scaleFactor;
+	return new Rectangle.OfFloat(scaledX, scaledY, scaledWidth, scaledHeight);
 }
 
 /**
@@ -436,11 +427,11 @@ public static Point autoScaleUp(Point point) {
 
 public static Point scaleUp(Point point, int zoom) {
 	if (zoom == 100 || point == null) return point;
+	Point.OfFloat fPoint = FloatAwareGeometryFactory.createFrom(point);
 	float scaleFactor = getScalingFactor(zoom);
-	Point scaledPoint = new Point(0,0);
-	scaledPoint.x = Math.round (point.x * scaleFactor);
-	scaledPoint.y = Math.round (point.y * scaleFactor);
-	return scaledPoint;
+	float scaledX = fPoint.getX() * scaleFactor;
+	float scaledY = fPoint.getY() * scaleFactor;
+	return new Point.OfFloat(scaledX, scaledY);
 }
 
 /**
@@ -463,16 +454,7 @@ public static Rectangle autoScaleUp(Rectangle rect) {
 }
 
 public static Rectangle scaleUp(Rectangle rect, int zoom) {
-	if (zoom == 100 || rect == null) return rect;
-	Rectangle scaledRect = new Rectangle(0,0,0,0);
-	Point scaledTopLeft = scaleUp (new Point(rect.x, rect.y), zoom);
-	Point scaledBottomRight = scaleUp (new Point(rect.x + rect.width, rect.y + rect.height), zoom);
-
-	scaledRect.x = scaledTopLeft.x;
-	scaledRect.y = scaledTopLeft.y;
-	scaledRect.width = scaledBottomRight.x - scaledTopLeft.x;
-	scaledRect.height = scaledBottomRight.y - scaledTopLeft.y;
-	return scaledRect;
+	return scaleBounds(rect, zoom, 100);
 }
 
 /**
@@ -751,4 +733,20 @@ public ImageData getImageData(int zoom) {
 		return DPIUtil.scaleImageData(device, imageData, zoom, currentZoom);
 	}
 }
+
+private class FloatAwareGeometryFactory {
+	static Rectangle.OfFloat createFrom(Rectangle rectangle) {
+		if (rectangle instanceof Rectangle.OfFloat) {
+			return (Rectangle.OfFloat) rectangle;
+		}
+		return new Rectangle.OfFloat(rectangle.x, rectangle.y, rectangle.width, rectangle.height);
+	}
+
+	static Point.OfFloat createFrom(Point point) {
+		if (point instanceof Point.OfFloat) {
+			return (Point.OfFloat) point;
+		}
+		return new Point.OfFloat(point.x, point.y);
+	}
+}
 }

tests/org.eclipse.swt.tests/JUnit Tests/org/eclipse/swt/tests/junit/DPIUtilTests.java

@@ -319,4 +319,40 @@ public void scaleUpRectangle() {
 		scaledValue = DPIUtil.scaleUp((Device) null, valueAt100, 100);
 		assertSame(valueAt100, scaledValue, "Scaling up Rectangle without zoom change with device failed");
 	}
+
+	@Test
+	public void scaleDownscaleUpRectangleInvertible() {
+		int[] zooms = new int[] {25, 50, 75, 100, 125, 150, 175, 200, 225, 250, 275, 300, 325, 350, 375, 400};
+		for (int zoom1 : zooms) {
+			for (int zoom2 : zooms) {
+				for (int i = 1; i <= 10000; i++) {
+					Rectangle rect = new Rectangle(0, 0, i, i);
+					Rectangle scaleDown = DPIUtil.scaleDown(rect, zoom1);
+					Rectangle scaleUp = DPIUtil.scaleUp(scaleDown, zoom2);
+					scaleDown = DPIUtil.scaleDown(scaleUp, zoom2);
+					scaleUp = DPIUtil.scaleUp(scaleDown, zoom1);
+					assertEquals(rect.width, scaleUp.width);
+					assertEquals(rect.height, scaleUp.height);
+				}
+			}
+		}
+	}
+
+	@Test
+	public void scaleDownscaleUpPointInvertible() {
+		int[] zooms = new int[] {25, 50, 75, 100, 125, 150, 175, 200, 225, 250, 275, 300, 325, 350, 375, 400};
+		for (int zoom1 : zooms) {
+			for (int zoom2 : zooms) {
+				for (int i = 1; i <= 10000; i++) {
+					Point pt = new Point(i, i);
+					Point scaleDown = DPIUtil.scaleDown(pt, zoom1);
+					Point scaleUp = DPIUtil.scaleUp(scaleDown, zoom2);
+					scaleDown = DPIUtil.scaleDown(scaleUp, zoom2);
+					scaleUp = DPIUtil.scaleUp(scaleDown, zoom1);
+					assertEquals(pt.x, scaleUp.x);
+					assertEquals(pt.y, scaleUp.y);
+				}
+			}
+		}
+	}
 }