Fix GC#drawImage + ImageGcDrawer for Cropping and Scaling

The GC#drawImage method takes
(image, srcX, srcY, srcWidth, srcHeight, destX, destY, destWidth, destHeight)
as arguments and crops and scales from the source region to the destination
region.

Passing an image drawn via ImageGCDrawer led to the following issue:

The image handle from the subcall is resolved using the monitor zoom
(data.nativeZoom) and the calculated scaledImageZoom (gcZoom * scaleFactor).
This handle corresponds to an ImageData initialized at scaledImageZoom,
whereas the drawings of the second GC are performed using the monitor zoom,
subject to the auto-scale property.

This mismatch results in unaligned sizing of drawings. For example, a 200%
monitor zoom combined with a scale factor of 0.5 produces a scaledImageZoom of
100%. As a result, the ImageData is initialized at 100%, while drawing occurs
at 200%. This exact case is demonstrated in
vi-eclipse/Eclipse-Platform#554
.

Furthermore, the calculation of scaledImageZoom uses fallback logic that only
allows 100% and 200% as possible outcomes, which is clearly unintended in this
context.

The fix delegates resolving the correct handle to the Image class by passing
the width/height of the full image scaled by the scaledImageZoom. This
is a space on where scaled src coordinates/width/height lie. A callback
then creates a new handle for the height/width and respects the auto-scale property.

If the returned handle matches the full image scaled to the requested
scaledImageZoom in width and height, the source region
coordinates/width/height are passed directly in pixels at that zoom. Otherwise,
the internal zoom factor is derived from the returned handle’s width relative to
the full image, and the source region coordinates are converted to pixel values
using this internal zoom.

Additionally, if a transform is applied via the GC, then both drawImage
APIs consider now the best fitting handle by requesting it through the
width/height of the full image scaled by the scaleFactor (relating
destination width/height to source width/height) times the width/height scaling induced by
the transformation.

Author: al-noori

bundles/org.eclipse.swt/Eclipse SWT/win32/org/eclipse/swt/graphics/GC.java

@@ -15,16 +15,13 @@
 
 
 import java.util.*;
-import java.util.List;
 import java.util.function.*;
-import java.util.stream.*;
 
 import org.eclipse.swt.*;
 import org.eclipse.swt.graphics.Image.*;
 import org.eclipse.swt.internal.*;
 import org.eclipse.swt.internal.gdip.*;
 import org.eclipse.swt.internal.win32.*;
-import org.eclipse.swt.widgets.*;
 
 /**
  * Class <code>GC</code> is where all of the drawing capabilities that are
@@ -1183,15 +1180,6 @@ void apply() {
 		drawImage(getImage(), source.x, source.y, source.width, source.height, destination.x, destination.y, destination.width, destination.height, gcZoom, srcImageZoom);
 	}
 
-	private Collection<Integer> getAllCurrentMonitorZooms() {
-		if (device instanceof Display display) {
-			return Arrays.stream(display.getMonitors())
-				.map(Monitor::getZoom)
-				.collect(Collectors.toSet());
-		}
-		return Collections.emptySet();
-	}
-
 	private int calculateZoomForImage(int gcZoom, int srcWidth, int srcHeight, int destWidth, int destHeight) {
 		if (srcWidth == 1 && srcHeight == 1) {
 			// One pixel images can use the GC zoom
@@ -1207,13 +1195,7 @@ private int calculateZoomForImage(int gcZoom, int srcWidth, int srcHeight, int d
 
 		float imageScaleFactor = 1f * destWidth / srcWidth;
 		int imageZoom = Math.round(gcZoom * imageScaleFactor);
-		if (getAllCurrentMonitorZooms().contains(imageZoom)) {
-			return imageZoom;
-		}
-		if (imageZoom > 150) {
-			return 200;
-		}
-		return 100;
+		return imageZoom;
 	}
 }
 
@@ -1232,37 +1214,76 @@ void apply() {
 	}
 }
 
+private float calculateTransformationScale() {
+	Transform current = new Transform(device);
+	getTransform(current);
+	float[] m = new float[6];
+	current.getElements(m);
+	float scaleWidth = (float) Math.hypot(m[0], m[2]);
+	float scaleHeight = (float) Math.hypot(m[1], m[3]);
+	return Math.max(scaleWidth, scaleHeight);
+}
+
 private void drawImage(Image image, int destX, int destY, int destWidth, int destHeight, int imageZoom) {
-	Rectangle destPixels = Win32DPIUtils.pointToPixel(drawable, new Rectangle(destX, destY, destWidth, destHeight),
+	float transformationScale = calculateTransformationScale();
+	int scaledImageZoomWithTransform = Math.round(transformationScale * imageZoom);
+	Rectangle destPixelsScaledWithTransform = Win32DPIUtils.pointToPixel(drawable, new Rectangle(destX , destY, destWidth , destHeight),
+			scaledImageZoomWithTransform);
+	Rectangle destPixels= Win32DPIUtils.pointToPixel(drawable, new Rectangle(destX , destY, destWidth , destHeight),
 			imageZoom);
 	image.executeOnImageHandleAtBestFittingSize(tempHandle -> {
 		drawImage(image, 0, 0, tempHandle.getWidth(), tempHandle.getHeight(), destPixels.x, destPixels.y,
 				destPixels.width, destPixels.height, false, tempHandle);
-	}, destPixels.width, destPixels.height);
+	}, destPixelsScaledWithTransform.width, destPixelsScaledWithTransform.height);
 }
 
 private void drawImage(Image image, int srcX, int srcY, int srcWidth, int srcHeight, int destX, int destY,
 		int destWidth, int destHeight, int imageZoom, int scaledImageZoom) {
 	Rectangle src = Win32DPIUtils.pointToPixel(drawable, new Rectangle(srcX, srcY, srcWidth, srcHeight), scaledImageZoom);
 	Rectangle dest = Win32DPIUtils.pointToPixel(drawable, new Rectangle(destX, destY, destWidth, destHeight), imageZoom);
+	Rectangle fullImageBounds = image.getBounds();
+	Rectangle fullImageBoundsScaled = Win32DPIUtils.pointToPixel(drawable, fullImageBounds, scaledImageZoom);
+	float transformationScale = calculateTransformationScale();
+	int scaledImageZoomWithTransform = Math.round(transformationScale * scaledImageZoom);
+	Rectangle fullImageBoundsScaledWithTransform = Win32DPIUtils.pointToPixel(drawable, fullImageBounds, scaledImageZoomWithTransform);
+	Rectangle unscaledSrc =  new Rectangle(srcX, srcY, srcWidth, srcHeight);
 	if (scaledImageZoom != 100) {
 		/*
 		 * This is a HACK! Due to rounding errors at fractional scale factors,
 		 * the coordinates may be slightly off. The workaround is to restrict
 		 * coordinates to the allowed bounds.
 		 */
