Phase 2.2: Add ToolBar/StatusBar simulation controls and speed indicator integration

Agent-Logs-Url: https://github.com/bedaHovorka/interlockSim/sessions/a05d505b-27f4-4dc3-8ad6-c336a6ca4ec8

Co-authored-by: bedaHovorka <5263405+bedaHovorka@users.noreply.github.com>

Author: Copilot

desktop-ui/src/main/kotlin/cz/vutbr/fit/interlockSim/gui/Frame.kt

@@ -104,8 +104,13 @@ class Frame : JFrame(PROGRAM_FULL_NAME) {
 	private var eventTimelinePanel: cz.vutbr.fit.interlockSim.gui.animation.EventTimelinePanel? = null
 	private var animationUpdateTimer: Timer? = null
 
+	// South panel: always at BorderLayout.SOUTH; holds StatusBar and optionally EventTimelinePanel
+	private val southPanel: JPanel = JPanel().apply {
+		layout = BoxLayout(this, BoxLayout.Y_AXIS)
+	}
+
 	// Simulation lifecycle delegated to SimulationController for testability (Issue #189)
-	internal val simulationController: SimulationController = SimulationController(controlPanel)
+	internal val simulationController: SimulationController = SimulationController(controlPanel, toolBar, statusBar)
 	private var currentSimulationContext: SimulationContext? = null
 
 	/**
@@ -131,8 +136,10 @@ class Frame : JFrame(PROGRAM_FULL_NAME) {
 		northContainer.add(controlPanel)
 		contentPane.add(northContainer, BorderLayout.NORTH)
 
+		// South panel contains StatusBar (edit mode) and EventTimelinePanel (simulation mode)
 		statusBar.registerProducer(railwayNetGridCanvas)
-		contentPane.add(statusBar, BorderLayout.SOUTH)
+		southPanel.add(statusBar)
+		contentPane.add(southPanel, BorderLayout.SOUTH)
 
 		// Add component listener to refresh canvas when frame is resized
 		addComponentListener(
@@ -157,8 +164,8 @@ class Frame : JFrame(PROGRAM_FULL_NAME) {
 	/**
 	 * Switch UI layout to simulation mode (Issue #205).
 	 *
-	 * - Hides StatusBar
-	 * - Shows EventTimelinePanel (if created)
+	 * - Hides StatusBar (shown by speed indicator when speed != 1.0x)
+	 * - Shows EventTimelinePanel in south panel (if created)
 	 * - Shows ControlPanel
 	 * - Disables editing ToolBar
 	 *
@@ -169,11 +176,13 @@ class Frame : JFrame(PROGRAM_FULL_NAME) {
 			"switchToSimulationMode must be called from EDT"
 		}
 
-		// Hide StatusBar, show EventTimelinePanel
+		// Hide StatusBar; speed indicator (updateSpeedIndicator) will show it when speed != 1.0x
 		statusBar.isVisible = false
-		contentPane.remove(statusBar)
-		eventTimelinePanel?.let {
-			contentPane.add(it, BorderLayout.SOUTH)
+		// Add EventTimelinePanel to south panel
+		eventTimelinePanel?.let { panel ->
+			if (panel.parent == null) {
+				southPanel.add(panel, 0)
+			}
 		}
 
 		// Show ControlPanel
@@ -183,6 +192,8 @@ class Frame : JFrame(PROGRAM_FULL_NAME) {
 		// Disable editing toolbar in simulation mode
 		toolBar.setToolsEnabled(false)
 
+		southPanel.revalidate()
+		southPanel.repaint()
 		contentPane.revalidate()
 		contentPane.repaint()
 	}
@@ -202,11 +213,10 @@ class Frame : JFrame(PROGRAM_FULL_NAME) {
 			"switchToEditingMode must be called from EDT"
 		}
 
-		// Show StatusBar, hide EventTimelinePanel
-		eventTimelinePanel?.let {
-			contentPane.remove(it)
+		// Remove EventTimelinePanel from south panel; show StatusBar
+		eventTimelinePanel?.let { panel ->
+			southPanel.remove(panel)
 		}
-		contentPane.add(statusBar, BorderLayout.SOUTH)
 		statusBar.isVisible = true
 
 		// Hide ControlPanel
@@ -215,6 +225,8 @@ class Frame : JFrame(PROGRAM_FULL_NAME) {
 		// Enable editing toolbar in editing mode
 		toolBar.setToolsEnabled(true)
 
+		southPanel.revalidate()
+		southPanel.repaint()
 		contentPane.revalidate()
 		contentPane.repaint()
 	}

desktop-ui/src/main/kotlin/cz/vutbr/fit/interlockSim/gui/SimulationController.kt

@@ -13,6 +13,7 @@ package cz.vutbr.fit.interlockSim.gui
 import cz.vutbr.fit.interlockSim.context.SimulationContext
 import cz.vutbr.fit.interlockSim.gui.animation.ControlPanel
 import io.github.oshai.kotlinlogging.KotlinLogging
+import java.beans.PropertyChangeListener
 import javax.swing.SwingUtilities
 
 /**
@@ -39,13 +40,17 @@ import javax.swing.SwingUtilities
  * - [onCompleted] is always dispatched to EDT via [SwingUtilities.invokeLater].
  *
  * @param controlPanel ControlPanel whose Stop button and status label are managed here.
+ * @param toolBar Optional [ToolBar] to show/hide simulation controls on lifecycle changes.
+ * @param statusBar Optional [StatusBar] to display speed indicator when speed != 1.0x.
  * @param onCompleted Callback invoked on EDT when the simulation finishes naturally.
  *   Defaults to a no-op if not provided.
  * @since 2026-04-20 (extracted from Frame for testability)
  * @see Frame
  */
 internal class SimulationController(
 	private val controlPanel: ControlPanel,
+	private val toolBar: ToolBar? = null,
+	private val statusBar: StatusBar? = null,
 	private val onCompleted: () -> Unit = {},
 ) {
 	/**
@@ -57,6 +62,9 @@ internal class SimulationController(
 	var runner: SimulationRunner? = null
 		private set
 
+	/** Listener registered on the active runner for speed changes; removed on stop. */
+	private var speedListener: PropertyChangeListener? = null
+
 	/**
 	 * Start the simulation for [context].
 	 *
@@ -87,6 +95,17 @@ internal class SimulationController(
 		// thread. This ensures stopSimulation() always has a live thread to interrupt.
 		newRunner.start()
 
+		// Wire speed indicator: notify StatusBar whenever SimulationRunner speed changes.
+		// The listener is removed when the simulation stops (in stop() or monitor finally).
+		val listener = PropertyChangeListener { evt ->
+			statusBar?.updateSpeedIndicator(evt.newValue as Double)
+		}
+		speedListener = listener
+		newRunner.addPropertyChangeListener(SimulationRunner.PROP_SPEED_MULTIPLIER, listener)
+
+		// Show simulation controls in ToolBar (EDT-safe: start() is called from EDT).
+		toolBar?.showSimulationControls()
+
 		controlPanel.updateStatus(ControlPanel.SimulationStatus.RUNNING)
 		controlPanel.setStopEnabled(true)
 
@@ -118,7 +137,10 @@ internal class SimulationController(
 							// instance. Skip the reset to avoid clobbering the new run's panel
 							// state (and avoid firing onCompleted for the old run).
 							if (runner === newRunner) {
+								cleanupSpeedListener(newRunner)
 								runner = null
+								toolBar?.hideSimulationControls()
+								statusBar?.updateSpeedIndicator(SimulationRunner.DEFAULT_SPEED)
 								controlPanel.updateStatus(ControlPanel.SimulationStatus.STOPPED)
 								controlPanel.setStopEnabled(false)
 								onCompleted()
@@ -139,12 +161,21 @@ internal class SimulationController(
 	 */
 	fun stop() {
 		val r = runner ?: return
+		cleanupSpeedListener(r)
 		r.stop()
 		runner = null
+		toolBar?.hideSimulationControls()
+		statusBar?.updateSpeedIndicator(SimulationRunner.DEFAULT_SPEED)
 		controlPanel.setStopEnabled(false)
 		controlPanel.updateStatus(ControlPanel.SimulationStatus.STOPPED)
 	}
 
+	/** Removes the speed [PropertyChangeListener] from [r] and clears the reference. */
+	private fun cleanupSpeedListener(r: SimulationRunner) {
+		speedListener?.let { r.removePropertyChangeListener(SimulationRunner.PROP_SPEED_MULTIPLIER, it) }
+		speedListener = null
+	}
+
 	/** Returns `true` while the underlying [SimulationRunner] reports running. */
 	fun isRunning(): Boolean = runner?.isRunning() ?: false
 

desktop-ui/src/main/kotlin/cz/vutbr/fit/interlockSim/gui/StatusBar.kt

@@ -18,6 +18,7 @@ import java.awt.Dimension
 import java.awt.event.MouseEvent
 import java.awt.event.MouseMotionListener
 import javax.swing.JLabel
+import javax.swing.SwingUtilities
 
 /**
  * Status bar for displaying context information and mouse motion status
@@ -89,4 +90,30 @@ class StatusBar :
 		timer.isRepeats = false
 		timer.start()
 	}
+
+	/**
+	 * Updates the speed indicator display.
+	 *
+	 * Shows speed information in the status bar when the multiplier differs from
+	 * real-time (1.0x). Hides the status bar when running at default speed.
+	 *
+	 * EDT-safe: uses [SwingUtilities.invokeLater] if called from a background thread.
+	 *
+	 * @param multiplier Current speed multiplier from [cz.vutbr.fit.interlockSim.gui.SimulationRunner]
+	 */
+	fun updateSpeedIndicator(multiplier: Double) {
+		SwingUtilities.invokeLater {
+			if (kotlin.math.abs(multiplier - DEFAULT_SPEED) > SPEED_EPSILON) {
+				text = "Speed: ${"%.1f".format(multiplier)}x"
+				isVisible = true
+			} else {
+				isVisible = false
+			}
+		}
+	}
+
+	companion object {
+		private const val DEFAULT_SPEED = 1.0
+		private const val SPEED_EPSILON = 0.001
+	}
 }

desktop-ui/src/main/kotlin/cz/vutbr/fit/interlockSim/gui/ToolBar.kt

@@ -23,6 +23,7 @@ import java.awt.Dimension
 import java.awt.event.ActionEvent
 import javax.swing.AbstractAction
 import javax.swing.ButtonGroup
+import javax.swing.JLabel
 import javax.swing.JToggleButton
 import javax.swing.JToolBar
 
@@ -121,4 +122,37 @@ class ToolBar : JToolBar() {
 			component.isEnabled = enabled
 		}
 	}
