GC#drawImage methods now consider applied Transformations

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 winowdth/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

@@ -1193,7 +1193,7 @@ private int calculateZoomForImage(int gcZoom, int srcWidth, int srcHeight, int d
 			return gcZoom;
 		}
 
-		float imageScaleFactor = 1f * destWidth / srcWidth;
+		float imageScaleFactor = Math.max(1f * destWidth / srcWidth, 1f * destHeight / srcHeight);
 		int imageZoom = Math.round(gcZoom * imageScaleFactor);
 		return imageZoom;
 	}
@@ -1214,59 +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]);
+	current.dispose();
+	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 destPixels = Win32DPIUtils.pointToPixel(drawable, new Rectangle(destX , destY, destWidth , destHeight),
 			imageZoom);
+	Rectangle destPixelsScaledWithTransform = Win32DPIUtils.pointToPixel(drawable, new Rectangle(destX , destY, destWidth , destHeight),
+			scaledImageZoomWithTransform);
 
 	image.executeOnImageHandleAtBestFittingSize(tempHandle -> {
 		drawImage(image, 0, 0, tempHandle.width(), tempHandle.height(), 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 srcPixels = Win32DPIUtils.pointToPixel(drawable, new Rectangle(srcX, srcY, srcWidth, srcHeight), scaledImageZoom);
+	Rectangle destPixels = Win32DPIUtils.pointToPixel(drawable, new Rectangle(destX, destY, destWidth, destHeight), imageZoom);
 	Rectangle fullImageBounds = image.getBounds();
-	Rectangle fullImageBoundsScaled = Win32DPIUtils.pointToPixel(drawable, fullImageBounds, scaledImageZoom);
-	Rectangle unscaledSrc =  new Rectangle(srcX, srcY, srcWidth, srcHeight);
+	Rectangle fullImageBoundsPixels = Win32DPIUtils.pointToPixel(drawable, fullImageBounds, scaledImageZoom);
+	Rectangle src =  new Rectangle(srcX, srcY, srcWidth, srcHeight);
+	float transformationScale = calculateTransformationScale();
+	int scaledImageZoomWithTransform = Math.round(transformationScale * scaledImageZoom);
+	Rectangle fullImageBoundsScaledWithTransform = Win32DPIUtils.pointToPixel(drawable, fullImageBounds, scaledImageZoomWithTransform);
 	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.
 		 */
-		int errX = src.x + src.width - fullImageBoundsScaled.width;
-		int errY = src.y + src.height - fullImageBoundsScaled.height;
+		int errX = srcPixels.x + srcPixels.width - fullImageBoundsPixels.width;
+		int errY = srcPixels.y + srcPixels.height - fullImageBoundsPixels.height;
 		if (errX != 0 || errY != 0) {
 			if (errX <= scaledImageZoom / 100 && errY <= scaledImageZoom / 100) {
-				src.intersect(fullImageBoundsScaled);
+				srcPixels.intersect(fullImageBoundsPixels);
 			} else {
 				SWT.error (SWT.ERROR_INVALID_ARGUMENT);
 			}
 		}
 	}
 	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);
-	}, fullImageBoundsScaled.width, fullImageBoundsScaled.height);
+		Rectangle newSrcPixels = computeSourceRectangle(tempHandle, fullImageBounds, fullImageBoundsPixels, src, srcPixels);
+		drawImage(image, newSrcPixels.x, newSrcPixels.y, newSrcPixels.width, newSrcPixels.height, destPixels.x, destPixels.y, destPixels.width,
+				destPixels.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;
+private Rectangle computeSourceRectangle(ImageHandle imageHandle, Rectangle fullImageBounds, Rectangle fullImageBoundsPixels, Rectangle src, Rectangle srcPixels) {
+	if (new Rectangle(0, 0, imageHandle.width(), imageHandle.height()).equals(fullImageBoundsPixels)) {
+		return srcPixels;
 	} 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
+		 * 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 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;
+		float scaleFactor = Math.max(1f * imageHandle.width() / fullImageBounds.width, 1f * imageHandle.height() / fullImageBounds.height);
 		int closestZoomOfHandle = Math.round(scaleFactor * 100);
-		return Win32DPIUtils.pointToPixel(drawable, unscaledSrc, closestZoomOfHandle);
+		return Win32DPIUtils.pointToPixel(drawable, src, closestZoomOfHandle);
 	}
 }