Unify and improve image disablement calculation algorithm

Each OS-specific implementation of the Image class has its own
implementation of an algorithm to calculate a disabled representation of
a given image. In addition, the algorithm used on Windows and MacOS
produces bad results, which is why usually pre-generated disabled icons
are used.

This change extracts the implementations of those algorithms into
ImageProcessingDescriptors. The implementation for Windows and MacOS is
improved and a legacy mode applying the old algorithm is added.

Co-authored-by: Manuel Killinger <Manuel.Killinger@vector.com>

Author: HeikoKlare

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

@@ -14,6 +14,9 @@
 package org.eclipse.swt.graphics;
 
 
+import static org.eclipse.swt.internal.image.ImageProcessingDescriptor.createHSBImageProcessingDescriptor;
+import static org.eclipse.swt.internal.image.ImageProcessingDescriptor.createThresholdIntensityImageProcessingDescriptor;
+
 import java.io.*;
 import java.util.*;
 import java.util.function.*;
@@ -77,6 +80,8 @@
  */
 public final class Image extends Resource implements Drawable {
 
+	private static final boolean USE_LEGACY_IMAGE_DISABLEMENT = Boolean.getBoolean("org.eclipse.swt.image.useLegacyDisablementAlgorithm");
+
 	/**
 	 * specifies whether the receiver is a bitmap or an icon
 	 * (one of <code>SWT.BITMAP</code>, <code>SWT.ICON</code>)
@@ -436,29 +441,24 @@ private void createRepFromSourceAndApplyFlag(NSBitmapImageRep srcRep, int srcWid
 	long data = rep.bitmapData();
 	C.memmove(data, srcData, srcWidth * srcHeight * 4);
 	if (flag != SWT.IMAGE_COPY) {
-		final int redOffset, greenOffset, blueOffset;
+		final int redOffset, greenOffset, blueOffset, alphaOffset;
 		if (srcBpp == 32 && (srcBitmapFormat & OS.NSAlphaFirstBitmapFormat) == 0) {
 			redOffset = 0;
 			greenOffset = 1;
 			blueOffset = 2;
+			alphaOffset = 3;
 		} else {
+			alphaOffset = 0;
 			redOffset = 1;
 			greenOffset = 2;
 			blueOffset = 3;
 		}
 		/* Apply transformation */
 		switch (flag) {
 		case SWT.IMAGE_DISABLE: {
-			Color zeroColor = this.device.getSystemColor(SWT.COLOR_WIDGET_NORMAL_SHADOW);
-			RGB zeroRGB = zeroColor.getRGB();
-			byte zeroRed = (byte)zeroRGB.red;
-			byte zeroGreen = (byte)zeroRGB.green;
-			byte zeroBlue = (byte)zeroRGB.blue;
-			Color oneColor = this.device.getSystemColor(SWT.COLOR_WIDGET_BACKGROUND);
-			RGB oneRGB = oneColor.getRGB();
-			byte oneRed = (byte)oneRGB.red;
-			byte oneGreen = (byte)oneRGB.green;
-			byte oneBlue = (byte)oneRGB.blue;
+			ImageProcessingDescriptor disabledImageProcessor = USE_LEGACY_IMAGE_DISABLEMENT
+					? createThresholdIntensityImageProcessingDescriptor(device)
+					: createHSBImageProcessingDescriptor(1.0f, 0.2f, 0.9f, 0.5f);
 			byte[] line = new byte[(int)srcBpr];
 			for (int y=0; y<srcHeight; y++) {
 				C.memmove(line, data + (y * srcBpr), srcBpr);
@@ -467,16 +467,12 @@ private void createRepFromSourceAndApplyFlag(NSBitmapImageRep srcRep, int srcWid
 					int red = line[offset+redOffset] & 0xFF;
 					int green = line[offset+greenOffset] & 0xFF;
 					int blue = line[offset+blueOffset] & 0xFF;
-					int intensity = red * red + green * green + blue * blue;
-					if (intensity < 98304) {
-						line[offset+redOffset] = zeroRed;
-						line[offset+greenOffset] = zeroGreen;
-						line[offset+blueOffset] = zeroBlue;
-					} else {
-						line[offset+redOffset] = oneRed;
-						line[offset+greenOffset] = oneGreen;
-						line[offset+blueOffset] = oneBlue;
-					}
+					int alpha = line[offset+alphaOffset] & 0xFF;
+					RGBA result = disabledImageProcessor.adaptPixelValue(red, green, blue, alpha);
+					line[offset+redOffset] = (byte) result.rgb.red;
+					line[offset+greenOffset] = (byte) result.rgb.green;
+					line[offset+blueOffset] = (byte) result.rgb.blue;
+					line[offset+alphaOffset] = (byte) result.alpha;
 					offset += 4;
 				}
 				C.memmove(data + (y * srcBpr), line, srcBpr);

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

@@ -0,0 +1,53 @@
+/*******************************************************************************
+ * 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
+ *******************************************************************************/
+package org.eclipse.swt.internal.image;
+
+import org.eclipse.swt.*;
+import org.eclipse.swt.graphics.*;
+
+public interface ImageProcessingDescriptor {
+
+	RGBA adaptPixelValue(int red, int green, int blue, int alpha);
+
+	public static ImageProcessingDescriptor createHSBImageProcessingDescriptor(float hueFactor, float saturationFactor,
+			float brightnessFactor, float alphaFactor) {
+		return (red, green, blue, alpha) -> {
+			float[] hsba = new RGBA(red, green, blue, alpha).getHSBA();
+			float hue = Math.min(hueFactor * hsba[0], 1.0f);
+			float saturation = Math.min(saturationFactor * hsba[1], 1.0f);
+			float brightness = Math.min(brightnessFactor * hsba[2], 1.0f);
+			float alphaResult = Math.min(alphaFactor * hsba[3], 255.0f);
+			return new RGBA(hue, saturation, brightness, alphaResult);
+		};
+	}
+
+	public static ImageProcessingDescriptor createRGBImageProcessingDescriptor(float redFactor, float greenFactor,
+			float blueFactor, float alphaFactor) {
+		return (red, green, blue, alpha) -> {
+			int redResult = (int) Math.min(redFactor * red, 255.0f);
+			int greenResult = (int) Math.min(greenFactor * green, 255.0f);
+			int blueResult = (int) Math.min(blueFactor * blue, 255.0f);
+			int alphaResult = (int) Math.min(alphaFactor * alpha, 255.0f);
+			return new RGBA(redResult, greenResult, blueResult, alphaResult);
+		};
+	}
+
+	public static ImageProcessingDescriptor createThresholdIntensityImageProcessingDescriptor(Device device) {
+		RGBA lowIntensity = device.getSystemColor(SWT.COLOR_WIDGET_NORMAL_SHADOW).getRGBA();
+		RGBA highIntensity = device.getSystemColor(SWT.COLOR_WIDGET_BACKGROUND).getRGBA();
+		return (red, green, blue, alpha) -> {
+			int intensity = red * red + green * green + blue * blue;
+			RGBA usedGraytone = intensity < 98304 ? lowIntensity : highIntensity;
+			return new RGBA(usedGraytone.rgb.red, usedGraytone.rgb.green, usedGraytone.rgb.blue, alpha);
+		};
+	}
+
+}

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

@@ -14,6 +14,8 @@
 package org.eclipse.swt.graphics;
 
 
+import static org.eclipse.swt.internal.image.ImageProcessingDescriptor.createRGBImageProcessingDescriptor;
+
 import java.io.*;
 import java.util.*;
 
@@ -304,6 +306,7 @@ public Image(Device device, Image srcImage, int flag) {
 		}
 		switch (flag) {
 			case SWT.IMAGE_DISABLE: {
+				ImageProcessingDescriptor disabledImageProcessor = createRGBImageProcessingDescriptor(0.5f, 0.5f, 0.5f, 0.5f);
 				byte[] line = new byte[stride];
 				for (int y=0; y<height; y++) {
 					C.memmove(line, data + (y * stride), stride);
@@ -312,10 +315,11 @@ public Image(Device device, Image srcImage, int flag) {
 						int r = line[offset + or] & 0xFF;
 						int g = line[offset + og] & 0xFF;
 						int b = line[offset + ob] & 0xFF;
-						line[offset + oa] = (byte) Math.round((double) a * 0.5);
-						line[offset + or] = (byte) Math.round((double) r * 0.5);
-						line[offset + og] = (byte) Math.round((double) g * 0.5);
-						line[offset + ob] = (byte) Math.round((double) b * 0.5);
+						RGBA result = disabledImageProcessor.adaptPixelValue(r, g, b, a);
+						line[offset + oa] = (byte) Math.round(result.alpha);
+						line[offset + or] = (byte) Math.round(result.rgb.red);
+						line[offset + og] = (byte) Math.round(result.rgb.green);
+						line[offset + ob] = (byte) Math.round(result.rgb.blue);
 					}
 					C.memmove(data + (y * stride), line, stride);
 				}

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

@@ -14,6 +14,9 @@
 package org.eclipse.swt.graphics;
 
 
+import static org.eclipse.swt.internal.image.ImageProcessingDescriptor.createHSBImageProcessingDescriptor;
+import static org.eclipse.swt.internal.image.ImageProcessingDescriptor.createThresholdIntensityImageProcessingDescriptor;
+
 import java.io.*;
 import java.util.*;
 
@@ -76,6 +79,8 @@
  */
 public final class Image extends Resource implements Drawable {
 
+	private static final boolean USE_LEGACY_IMAGE_DISABLEMENT = Boolean.getBoolean("org.eclipse.swt.image.useLegacyDisablementAlgorithm");
+
 	/**
 	 * specifies whether the receiver is a bitmap or an icon
 	 * (one of <code>SWT.BITMAP</code>, <code>SWT.ICON</code>)
@@ -667,12 +672,11 @@ void init() {
 }
 
 private ImageData applyDisableImageData(ImageData data, int height, int width) {
+	ImageProcessingDescriptor disabledImageProcessor = USE_LEGACY_IMAGE_DISABLEMENT
+			? createThresholdIntensityImageProcessingDescriptor(device)
+			: createHSBImageProcessingDescriptor(1.0f, 0.2f, 0.9f, 0.5f);
 	PaletteData palette = data.palette;
-	RGB[] rgbs = new RGB[3];
-	rgbs[0] = this.device.getSystemColor(SWT.COLOR_BLACK).getRGB();
-	rgbs[1] = this.device.getSystemColor(SWT.COLOR_WIDGET_NORMAL_SHADOW).getRGB();
-	rgbs[2] = this.device.getSystemColor(SWT.COLOR_WIDGET_BACKGROUND).getRGB();
-	ImageData newData = new ImageData(width, height, 8, new PaletteData(rgbs));
+	ImageData newData = new ImageData(width, height, 32, new PaletteData(0xFF, 0xFF00, 0xFF0000));
 	newData.alpha = data.alpha;
 	newData.alphaData = data.alphaData;
 	newData.maskData = data.maskData;
@@ -692,7 +696,6 @@ private ImageData applyDisableImageData(ImageData data, int height, int width) {
 	int greenShift = palette.greenShift;
 	int blueShift = palette.blueShift;
 	for (int y=0; y<height; y++) {
-		int offset = y * newData.bytesPerLine;
 		data.getPixels(0, y, width, scanline, 0);
 		if (mask != null) mask.getPixels(0, y, width, maskScanline, 0);
 		for (int x=0; x<width; x++) {
@@ -711,14 +714,10 @@ private ImageData applyDisableImageData(ImageData data, int height, int width) {
 					green = palette.colors[pixel].green;
 					blue = palette.colors[pixel].blue;
 				}
-				int intensity = red * red + green * green + blue * blue;
-				if (intensity < 98304) {
-					newData.data[offset] = (byte)1;
-				} else {
-					newData.data[offset] = (byte)2;
-				}
+				RGBA result = disabledImageProcessor.adaptPixelValue(red, green, blue, data.getAlpha(x, y));
+				newData.setAlpha(x, y, result.alpha);
+				newData.setPixel(x, y, newData.palette.getPixel(result.rgb));
 			}
-			offset++;
 		}
 	}
 	return newData;