Move methods from Win32DPIUtil to DPIUtil for autoscaling

Move some methods from Win32DPIUtil to DPIUtil to make them available
OS-independently such that they can be accessed from OS-independent
code.

Author: ShahzaibIbrahim

bundles/org.eclipse.swt/Eclipse SWT Tests/win32/org/eclipse/swt/internal/ResetMonitorSpecificScalingExtension.java

@@ -25,7 +25,7 @@ protected ResetMonitorSpecificScalingExtension() {
 
 	@Override
 	public void beforeEach(ExtensionContext context) throws Exception {
-		wasMonitorSpecificScalingActive = Win32DPIUtils.isMonitorSpecificScalingActive();
+		wasMonitorSpecificScalingActive = DPIUtil.isMonitorSpecificScalingActive();
 		Display.getDefault().dispose();
 	}
 

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

@@ -51,6 +51,19 @@ public static Optional<AutoScaleMethod> forString(String s) {
 
 	private static String autoScaleValue;
 
+	private static final Set<String> ALLOWED_AUTOSCALE_VALUES_FOR_UPDATE_ON_RUNTIME = Set.of("quarter", "exact", "false");
+	/**
+	 * System property to enable to scale the application on runtime
+	 * when a DPI change is detected.
+	 * <ul>
+	 * <li>"true": the application is scaled on DPI changes</li>
+	 * <li>"false": the application will remain in its initial scaling</li>
+	 * </ul>
+	 * <b>Important:</b> This flag is only parsed and used on Win32. Setting it to
+	 * true on GTK or cocoa will be ignored.
+	 */
+	static final String SWT_AUTOSCALE_UPDATE_ON_RUNTIME = "swt.autoScale.updateOnRuntime";
+
 	/**
 	 * System property that controls the autoScale functionality.
 	 * <ul>
@@ -89,7 +102,6 @@ public static Optional<AutoScaleMethod> forString(String s) {
 
 	static {
 		autoScaleValue = System.getProperty (SWT_AUTOSCALE);
-
 		String value = System.getProperty (SWT_AUTOSCALE_METHOD);
 		AUTO_SCALE_METHOD_SETTING = AutoScaleMethod.forString(value).orElse(AutoScaleMethod.AUTO);
 		autoScaleMethod = AUTO_SCALE_METHOD_SETTING != AutoScaleMethod.AUTO ? AUTO_SCALE_METHOD_SETTING : AutoScaleMethod.NEAREST;
@@ -103,6 +115,51 @@ static void setAutoScaleValue(String autoScaleValueArg) {
 	autoScaleValue = autoScaleValueArg;
 }
 
+/**
+ * Returns {@code true} only if the current setup is compatible
+ * with monitor-specific scaling. Returns {@code false} if:
+ * <ul>
+ *   <li>Not running on Windows</li>
+ *   <li>The current auto-scale mode is incompatible</li>
+ * </ul>
+ *
+ * The supported auto-scale modes are "quarter" and "exact" or explicit zoom values given
+ * by the value itself or "false". Every other value will be treated as
+ * "integer"/"integer200" and is thus not supported.
+ *
+ * <p>
+ * <b>Background information:</b>
+ * Monitor-specific scaling on Windows only supports auto-scale modes in which
+ * all elements (font, images, control bounds etc.) are scaled equally or almost
+ * equally. The previously default mode "integer"/"integer200", which rounded
+ * the scale factor for everything but fonts to multiples of 100, is complex and
+ * difficult to realize with monitor-specific rescaling of UI elements. Since a
+ * uniform scale factor for everything should perspectively be used anyway,
+ * there will be no support for complex auto-scale modes for monitor-specific
+ * scaling.
+ */
+public static boolean isSetupCompatibleToMonitorSpecificScaling() {
+	if (DPIUtil.getAutoScaleValue() == null) {
+		return false;
+	}
+
+	if (ALLOWED_AUTOSCALE_VALUES_FOR_UPDATE_ON_RUNTIME.contains(DPIUtil.getAutoScaleValue().toLowerCase())) {
+		return true;
+	}
+	try {
+		Integer.parseInt(DPIUtil.getAutoScaleValue());
+		return true;
+	} catch (NumberFormatException e) {
+		// unsupported value, use default
+	}
+	return false;
+}
+
+public static boolean isMonitorSpecificScalingActive() {
+	boolean updateOnRuntimeValue = Boolean.getBoolean (DPIUtil.SWT_AUTOSCALE_UPDATE_ON_RUNTIME);
+	return updateOnRuntimeValue;
+}
+
 public static int pixelToPoint(int size, int zoom) {
 	if (zoom == 100 || size == SWT.DEFAULT) return size;
 	float scaleFactor = getScalingFactor (zoom);

bundles/org.eclipse.swt/Eclipse SWT/win32/org/eclipse/swt/internal/Win32DPIUtils.java

@@ -33,20 +33,9 @@
  * @noreference This class is not intended to be referenced by clients
  */
 public class Win32DPIUtils {
-	/**
-	 * System property to enable to scale the application on runtime
-	 * when a DPI change is detected.
-	 * <ul>
-	 * <li>"true": the application is scaled on DPI changes</li>
-	 * <li>"false": the application will remain in its initial scaling</li>
-	 * </ul>
-	 * <b>Important:</b> This flag is only parsed and used on Win32. Setting it to
-	 * true on GTK or cocoa will be ignored.
-	 */
-	private static final String SWT_AUTOSCALE_UPDATE_ON_RUNTIME = "swt.autoScale.updateOnRuntime";
 
 	static {
-	    DPIUtil.setUseSmoothScalingByDefaultProvider(() -> isMonitorSpecificScalingActive());
+		DPIUtil.setUseSmoothScalingByDefaultProvider(() -> DPIUtil.isMonitorSpecificScalingActive());
 	}
 
 	public static boolean setDPIAwareness(int desiredDpiAwareness) {
@@ -302,55 +291,20 @@ public static Rectangle pointToPixel(Drawable drawable, Rectangle rect, int zoom
 	}
 
 	public static void setMonitorSpecificScaling(boolean activate) {
-		System.setProperty(SWT_AUTOSCALE_UPDATE_ON_RUNTIME, Boolean.toString(activate));
+		System.setProperty(DPIUtil.SWT_AUTOSCALE_UPDATE_ON_RUNTIME, Boolean.toString(activate));
 	}
 
 	public static void setAutoScaleForMonitorSpecificScaling() {
 		boolean isDefaultAutoScale = DPIUtil.getAutoScaleValue() == null;
 		if (isDefaultAutoScale) {
 			DPIUtil.setAutoScaleValue("quarter");
-		} else if (!isSupportedAutoScaleForMonitorSpecificScaling()) {
+		} else if (!DPIUtil.isSetupCompatibleToMonitorSpecificScaling()) {
 			throw new SWTError(SWT.ERROR_NOT_IMPLEMENTED,
 					"monitor-specific scaling is only implemented for auto-scale values \"quarter\", \"exact\", \"false\" or a concrete zoom value, but \""
 							+ DPIUtil.getAutoScaleValue() + "\" has been specified");
 		}
 	}
 
-	/**
-	 * Monitor-specific scaling on Windows only supports auto-scale modes in which
-	 * all elements (font, images, control bounds etc.) are scaled equally or almost
-	 * equally. The previously default mode "integer"/"integer200", which rounded
-	 * the scale factor for everything but fonts to multiples of 100, is complex and
-	 * difficult to realize with monitor-specific rescaling of UI elements. Since a
-	 * uniform scale factor for everything should perspectively be used anyway,
-	 * there will be support for complex auto-scale modes for monitor-specific
-	 * scaling.
-	 *
-	 * The supported modes are "quarter" and "exact" or explicit zoom values given
-	 * by the value itself or "false". Every other value will be treated as
-	 * "integer"/"integer200" and is thus not supported.
-	 */
-	private static boolean isSupportedAutoScaleForMonitorSpecificScaling() {
-		if (DPIUtil.getAutoScaleValue() == null) {
-			return false;
-		}
-		switch (DPIUtil.getAutoScaleValue().toLowerCase()) {
-			case "false", "quarter", "exact": return true;
-		}
-		try {
-			Integer.parseInt(DPIUtil.getAutoScaleValue());
-			return true;
-		} catch (NumberFormatException e) {
-			// unsupported value, use default
-		}
-		return false;
-	}
-
-	public static boolean isMonitorSpecificScalingActive() {
-		boolean updateOnRuntimeValue = Boolean.getBoolean (SWT_AUTOSCALE_UPDATE_ON_RUNTIME);
-		return updateOnRuntimeValue;
-	}
-
 	public static int getPrimaryMonitorZoomAtStartup() {
 		long hDC = OS.GetDC(0);
 		int dpi = OS.GetDeviceCaps(hDC, OS.LOGPIXELSX);

bundles/org.eclipse.swt/Eclipse SWT/win32/org/eclipse/swt/widgets/Display.java

@@ -949,7 +949,7 @@ public void close () {
 protected void create (DeviceData data) {
 	checkSubclass ();
 	checkDisplay (thread = Thread.currentThread (), true);
-	if (Win32DPIUtils.isMonitorSpecificScalingActive()) {
+	if (DPIUtil.isMonitorSpecificScalingActive()) {
 		setMonitorSpecificScaling(true);
 		Win32DPIUtils.setAutoScaleForMonitorSpecificScaling();
 	}