[Win32] Reuse zoom handle for drawing image at size if appropriate

When drawing an image at a specified size, currently a new image handle
is always created based on on-demand loaded image data. In case the
fallback to loading image data for the best fitting zoom is used, a
handle for that zoom may already exist and could be reused but is
currently not considered.

With this change, an existing handle is used if appropriate instead of
unnecessarily creating a temporary handle.

Author: HeikoKlare

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

@@ -141,33 +141,66 @@ public final class Image extends Resource implements Drawable {
 
 	private List<Consumer<Image>> onDisposeListeners;
 
-	private record CachedHandle(ImageHandle handleContainer, int requestedWidth, int requestedHeight) {
+	private class HandleAtSize {
+		private ImageHandle handleContainer = null;
+		private int requestedWidth = -1;
+		private int requestedHeight = -1;
 
 		public void destroy() {
-			if (handleContainer != null) {
+			if (handleContainer != null && !zoomLevelToImageHandle.containsValue(handleContainer)) {
 				handleContainer.destroy();
 			}
+			handleContainer = null;
+			requestedWidth = -1;
+			requestedHeight = -1;
 		}
 
-		public boolean isReusable(int height, int width) {
-			if(handleContainer == null) {
+		public ImageHandle refresh(int width, int height) {
+			if (!isReusable(width, height)) {
+				destroy();
+				requestedWidth = width;
+				requestedHeight = height;
+				handleContainer = createHandleAtExactSize(width, height)
+						.orElseGet(() -> getOrCreateImageHandleAtClosestSize(width, height));
+			}
+			return handleContainer;
+		}
+
+		private boolean isReusable(int width, int height) {
+			if (handleContainer == null) {
 				return false;
 			}
 			return (requestedHeight == height && requestedWidth == width)
 					|| (handleContainer.height == height && handleContainer.width == width);
+		}
 
+		private Optional<ImageHandle> createHandleAtExactSize(int widthHint, int heightHint) {
+			Optional<ImageData> imageData = imageProvider.loadImageDataAtExactSize(widthHint, heightHint);
+			if (imageData.isPresent()) {
+				ImageData adaptedData = adaptImageDataIfDisabledOrGray(imageData.get());
+				ImageHandle imageHandle = init(adaptedData, -1);
+				return Optional.of(imageHandle);
+			}
+			return Optional.empty();
 		}
 
-		public long getHandle() {
-			if (handleContainer != null) {
-				return handleContainer.handle;
+		private ImageHandle getOrCreateImageHandleAtClosestSize(int widthHint, int heightHint) {
+			Rectangle bounds = getBounds(100);
+			int imageZoomForWidth = 100 * widthHint / bounds.width;
+			int imageZoomForHeight = 100 * heightHint / bounds.height;
+			int imageZoom = DPIUtil.getZoomForAutoscaleProperty(Math.max(imageZoomForWidth, imageZoomForHeight));
+			ImageHandle bestFittingHandle = zoomLevelToImageHandle.get(imageZoom);
+			if (bestFittingHandle == null) {
+				ImageData bestFittingImageData = imageProvider.loadImageData(imageZoom).element();
+				ImageData adaptedData = adaptImageDataIfDisabledOrGray(bestFittingImageData);
+				bestFittingHandle = init(adaptedData, -1);
 			}
-			return -1;
+			return bestFittingHandle;
 		}
-	};
 
-	// Initialize lastRequestedHandle with -1 for size-related fields to indicate uninitialized values
-	CachedHandle lastRequestedHandle = new CachedHandle(null, -1, -1);
+	}
+
+	private final HandleAtSize lastRequestedHandle = new HandleAtSize();
 
 private Image (Device device, int type, long handle, int nativeZoom) {
 	super(device);
@@ -854,15 +887,8 @@ interface HandleAtSizeConsumer {
 }
 
 void executeOnImageHandleAtSize(HandleAtSizeConsumer handleAtSizeConsumer, int widthHint, int heightHint) {
-	if (!lastRequestedHandle.isReusable(heightHint, widthHint)) {
-		ImageData imageData;
-		imageData = this.imageProvider.loadImageDataAtSize(widthHint, heightHint);
-		lastRequestedHandle.destroy();
-		ImageHandle handleContainer = init(imageData, -1);
-		lastRequestedHandle = new CachedHandle(handleContainer, widthHint, heightHint);
-	}
-	handleAtSizeConsumer.accept(lastRequestedHandle.getHandle(),
-			new Point(lastRequestedHandle.handleContainer().width, lastRequestedHandle.handleContainer().height));
+	ImageHandle imageHandle = lastRequestedHandle.refresh(widthHint, heightHint);
+	handleAtSizeConsumer.accept(imageHandle.handle, new Point(imageHandle.width, imageHandle.height));
 }
 
 /**
@@ -1096,8 +1122,8 @@ void destroy () {
 }
 
 private void destroyHandles() {
-	destroyHandles(__ -> true);
 	lastRequestedHandle.destroy();
+	destroyHandles(__ -> true);
 }
 
 @Override
@@ -2007,22 +2033,6 @@ ElementAtZoom<ImageData> getClosestAvailableImageData(int zoom) {
 		return new ElementAtZoom<>(getImageMetadata(new ZoomContext(closestZoom)).getImageData(), closestZoom);
 	}
 
-	public ImageData loadImageDataAtSize(int widthHint, int heightHint) {
-		Optional<ImageData> exact = loadImageDataAtExactSize(widthHint, heightHint);
-		if (exact.isPresent()) {
-			return adaptImageDataIfDisabledOrGray(exact.get());
-		}
-		return loadImageDataClosestTo(widthHint, heightHint);
-	}
-
-	private ImageData loadImageDataClosestTo(int targetWidth, int targetHeight) {
-		Rectangle bounds = getBounds(100);
-		int imageZoomForWidth = 100 * targetWidth / bounds.width;
-		int imageZoomForHeight = 100 * targetHeight / bounds.height;
-		int imageZoom = DPIUtil.getZoomForAutoscaleProperty(Math.max(imageZoomForWidth, imageZoomForHeight));
-		return loadImageData(imageZoom).element();
-	}
-
 	protected Optional<ImageData> loadImageDataAtExactSize(int width, int height) {
 		return Optional.empty(); // exact size not available
 	}