Allow GC to draw images in arbitrary sizes

bundles/org.eclipse.swt.svg/src/org/eclipse/swt/svg/JSVGRasterizer.java

@@ -72,34 +72,44 @@ public class JSVGRasterizer implements SVGRasterizer {
 
 	@Override
 	public ImageData rasterizeSVG(InputStream inputStream, int zoom) throws IOException {
-		SVGDocument svgDocument = loadSVG(inputStream);
-		if (svgDocument == null) {
-			SWT.error(SWT.ERROR_INVALID_IMAGE);
-		}
+		SVGDocument svgDocument = loadAndValidateSVG(inputStream);
 		BufferedImage rasterizedImage = renderSVG(svgDocument, zoom);
 		return convertToSWTImageData(rasterizedImage);
 	}
-
-	private SVGDocument loadSVG(InputStream inputStream) {
-		return SVG_LOADER.load(inputStream, null, LoaderContext.createDefault());
+
+	@Override
+	public ImageData rasterizeSVG(InputStream inputStream, int width, int height) throws IOException {
+		SVGDocument svgDocument = loadAndValidateSVG(inputStream);
+		BufferedImage rasterizedImage = renderSVG(svgDocument, width, height);
+		return convertToSWTImageData(rasterizedImage);
+	}
+
+	private SVGDocument loadAndValidateSVG(InputStream inputStream) throws IOException {
+		SVGDocument svgDocument = SVG_LOADER.load(inputStream, null, LoaderContext.createDefault());
+		if (svgDocument == null) {
+			SWT.error(SWT.ERROR_INVALID_IMAGE);
+		}
+		return svgDocument;
 	}
 
 	private BufferedImage renderSVG(SVGDocument svgDocument, int zoom) {
+		FloatSize sourceImageSize = svgDocument.size();
 		float scalingFactor = zoom / 100.0f;
-		BufferedImage image = createImageBase(svgDocument, scalingFactor);
-		Graphics2D g = configureRenderingOptions(scalingFactor, image);
+		int targetImageWidth = calculateTargetWidth(scalingFactor, sourceImageSize);
+		int targetImageHeight = calculateTargetHeight(scalingFactor, sourceImageSize);
+		return renderSVG(svgDocument, targetImageWidth, targetImageHeight);
+	}
+
+	private BufferedImage renderSVG(SVGDocument svgDocument, int width, int height) {
+		BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);
+		float widthScalingFactor = width / svgDocument.size().width;
+		float heightScalingFactor = height / svgDocument.size().height;
+		Graphics2D g = configureRenderingOptions(widthScalingFactor, heightScalingFactor, image);
 		svgDocument.render(null, g);
 		g.dispose();
 		return image;
 	}
 
-	private BufferedImage createImageBase(SVGDocument svgDocument, float scalingFactor) {
-		FloatSize sourceImageSize = svgDocument.size();
-		int targetImageWidth = calculateTargetWidth(scalingFactor, sourceImageSize);
-		int targetImageHeight = calculateTargetHeight(scalingFactor, sourceImageSize);
-		return new BufferedImage(targetImageWidth, targetImageHeight, BufferedImage.TYPE_INT_ARGB);
-	}
-
 	private int calculateTargetWidth(float scalingFactor, FloatSize sourceImageSize) {
 		double sourceImageWidth = sourceImageSize.getWidth();
 		return (int) Math.round(sourceImageWidth * scalingFactor);
@@ -110,10 +120,10 @@ private int calculateTargetHeight(float scalingFactor, FloatSize sourceImageSize
 		return (int) Math.round(sourceImageHeight * scalingFactor);
 	}
 
-	private Graphics2D configureRenderingOptions(float scalingFactor, BufferedImage image) {
+	private Graphics2D configureRenderingOptions(float widthScalingFactor, float heightScalingFactor, BufferedImage image) {
 		Graphics2D g = image.createGraphics();
 		g.setRenderingHints(RENDERING_HINTS);
-		g.scale(scalingFactor, scalingFactor);
+		g.scale(widthScalingFactor, heightScalingFactor);
 		return g;
 	}
 

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

@@ -0,0 +1,24 @@
+/*******************************************************************************
+ * Copyright (c) 2025 Vector Informatik GmbH and others.
+ *
+ * This program and the accompanying materials are made available under the terms of the Eclipse
+ * Public License 2.0 which accompanies this distribution, and is available at
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *     Michael Bangas (Vector Informatik GmbH) - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.swt.graphics;
+
+import java.util.*;
+
+/**
+ * @since 3.131
+ */
+public interface ImageDataAtSizeProvider extends ImageDataProvider {
+
+	Optional<ImageData> getImageData(int targetWidth, int targetHeight);
+
+}

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

@@ -41,20 +41,32 @@ public static boolean canLoadAtZoom(InputStream stream, int fileZoom, int target
 		return ImageLoader.canLoadAtZoom(stream, fileZoom, targetZoom);
 	}
 
-	public static ElementAtZoom<ImageData> load(InputStream stream, int fileZoom, int targetZoom) {
-		List<ElementAtZoom<ImageData>> data = new ImageLoader().load(stream, fileZoom, targetZoom);
-		if (data.isEmpty()) SWT.error(SWT.ERROR_INVALID_IMAGE);
-		return data.get(0);
-	}
-
 	public static boolean canLoadAtZoom(String filename, int fileZoom, int targetZoom) {
 		return ImageLoader.canLoadAtZoom(filename, fileZoom, targetZoom);
 	}
 
-	public static ElementAtZoom<ImageData> load(String filename, int fileZoom, int targetZoom) {
-		List<ElementAtZoom<ImageData>> data = new ImageLoader().load(filename, fileZoom, targetZoom);
+	public static ElementAtZoom<ImageData> loadByZoom(InputStream stream, int fileZoom, int targetZoom) {
+		List<ElementAtZoom<ImageData>> data = new ImageLoader().loadByZoom(stream, fileZoom, targetZoom);
+		if (data.isEmpty()) SWT.error(SWT.ERROR_INVALID_IMAGE);
+		return data.get(0);
+	}
+
+	public static ElementAtZoom<ImageData> loadByZoom(String filename, int fileZoom, int targetZoom) {
+		List<ElementAtZoom<ImageData>> data = new ImageLoader().loadByZoom(filename, fileZoom, targetZoom);
 		if (data.isEmpty()) SWT.error(SWT.ERROR_INVALID_IMAGE);
 		return data.get(0);
 	}
 
+	public static ImageData loadByTargetSize(InputStream stream, int targetWidth, int targetHeight) {
+		ImageData data = new ImageLoader().loadByTargetSize(stream, targetWidth, targetHeight);
+		if (data == null) SWT.error(SWT.ERROR_INVALID_IMAGE);
+		return data;
+	}
+
+	public static ImageData loadByTargetSize(String filename, int targetWidth, int targetHeight) {
+		ImageData data = new ImageLoader().loadByTargetSize(filename, targetWidth, targetHeight);
+		if (data == null) SWT.error(SWT.ERROR_INVALID_IMAGE);
+		return data;
+	}
+
 }

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

@@ -0,0 +1,28 @@
+/*******************************************************************************
+ * Copyright (c) 2025 Vector Informatik GmbH and others.
+ *
+ * This program and the accompanying materials are made available under the terms of the Eclipse
+ * Public License 2.0 which accompanies this distribution, and is available at
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *     Michael Bangas (Vector Informatik GmbH) - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.swt.graphics;
+
+import java.util.*;
+
+/**
+ * @since 3.131
+ */
+public interface ImageFileNameAtSizeProvider extends ImageFileNameProvider {
+
+    /**
+     * Returns the image file path most suitable for rendering at the given target size.
+     *
+     */
+	Optional<String> getImagePath(int targetWidth, int targetHeight);
+
+}

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

@@ -151,18 +151,26 @@ void reset() {
  * </ul>
  */
 public ImageData[] load(InputStream stream) {
-	load(stream, FileFormat.DEFAULT_ZOOM, FileFormat.DEFAULT_ZOOM);
+	loadByZoom(stream, FileFormat.DEFAULT_ZOOM, FileFormat.DEFAULT_ZOOM);
 	return data;
 }
 
-List<ElementAtZoom<ImageData>> load(InputStream stream, int fileZoom, int targetZoom) {
+List<ElementAtZoom<ImageData>> loadByZoom(InputStream stream, int fileZoom, int targetZoom) {
 	if (stream == null) SWT.error(SWT.ERROR_NULL_ARGUMENT);
 	reset();
 	List<ElementAtZoom<ImageData>> images = NativeImageLoader.load(new ElementAtZoom<>(stream, fileZoom), this, targetZoom);
 	data = images.stream().map(ElementAtZoom::element).toArray(ImageData[]::new);
 	return images;
 }
 
+ImageData loadByTargetSize(InputStream stream, int targetWidth, int targetHeight) {
+	if (stream == null) SWT.error(SWT.ERROR_NULL_ARGUMENT);
+	reset();
+	ImageData image = NativeImageLoader.load(stream, this, targetWidth, targetHeight);
+	data = new ImageData[] {image};
+	return image;
+}
+
 static boolean canLoadAtZoom(InputStream stream, int fileZoom, int targetZoom) {
 	if (stream == null) SWT.error(SWT.ERROR_NULL_ARGUMENT);
 	return FileFormat.canLoadAtZoom(new ElementAtZoom<>(stream, fileZoom), targetZoom);
@@ -187,14 +195,24 @@ static boolean canLoadAtZoom(InputStream stream, int fileZoom, int targetZoom) {
  * </ul>
  */
 public ImageData[] load(String filename) {
-	load(filename, FileFormat.DEFAULT_ZOOM, FileFormat.DEFAULT_ZOOM);
+	loadByZoom(filename, FileFormat.DEFAULT_ZOOM, FileFormat.DEFAULT_ZOOM);
 	return data;
 }
 
-List<ElementAtZoom<ImageData>> load(String filename, int fileZoom, int targetZoom) {
+List<ElementAtZoom<ImageData>> loadByZoom(String filename, int fileZoom, int targetZoom) {
+	if (filename == null) SWT.error(SWT.ERROR_NULL_ARGUMENT);
+	try (InputStream stream = new FileInputStream(filename)) {
+		return loadByZoom(stream, fileZoom, targetZoom);
+	} catch (IOException e) {
+		SWT.error(SWT.ERROR_IO, e);
+	}
+	return null;
+}
+
+ImageData loadByTargetSize(String filename, int targetWidth, int targetHeight) {
 	if (filename == null) SWT.error(SWT.ERROR_NULL_ARGUMENT);
 	try (InputStream stream = new FileInputStream(filename)) {
-		return load(stream, fileZoom, targetZoom);
+		return loadByTargetSize(stream, targetWidth, targetHeight);
 	} catch (IOException e) {
 		SWT.error(SWT.ERROR_IO, e);
 	}

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

@@ -144,34 +144,49 @@ public static ImageData scaleImageData (Device device, final ElementAtZoom<Image
 	return scaleImageData(device, elementAtZoom.element(), targetZoom, elementAtZoom.zoom());
 }
 
-public static ImageData autoScaleImageData (Device device, final ImageData imageData, float scaleFactor) {
-	// Guards are already implemented in callers: if (deviceZoom == 100 || imageData == null || scaleFactor == 1.0f) return imageData;
-	int width = imageData.width;
-	int height = imageData.height;
-	int scaledWidth = Math.round (width * scaleFactor);
-	int scaledHeight = Math.round (height * scaleFactor);
+public static ImageData autoScaleImageData(Device device, final ImageData imageData, float scaleFactor) {
+	int targetWidth = Math.round(imageData.width * scaleFactor);
+	int targetHeight = Math.round(imageData.height * scaleFactor);
+	return scaleImage(device, imageData, imageData.width, imageData.height, targetWidth, targetHeight, Image::drawAtTargetSize);
+}
+
+public static ImageData autoScaleImageData(Device device, final ImageData imageData, int targetWidth, int targetHeight) {
+	return scaleImage(device, imageData, imageData.width, imageData.height, targetWidth, targetHeight, Image::drawAtTargetSize);
+}
+
+@FunctionalInterface
+private interface ImageDrawFunction {
+	void draw(GC gc, Image original, int originalWidth, int originalHeight, int targetWidth, int targetHeight);
+}
+
+private static ImageData scaleImage(Device device, ImageData imageData, int originalWidth, int originalHeight,
+		int targetWidth, int targetHeight, ImageDrawFunction drawFunction) {
+
 	boolean useSmoothScaling = isSmoothScalingEnabled() && imageData.getTransparencyType() != SWT.TRANSPARENCY_MASK;
+
 	if (useSmoothScaling) {
-		Image original = new Image (device, (ImageDataProvider) zoom -> imageData);
-		ImageGcDrawer drawer =  new ImageGcDrawer() {
+		Image original = new Image(device, (ImageDataProvider) zoom -> imageData);
+
+		ImageGcDrawer drawer = new ImageGcDrawer() {
 			@Override
 			public void drawOn(GC gc, int imageWidth, int imageHeight) {
-				gc.setAntialias (SWT.ON);
-				Image.drawScaled(gc, original, width, height, scaleFactor);
-			};
+				gc.setAntialias(SWT.ON);
+				drawFunction.draw(gc, original, originalWidth, originalHeight, targetWidth, targetHeight);
+			}
 
 			@Override
 			public int getGcStyle() {
 				return SWT.TRANSPARENT;
 			}
 		};
-		Image resultImage = new Image (device, drawer, scaledWidth, scaledHeight);
-		ImageData result = resultImage.getImageData (100);
-		original.dispose ();
-		resultImage.dispose ();
+
+		Image resultImage = new Image(device, drawer, targetWidth, targetHeight);
+		ImageData result = resultImage.getImageData(100);
+		original.dispose();
+		resultImage.dispose();
 		return result;
 	} else {
-		return imageData.scaledTo (scaledWidth, scaledHeight);
+		return imageData.scaledTo(targetWidth, targetHeight);
 	}
 }
 

bundles/org.eclipse.swt/Eclipse SWT/common/org/eclipse/swt/internal/image/FileFormat.java

@@ -85,6 +85,11 @@ static abstract class StaticImageFileFormat extends FileFormat {
 		List<ElementAtZoom<ImageData>> loadFromByteStream(int fileZoom, int targetZoom) {
 			return Arrays.stream(loadFromByteStream()).map(d -> new ElementAtZoom<>(d, fileZoom)).toList();
 		}
+
+		@Override
+		ImageData loadFromByteStreamByTargetSize(int targetWidth, int targetHeight) {
+			return loadFromByteStream()[0];
+		}
 	}
 
 	LEDataInputStream inputStream;
@@ -104,6 +109,8 @@ List<ElementAtZoom<ImageData>> loadFromByteStream(int fileZoom, int targetZoom)
 	 */
 	abstract List<ElementAtZoom<ImageData>> loadFromByteStream(int fileZoom, int targetZoom);
 
+	abstract ImageData loadFromByteStreamByTargetSize(int targetWidth, int targetHeight);
+
 /**
  * Read the specified input stream, and return the
  * device independent image array represented by the stream.
@@ -122,6 +129,20 @@ public List<ElementAtZoom<ImageData>> loadFromStream(LEDataInputStream stream, i
 	}
 }
 
+public ImageData loadFromStreamByTargetSize(LEDataInputStream stream, int targetWidth, int targetHeight) {
+	try {
+		inputStream = stream;
+		return loadFromByteStreamByTargetSize(targetWidth, targetHeight);
+	} catch (Exception e) {
+		if (e instanceof IOException) {
+			SWT.error(SWT.ERROR_IO, e);
+		} else {
+			SWT.error(SWT.ERROR_INVALID_IMAGE, e);
+		}
+		return null;
+	}
+}
+
 /**
  * Read the specified input stream using the specified loader, and
  * return the device independent image array represented by the stream.
@@ -136,6 +157,16 @@ public static List<ElementAtZoom<ImageData>> load(ElementAtZoom<InputStream> is,
 	return fileFormat.loadFromStream(stream, is.zoom(), targetZoom);
 }
 
+public static ImageData load(InputStream is, ImageLoader loader, int targetWidth, int targetHeight) {
+	LEDataInputStream stream = new LEDataInputStream(is);
+	FileFormat fileFormat = determineFileFormat(stream).orElseGet(() -> {
+		SWT.error(SWT.ERROR_UNSUPPORTED_FORMAT);
+		return null;
+	});
+	fileFormat.loader = loader;
+	return fileFormat.loadFromStreamByTargetSize(stream, targetWidth, targetHeight);
+}
+
 public static boolean canLoadAtZoom(ElementAtZoom<InputStream> is, int targetZoom) {
 	return is.zoom() == targetZoom  || isDynamicallySizableFormat(is.element());
 }

bundles/org.eclipse.swt/Eclipse SWT/common/org/eclipse/swt/internal/image/SVGFileFormat.java

@@ -60,6 +60,26 @@ List<ElementAtZoom<ImageData>> loadFromByteStream(int fileZoom, int targetZoom)
 		}
 	}
 
+	@Override
+	ImageData loadFromByteStreamByTargetSize(int targetWidth, int targetHeight) {
+		if (RASTERIZER == null) {
+			SWT.error(SWT.ERROR_UNSUPPORTED_FORMAT, null, " [No SVG rasterizer found]");
+		}
+		if (targetWidth <= 0 || targetHeight <= 0) {
+			SWT.error(SWT.ERROR_INVALID_ARGUMENT, null, " [Cannot rasterize SVG for targetWidth or targetHeight <= 0]");
+		}
+		if (targetHeight <= 0 || targetHeight <= 0) {
+			SWT.error(SWT.ERROR_INVALID_ARGUMENT, null, " [Cannot rasterize SVG for targetHeight or targetHeight <= 0]");
+		}
+		try {
+			ImageData rasterizedImageData = RASTERIZER.rasterizeSVG(inputStream, targetWidth, targetHeight);
+			return rasterizedImageData;
+		} catch (IOException e) {
+			SWT.error(SWT.ERROR_INVALID_IMAGE, e);
+			return null;
+		}
+	}
+
 	@Override
 	void unloadIntoByteStream(ImageLoader loader) {
 		throw new UnsupportedOperationException();

bundles/org.eclipse.swt/Eclipse SWT/common/org/eclipse/swt/internal/image/SVGRasterizer.java

@@ -32,4 +32,6 @@ public interface SVGRasterizer {
 	 *         the input is not a valid SVG file or cannot be processed.
 	 */
 	public ImageData rasterizeSVG(InputStream stream, int zoom) throws IOException;
+
+	public ImageData rasterizeSVG(InputStream stream, int width, int height) throws IOException;
 }