+
+	private val simControlsSeparator: JToolBar.Separator = JToolBar.Separator()
+	private val simControlsLabel: JLabel = JLabel("▶ Simulation")
+
+	/**
+	 * Shows the simulation controls panel in the toolbar.
+	 *
+	 * Called when a simulation starts to indicate simulation mode visually.
+	 * Idempotent: safe to call if controls are already showing.
+	 * Must be called from the Event Dispatch Thread (EDT).
+	 */
+	fun showSimulationControls() {
+		if (simControlsLabel.parent != null) return
+		add(simControlsSeparator)
+		add(simControlsLabel)
+		revalidate()
+		repaint()
+	}
+
+	/**
+	 * Hides the simulation controls panel from the toolbar.
+	 *
+	 * Called when a simulation stops to return to editing mode appearance.
+	 * Idempotent: safe to call if controls are not currently showing.
+	 * Must be called from the Event Dispatch Thread (EDT).
+	 */
+	fun hideSimulationControls() {
+		if (simControlsLabel.parent == null) return
+		remove(simControlsSeparator)
+		remove(simControlsLabel)
+		revalidate()
+		repaint()
+	}
 }

desktop-ui/src/test/kotlin/cz/vutbr/fit/interlockSim/gui/FrameTest.kt

@@ -15,6 +15,7 @@ import assertk.assertThat
 import assertk.assertions.isEqualTo
 import assertk.assertions.isInstanceOf
 import assertk.assertions.isNotNull