-		Rectangle b = image.getBounds(scaledImageZoom);
-		int errX = src.x + src.width - b.width;
-		int errY = src.y + src.height - b.height;
+		int errX = src.x + src.width - fullImageBoundsScaled.width;
+		int errY = src.y + src.height - fullImageBoundsScaled.height;
 		if (errX != 0 || errY != 0) {
 			if (errX <= scaledImageZoom / 100 && errY <= scaledImageZoom / 100) {
-				src.intersect(b);
+				src.intersect(fullImageBoundsScaled);
 			} else {
 				SWT.error (SWT.ERROR_INVALID_ARGUMENT);
 			}
 		}
 	}
-	drawImage(image, src.x, src.y, src.width, src.height, dest.x, dest.y, dest.width, dest.height, false, image.getHandle(scaledImageZoom, data.nativeZoom));
+	image.executeOnImageHandleAtBestFittingSize((tempHandle) -> {
+		Rectangle newSrc = computeSourceRectangle(tempHandle, fullImageBounds, fullImageBoundsScaled, unscaledSrc, src);
+		drawImage(image, newSrc.x, newSrc.y, newSrc.width, newSrc.height, dest.x, dest.y, dest.width,
+				dest.height, false, tempHandle);
+	}, fullImageBoundsScaledWithTransform.width, fullImageBoundsScaledWithTransform.height);
+}
+
+private Rectangle computeSourceRectangle(ImageHandle imageHandle, Rectangle fullImageBounds, Rectangle fullImageBoundsScaled, Rectangle unscaledSrc, Rectangle src) {
+	if (new Rectangle(0, 0, imageHandle.getWidth(), imageHandle.getHeight()).equals(fullImageBoundsScaled)) {
+		return src;
+	} else {
+		/*
+		 *  the achieved handle with its drawings has not the required size, thus we calculate the zoom of the handle
+		 *
+		 * with respect to the full 100% image. The point values (x,y,width,height) of the source "part" of the full image will
+		 * be computed to pixels by this zoom.
+		 */
+		float scaleFactor = 1f * imageHandle.getWidth() / fullImageBounds.width;
+		int closestZoomOfHandle = Math.round(scaleFactor * 100);
+		return Win32DPIUtils.pointToPixel(drawable, unscaledSrc, closestZoomOfHandle);
+	}
 }
 
 private class DrawImageToImageOperation extends ImageOperation {
@@ -5810,7 +5831,7 @@ void apply() {
  * Returns the extent of the given string. No tab
  * expansion or carriage return processing will be performed.
  * <p>
- * The <em>extent</em> of a string is the width and height of
+ * The <em>extent</em> ofbut  a string is the width and height of
  * the rectangular area it would cover if drawn in a particular
  * font (in this case, the current font in the receiver).
  * </p>