JavaFX only calls {@code stop()} on the instance it launched itself, so an exit
- * after a profile switch has to release the resources explicitly.
+ * Releases the live runtime's resources explicitly: after a profile switch that is
+ * no longer the instance the process started with.
*/
public static void exitApplication() {
@@ -61,7 +58,6 @@ public final class ApplicationRuntimeLauncher {
currentRuntime.shutdownRuntime();
}
- Platform.exit();
System.exit(0);
}
@@ -88,14 +84,13 @@ public final class ApplicationRuntimeLauncher {
Kst4ContestApplication nextRuntime = new Kst4ContestApplication();
try {
- nextRuntime.start(new Stage());
+ nextRuntime.startRuntime();
} catch (Exception e) {
// The previous runtime is already gone, so there is nothing left to return to.
LOGGER.log(Level.SEVERE, "Could not start the selected operator profile", e);
Kst4ContestApplication.alertWindowEvent(
"The operator profile could not be started: " + e.getMessage()
+ "\n\nKST4Contest has to be closed.");
- Platform.exit();
System.exit(1);
return false;
}
diff --git a/app-desktop/src/main/java/kst4contest/view/AwtUiDispatcher.java b/app-desktop/src/main/java/kst4contest/view/AwtUiDispatcher.java
new file mode 100644
index 00000000..11f33378
--- /dev/null
+++ b/app-desktop/src/main/java/kst4contest/view/AwtUiDispatcher.java
@@ -0,0 +1,41 @@
+package kst4contest.view;
+
+import kst4contest.observe.UiDispatcher;
+
+import java.awt.EventQueue;
+
+/**
+ * The {@link UiDispatcher} backed by the AWT event dispatch thread.
+ *
+ * That is the thread Compose Desktop composes on, so this is where user-interface
+ * state belongs. The contract is the one {@code JavaFxUiDispatcher} had, down to the
+ * inline execution: a task handed over from the user-interface thread runs before
+ * {@link #runOnUi(Runnable)} returns rather than queueing behind work that is already
+ * pending. Several callers in {@code ChatController} ask {@link #isUiThread()} first and
+ * rely on exactly that.
+ */
+public class AwtUiDispatcher implements UiDispatcher {
+
+ @Override
+ public void runOnUi(Runnable task) {
+ if (EventQueue.isDispatchThread()) {
+ runGuarded(task);
+ } else {
+ EventQueue.invokeLater(() -> runGuarded(task));
+ }
+ }
+
+ @Override
+ public boolean isUiThread() {
+ return EventQueue.isDispatchThread();
+ }
+
+ private static void runGuarded(Runnable task) {
+ try {
+ task.run();
+ } catch (RuntimeException e) {
+ // Must not tear down the AWT event dispatch thread.
+ System.err.println("[observe] UI task failed: " + e);
+ }
+ }
+}
diff --git a/app-desktop/src/main/java/kst4contest/view/CoalescingTrigger.java b/app-desktop/src/main/java/kst4contest/view/CoalescingTrigger.java
new file mode 100644
index 00000000..6730eaa4
--- /dev/null
+++ b/app-desktop/src/main/java/kst4contest/view/CoalescingTrigger.java
@@ -0,0 +1,38 @@
+package kst4contest.view;
+
+import javax.swing.Timer;
+import java.util.Objects;
+
+/**
+ * Collapses a burst of requests into one run, a fixed delay after the last of them.
+ *
+ * Replaces the JavaFX pause transition the station list used. A
+ * {@code javax.swing.Timer} fires on the AWT event thread, which is where the user
+ * interface lives, and {@code restart()} means exactly what that class's
+ * {@code playFromStart()} meant. The old one needed a running JavaFX toolkit, which the
+ * application no longer starts.
+ */
+public final class CoalescingTrigger {
+
+ private final Timer timer;
+
+ /**
+ * @param delayMs how long to wait after the last request
+ * @param action runs on the user-interface thread once the delay elapses
+ */
+ public CoalescingTrigger(final int delayMs, final Runnable action) {
+ Objects.requireNonNull(action, "action");
+ this.timer = new Timer(delayMs, event -> action.run());
+ this.timer.setRepeats(false);
+ }
+
+ /** Requests a run, restarting the delay. */
+ public void trigger() {
+ timer.restart();
+ }
+
+ /** Drops a pending run. Idempotent, and the trigger stays usable afterwards. */
+ public void cancel() {
+ timer.stop();
+ }
+}
diff --git a/app-desktop/src/main/java/kst4contest/view/ComposeChatInputActions.java b/app-desktop/src/main/java/kst4contest/view/ComposeChatInputActions.java
index 683b9b3b..cbbe6286 100644
--- a/app-desktop/src/main/java/kst4contest/view/ComposeChatInputActions.java
+++ b/app-desktop/src/main/java/kst4contest/view/ComposeChatInputActions.java
@@ -28,11 +28,12 @@ public final class ComposeChatInputActions implements ChatInputActions {
@Override
public ChatMember tableSelection() {
- if (application.tbl_chatMember == null
- || application.tbl_chatMember.getSelectionModel() == null) {
- return null;
- }
- return application.tbl_chatMember.getSelectionModel().getSelectedItem();
+ /*
+ * The JavaFX station table is gone. Kept rather than dropped from the interface
+ * because ChatInputState's three-step lookup is the documented selection order, and
+ * a Compose station selection may fill this in again.
+ */
+ return null;
}
@Override
diff --git a/app-desktop/src/main/java/kst4contest/view/ComposeMenuActions.java b/app-desktop/src/main/java/kst4contest/view/ComposeMenuActions.java
index 1d9ddf73..505fc3f5 100644
--- a/app-desktop/src/main/java/kst4contest/view/ComposeMenuActions.java
+++ b/app-desktop/src/main/java/kst4contest/view/ComposeMenuActions.java
@@ -1,20 +1,15 @@
package kst4contest.view;
-import javafx.scene.control.MenuItem;
import kst4contest.view.compose.MainMenuActions;
-import java.util.function.Supplier;
-
/**
- * The Compose menu bar's actions, delegated to the JavaFX menu items they mirror.
+ * The Compose menu bar's actions, delegated to methods on {@link Kst4ContestApplication}.
*
- * Firing the very same {@link MenuItem} is deliberate. The two bars run side by side while
- * the operator compares the windows, and a second implementation of seventeen handlers would
- * be a second thing to compare — differences between the bars would be indistinguishable from
- * differences between the windows.
- *
- * When the JavaFX window goes, those handlers move into methods of their own and this class
- * calls those instead. Until then it is a bridge, not a design.
+ * These used to fire the {@code MenuItem}s of the old JavaFX menu bar,
+ * which ran side by side with the Compose bar so the two could be compared. The JavaFX bar is
+ * gone (part 3), so the handlers now live in {@code menuAction…} methods of the application and
+ * this class calls those directly. It stays a thin bridge: no behaviour of its own, one call per
+ * menu entry.
*/
public final class ComposeMenuActions implements MainMenuActions {
@@ -26,12 +21,12 @@ public final class ComposeMenuActions implements MainMenuActions {
@Override
public void connect() {
- fire(() -> application.menuItemFileConnect);
+ application.runOnUi(application::menuActionConnect);
}
@Override
public void disconnect() {
- fire(() -> application.menuItemFileDisconnect);
+ application.runOnUi(application::menuActionDisconnect);
}
@Override
@@ -41,96 +36,80 @@ public final class ComposeMenuActions implements MainMenuActions {
@Override
public void exitApplication() {
- fire(() -> application.menuItemFileExit);
+ application.runOnUi(application::menuActionExit);
}
@Override
public void setQrgAsNameInChat() {
- fire(() -> application.menuItemOptionsSetFrequencyAsName);
+ application.runOnUi(application::menuActionSetQrgAsNameInChat);
}
@Override
public void toggleAwayState() {
- fire(() -> application.menuItemOptionsAwayBack);
+ application.runOnUi(application::menuActionToggleAwayState);
}
@Override
public void toggleSettingsWindow() {
- fire(() -> application.menuItemOptionsShow);
+ application.runOnUi(application::menuActionToggleSettingsWindow);
}
@Override
public void toggleMonitorWindow() {
- fire(() -> application.menuItemWindowCluster);
+ application.runOnUi(application::menuActionToggleMonitorWindow);
}
@Override
public void toggleStationMap() {
- fire(() -> application.menuItemWindowStationMap);
+ application.runOnUi(application::menuActionToggleStationMap);
}
@Override
public void useDarkDesign() {
- fire(() -> application.menuItemWindowDarkDesign);
+ application.runOnUi(application::menuActionUseDarkDesign);
}
@Override
public void useDefaultDesign() {
- fire(() -> application.menuItemWindowDefaultDesign);
+ application.runOnUi(application::menuActionUseDefaultDesign);
}
@Override
public void openDonationPage() {
- fire(() -> application.menuItemInfoDonate);
+ application.runOnUi(application::menuActionOpenDonationPage);
}
@Override
public void openHomepage() {
- fire(() -> application.menuItemInfoHomepage);
+ application.runOnUi(application::menuActionOpenHomepage);
}
@Override
public void openNewsgroup() {
- fire(() -> application.menuItemInfoNewsgroup);
+ application.runOnUi(application::menuActionOpenNewsgroup);
}
@Override
public void openChangelog() {
/*
- * The JavaFX item and its handler are both commented out, so there is nothing to
- * fire. The Compose menu no longer offers this either; the method stays because the
- * interface is shared and an empty body is honest about there being no such feature.
+ * The JavaFX item and its handler were both commented out, so there is nothing to do.
+ * The method stays because the interface is shared and an empty body is honest about
+ * there being no such feature.
*/
}
@Override
public void openOv3tDonationPage() {
- fire(() -> application.menuItemInfoDonateOv3t);
+ application.runOnUi(application::menuActionOpenOv3tDonationPage);
}
@Override
public void contactAuthor() {
- fire(() -> application.menuItemInfoContact);
+ application.runOnUi(application::menuActionContactAuthor);
}
@Override
public void showAbout() {
- fire(() -> application.menuItemInfoAbout);
- }
-
- /**
- * Fires a menu item on the JavaFX thread.
- *
- * The item is looked up when the action runs rather than when this class is built,
- * because initMenuBar creates them after the runtime exists. A missing item is ignored:
- * a menu entry that cannot act is better than a crash mid contest.
- */
- private void fire(final Supplier