+import assertk.assertions.isTrue
 import cz.vutbr.fit.interlockSim.PROGRAM_FULL_NAME
 import cz.vutbr.fit.interlockSim.context.EditingContext
 import cz.vutbr.fit.interlockSim.context.EditingContextFactory
@@ -146,12 +147,16 @@ class FrameTest : AbstractFrameTestBase() {
 
 	@Test
 	@Timeout(value = 5, unit = TimeUnit.SECONDS)
-	@DisplayName("frame has status bar at south")
+	@DisplayName("frame has status bar in south panel")
 	fun frameHasStatusBarAtSouth() {
 		runOnEDT {
+			// SOUTH now contains a southPanel (JPanel) that wraps StatusBar and EventTimelinePanel
 			val southComponent = (frame.contentPane.layout as BorderLayout).getLayoutComponent(BorderLayout.SOUTH)
 			assertThat(southComponent).isNotNull()
-			assertThat(southComponent).isInstanceOf(StatusBar::class)
+			assertThat(southComponent).isInstanceOf(javax.swing.JPanel::class)
+			// StatusBar must be accessible and correctly initialised
+			assertThat(frame.statusBar).isInstanceOf(StatusBar::class)
+			assertThat(frame.statusBar.isVisible).isTrue()
 		}
 	}
 

desktop-ui/src/test/kotlin/cz/vutbr/fit/interlockSim/gui/SimulationControllerTest.kt

@@ -445,6 +445,80 @@ class SimulationControllerTest {
 
 	// ── helpers ───────────────────────────────────────────────────────────────
 
+	// ── toolBar / statusBar wiring ────────────────────────────────────────────
+
+	@Test
+	@Timeout(value = 10, unit = TimeUnit.SECONDS)
+	@DisplayName("speed change on runner propagates to StatusBar indicator")
+	fun speedChangePropagatestoStatusBar() {
+		val started = CountDownLatch(1)
+		val blockSim = CountDownLatch(1)
+		every { context.run() } answers {
+			started.countDown()
+			blockSim.await(10, TimeUnit.SECONDS)
+		}
+
+		val statusBar = StatusBar()
+
+		val controller = SimulationController(controlPanel, statusBar = statusBar)
+		controller.start(context)
+		assertThat(started.await(5, TimeUnit.SECONDS)).isTrue()
+
+		// Change speed via runner — this fires PROP_SPEED_MULTIPLIER
+		controller.runner!!.speedMultiplier = 2.0
+
+		// Flush EDT twice (listener calls invokeLater, so two flushes are needed)
+		SwingUtilities.invokeAndWait { /* flush 1 */ }
+		SwingUtilities.invokeAndWait { /* flush 2 */ }
+
+		SwingUtilities.invokeAndWait {
+			assertThat(findSpeedText(statusBar)).isEqualTo("Speed: 2.0x")
+			assertThat(statusBar.isVisible).isTrue()
+		}
+
+		blockSim.countDown()
+		controller.stop()
+	}
+
+	@Test
+	@Timeout(value = 10, unit = TimeUnit.SECONDS)
+	@DisplayName("stop resets StatusBar speed indicator to hidden")
+	fun stopResetsStatusBarSpeedIndicator() {
+		val started = CountDownLatch(1)
+		val blockSim = CountDownLatch(1)
+		every { context.run() } answers {
+			started.countDown()
+			blockSim.await(10, TimeUnit.SECONDS)
+		}
+
+		val statusBar = StatusBar()
+
+		val controller = SimulationController(controlPanel, statusBar = statusBar)
+		controller.start(context)
+		assertThat(started.await(5, TimeUnit.SECONDS)).isTrue()
+
+		// Set non-default speed, then stop
+		controller.runner!!.speedMultiplier = 3.0
+		SwingUtilities.invokeAndWait { /* flush */ }
+		SwingUtilities.invokeAndWait { /* flush invokeLater */ }
+
+		controller.stop()
+		blockSim.countDown()
+
+		// Stop calls updateSpeedIndicator(DEFAULT_SPEED) via invokeLater
+		SwingUtilities.invokeAndWait { /* flush stop's invokeLater */ }
+		SwingUtilities.invokeAndWait { /* flush nested */ }
+
+		SwingUtilities.invokeAndWait {
+			assertThat(statusBar.isVisible).isFalse()
+		}
+	}
+
+	// ── helpers ───────────────────────────────────────────────────────────────
+
+	private fun findSpeedText(statusBar: StatusBar): String? =
+		statusBar.text.takeIf { it.startsWith("Speed:") }
+
 	private fun findStopButton(): JButton? =
 		(0 until controlPanel.componentCount)
 			.mapNotNull { controlPanel.getComponent(it) as? JButton }