Kotlin flow update (#19)

Author: nedtwigg

CHANGES.md

@@ -1,6 +1,16 @@
 # DurianSwt releases
 
 ## [Unreleased]
+### Added
+- `SwtExec` can now plays nicely with Kotlin coroutines.
+- `CoatMux.Layer` now exposes its root `Control` instance ([#12](https://github.com/diffplug/durian-swt/issues/12)).
+- `VScrollCtl` and `VScrollBubble` for easier VScroll handling ([#10](https://github.com/diffplug/durian-swt/issues/10)).
+### Changed
+- **BREAKING** `SwtRx` is now based on Kotlin Flow rather than RxJava.
+### Removed
+- **BREAKING** Removed `ColorPool.getSystemColor()` ([#8](https://github.com/diffplug/durian-swt/issues/8)).
+- **BREAKING** Switched type arguments of `TypedDataField` ([#3](https://github.com/diffplug/durian-swt/issues/3)).
+- **BREAKING** Removed OSGi metadata.
 
 ## [3.6.1] - 2022-02-18
 ### Fixed

build.gradle

@@ -35,8 +35,6 @@ subprojects { subProject ->
 		options.linksOffline 'https://help.eclipse.org/2019-12/topic/org.eclipse.platform.doc.isv/reference/api/', rootProject.file('gradle/javadoc-eclipse').absolutePath
 	}
 
-	apply from: 干.file('base/osgi.gradle')
-
 	if (subProject.name == 'durian-swt') {
 		// configured there
 	} else if (subProject.name == 'durian-swt.os') {

durian-swt/build.gradle

@@ -1,3 +1,5 @@
+apply from: 干.file('base/kotlin.gradle')
+
 apply plugin: 'com.diffplug.eclipse.mavencentral'
 eclipseMavenCentral {
 	release SWT_VERSION, {
@@ -15,6 +17,7 @@ dependencies {
 	implementation "com.diffplug.durian:durian-concurrent:$VER_DURIAN"
 	compileOnly 'com.google.code.findbugs:jsr305:3.0.2'
 	compileOnly 'com.google.code.findbugs:annotations:3.0.1'
+	compileOnly "org.jetbrains:annotations:23.0.0"
 
 	testImplementation "junit:junit:$VER_JUNIT"
 	testImplementation "org.assertj:assertj-core:$VER_ASSERTJ"

durian-swt/src/main/java/com/diffplug/common/swt/Coat.java

@@ -0,0 +1,65 @@
+/*
+ * Copyright 2020 DiffPlug
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.diffplug.common.swt
+
+import com.diffplug.common.swt.Coat.Returning
+import org.eclipse.swt.widgets.Composite
+
+/**
+ * A function that can be "put on" a blank [Composite].
+ *
+ *
+ * An SWT Composite is a blank canvas.  As such, it's common to write functions
+ * that look like `void initializeCmp(Composite cmp)`. In order to make higher-order
+ * functionality, such as a utility for stacking `Composite`s, you need a way to pass
+ * these kinds of functions as arguments. That's what `Coat` does.
+ */
+fun interface Coat {
+    /**
+     * Populates the given composite.
+     * Caller promises that the composite has no layout and contains no children.
+     */
+    fun putOn(cmp: Composite)
+
+    /** A Coat which returns a handle to the content it created.  */
+    fun interface Returning<T> {
+        /**
+         * Populates the given composite, and returns a handle for communicating with the created GUI.
+         * Caller promises that the composite has no layout, and contains no children.
+         */
+        fun putOn(cmp: Composite): T
+
+        companion object {
+            /** Converts a non-returning Coat to a Coat.Returning.  */
+            fun <T> fromNonReturning(coat: Coat, returnValue: T): Returning<T> {
+                return Returning { cmp: Composite ->
+                    coat.putOn(cmp)
+                    returnValue
+                }
+            }
+        }
+    }
+
+    companion object {
+        /** A Coat which does nothing.  */
+		@JvmStatic
+		fun empty(): Coat {
+            return EMPTY
+        }
+
+        val EMPTY = Coat { cmp: Composite -> }
+    }
+}

durian-swt/src/main/java/com/diffplug/common/swt/Coat.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright 2020 DiffPlug
+ * Copyright (C) 2020-2022 DiffPlug
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -82,6 +82,11 @@ public RxGetter<Boolean> rxOnTop() {
 			return currentLayer.map(opt -> opt.isPresent() && opt.get() == this);
 		}
 
+		/** The control at the root of this layer. */
+		public Control getControl() {
+			return control;
+		}
+
 		/** The handle which was returned by the {@link Coat.Returning}. */
 		public T getHandle() {
 			return handle;
@@ -107,7 +112,7 @@ public Chit chit() {
 
 	/** Adds a persistent {@link Layer} which will be populated immediately by the given `Coat`, using `value` as the key. */
 	public <T> Layer<T> addCoat(Coat coat, @Nullable T value) {
-		return addCoat(Coat.Returning.fromNonReturning(coat, value));
+		return addCoat(Coat.Returning.Companion.fromNonReturning(coat, value));
 	}
 
 	/** Adds a persistent {@link Layer} which will be populated immediately by the given `Coat.Returning`, using the return value as the key. */
@@ -161,7 +166,7 @@ private <T> T makeTemporary(Layer<T> layer) {
 
 	/** Sets the current content of this `CoatMux`, gets disposed as soon as anything else becomes the top layer. */
 	public void setCoat(Coat coat) {
-		setCoatReturning(Coat.Returning.fromNonReturning(coat, null));
+		setCoatReturning(Coat.Returning.Companion.fromNonReturning(coat, null));
 	}
 
 	/** Sets the current content of this `CoatMux`, gets disposed as soon as anything else becomes the top layer. */

durian-swt/src/main/java/com/diffplug/common/swt/CoatMux.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2020 DiffPlug
+ * Copyright (C) 2020-2022 DiffPlug
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,37 +16,20 @@
 package com.diffplug.common.swt;
 
 
-import com.diffplug.common.collect.Maps;
 import java.util.HashMap;
-import org.eclipse.swt.SWT;
 import org.eclipse.swt.graphics.Color;
 import org.eclipse.swt.graphics.RGB;
-import org.eclipse.swt.widgets.Display;
 import org.eclipse.swt.widgets.Widget;
 
 /** Caches {@link Color}s, and automatically manages their disposal. */
 public class ColorPool {
-	private final HashMap<RGB, Color> colorTable = Maps.newHashMap();
-	private final Display display;
+	private final HashMap<RGB, Color> colorTable = new HashMap<>();
 
-	private ColorPool(Widget parent) {
-		display = parent.getDisplay();
-		parent.addListener(SWT.Dispose, e -> colorTable.values().forEach(Color::dispose));
-	}
+	private ColorPool() {}
 
 	/** Returns a Color for the given RGB value. */
 	public Color getColor(RGB rgb) {
-		Color color = colorTable.get(rgb);
-		if (color == null) {
-			color = new Color(display, rgb);
-			colorTable.put(rgb, color);
-		}
-		return color;
-	}
-
-	/** Returns a Color for the SWT.COLOR_xxx. */
-	public Color getSystemColor(int systemColor) {
-		return display.getSystemColor(systemColor);
+		return colorTable.computeIfAbsent(rgb, raw -> new Color(raw));
 	}
 
 	/** Returns a ColorPool for the given Widget, creating one if necessary. */
@@ -59,5 +42,5 @@ public static ColorPool forWidget(ControlWrapper wrapper) {
 		return onePerWidget.forWidget(wrapper.getRootControl());
 	}
 
-	private static final OnePerWidget<Widget, ColorPool> onePerWidget = OnePerWidget.from(ColorPool::new);
+	private static final OnePerWidget<Widget, ColorPool> onePerWidget = OnePerWidget.from(unused -> new ColorPool());
 }

durian-swt/src/main/java/com/diffplug/common/swt/ColorPool.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2020 DiffPlug
+ * Copyright (C) 2020-2022 DiffPlug
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -18,6 +18,8 @@
 
 import com.diffplug.common.base.Preconditions;
 import org.eclipse.swt.SWT;
+import org.eclipse.swt.graphics.Point;
+import org.eclipse.swt.graphics.Rectangle;
 import org.eclipse.swt.layout.FillLayout;
 import org.eclipse.swt.layout.GridData;
 import org.eclipse.swt.layout.GridLayout;
@@ -230,4 +232,58 @@ public static LayoutsRowData newRowPlaceholder(Composite parent) {
 		Label placeholder = new Label(parent, SWT.NONE);
 		return setRowData(placeholder);
 	}
+
+	////////////
+	// Single //
+	////////////
+	public static void setSingle(Composite composite) {
+		Single.child(composite);
+		composite.setLayout(standardMargin);
+	}
+
+	public static void setSingleNoMargin(Composite composite) {
+		Single.child(composite);
+		composite.setLayout(noMargin);
+	}
+
+	private static final Single noMargin = new Single();
+	private static final Single standardMargin = new Single();
+
+	private static class Single extends Layout {
+		private static Control child(Composite composite) {
+			Control[] children = composite.getChildren();
+			if (children.length == 1) {
+				return children[0];
+			} else {
+				throw new IllegalArgumentException("Must have 1 child, had " + children.length);
+			}
+		}
+
+		@Override
+		protected Point computeSize(Composite composite, int wHint, int hHint, boolean flushCache) {
+			Point child = child(composite).computeSize(wHint, hHint, flushCache);
+			if (this == noMargin) {
+				return child;
+			} else {
+				child.x += Layouts.defaultMargin() * 2;
+				child.y += Layouts.defaultMargin() * 2;
+				return child;
+			}
+		}
+
+		@Override
+		protected void layout(Composite composite, boolean flushCache) {
+			Control child = child(composite);
+			Rectangle area = composite.getClientArea();
+			if (this == standardMargin) {
+				area.x += Layouts.defaultMargin();
+				area.y += Layouts.defaultMargin();
+				area.width -= 2 * Layouts.defaultMargin();
+				area.height -= 2 * Layouts.defaultMargin();
+				area.width = Math.max(area.width, 1);
+				area.height = Math.max(area.height, 1);
+			}
+			child.setBounds(area);
+		}
+	}
 }