Adapt size of Windows with default size upon zoom change

When moved between monitors of different zoom, Windows may not show
their full contents anymore. This is caused by their shell and the used
fonts being linearly scaled in size according to the zoom, even though
font size and required area for a font of a size are not linearly
related. I.e., a font of double the size required more than double of
the width and height.

Since there are many ways to customize Windows and their sizes/layouts
during and after initialization, it's difficult to solve that problem in
general. It is, however, most severe for Windows that use the default
calculated size and are not resizable, as those Windows not have
sophisticated layouts that adapt to the limited space and may easily
lead to cut offs the user cannot work around by resizing.
Thus, this change adds according zoom change and resize listeners to
identify if a Window uses the default computed size and, in that case,
recomputes it upon zoom change.

Author: HeikoKlare

bundles/org.eclipse.jface/src/org/eclipse/jface/window/Window.java

@@ -14,6 +14,7 @@
 package org.eclipse.jface.window;
 
 import java.util.ArrayList;
+import java.util.concurrent.atomic.AtomicReference;
 
 import org.eclipse.core.runtime.Assert;
 import org.eclipse.jface.resource.JFaceResources;
@@ -433,6 +434,53 @@ public void create() {
 		//initialize the bounds of the shell to that appropriate for the
 		// contents
 		initializeBounds();
+		hookZoomChangeListenerForDefaultSizedDialogs();
+	}
+
+	/*
+	 * There is no linear relation between font size and containing control size
+	 * scaled according to some zoom value. In consequence, text with a scaled font
+	 * size may not fit into a control/shell with a size scaled by the same zoom. To
+	 * adhere for this in case of Windows using the default computed size, ensure
+	 * that on zoom change the new proper size is computed and applied. This will
+	 * not affect Windows that have a custom size, either programmatically or
+	 * manually applied.
+	 */
+	private void hookZoomChangeListenerForDefaultSizedDialogs() {
+		boolean hasCustomSize = !shell.getSize().equals(shell.computeSize(SWT.DEFAULT, SWT.DEFAULT, true));
+		boolean isEmpty = shell.getChildren().length == 0;
+		if (resizeHasOccurred || hasCustomSize || isEmpty) {
+			return;
+		}
+
+		AtomicReference<Listener> customResizeListener = new AtomicReference<>();
+		Listener adaptDefaultSizeListener = event -> {
+			if (shell == null || shell.isDisposed()) {
+				return;
+			}
+			Point size = shell.computeSize(SWT.DEFAULT, SWT.DEFAULT, true);
+			shell.setSize(size);
+		};
+		AtomicReference<Listener> zoomChangeListener = new AtomicReference<>();
+		zoomChangeListener.set(event -> {
+			if (shell == null || shell.isDisposed()) {
+				return;
+			}
+			shell.addListener(SWT.Resize, adaptDefaultSizeListener);
+			shell.removeListener(SWT.Resize, customResizeListener.get());
+			shell.getChildren()[0].removeListener(SWT.ZoomChanged, zoomChangeListener.get());
+		});
+		customResizeListener.set(event -> {
+			if (shell == null || shell.isDisposed()) {
+				return;
+			}
+			shell.getChildren()[0].removeListener(SWT.ZoomChanged, zoomChangeListener.get());
+		});
+
+		shell.getChildren()[0].addListener(SWT.ZoomChanged, zoomChangeListener.get());
+		// If custom resize happens before first zoom change, the dialog is custom sized
+		// and should not be auto-resized on zoom change
+		shell.addListener(SWT.Resize, customResizeListener.get());
 	}
 
 	/**