From 0ab9ffc2419ff4f2ddc4ae14fd0e2070adf3d95e Mon Sep 17 00:00:00 2001 From: Philipp Wagner Date: Wed, 18 Nov 2026 20:44:21 +0100 Subject: [PATCH] Add the setup wizard's antenna and power answers Written-by: DeepSeek V4 Pro Written-by: Claude Fable 5.2 --- .../view/compose/wizard/WizardAntenna.kt | 60 ++++++++++ .../view/compose/wizard/WizardAntennaTest.kt | 108 ++++++++++++++++++ 2 files changed, 168 insertions(+) create mode 100644 app-desktop/src/main/kotlin/kst4contest/view/compose/wizard/WizardAntenna.kt create mode 100644 app-desktop/src/test/kotlin/kst4contest/view/compose/wizard/WizardAntennaTest.kt diff --git a/app-desktop/src/main/kotlin/kst4contest/view/compose/wizard/WizardAntenna.kt b/app-desktop/src/main/kotlin/kst4contest/view/compose/wizard/WizardAntenna.kt new file mode 100644 index 00000000..1815e3ab --- /dev/null +++ b/app-desktop/src/main/kotlin/kst4contest/view/compose/wizard/WizardAntenna.kt @@ -0,0 +1,60 @@ +package kst4contest.view.compose.wizard + +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.setValue +import kst4contest.model.ChatPreferences +import kst4contest.view.compose.tabs.StationTabState + +/** + * The setup wizard's answers about antenna and power. + * + * These numbers have no empty state: every answer starts as the stored value and is a + * proposal the operator may pass unchanged, also when a station is set up anew. They feed the + * path analysis and the antenna sector on the map; the chat does not need them. + * + * The site elevation is the exception in form, not in rule: it is text, because empty is a + * value of its own -- "let the elevation model decide" -- and it is read exactly as the + * Station tab reads it. + * + * @param prefs the profile's preferences, already read from its file + */ +class WizardAntenna(prefs: ChatPreferences) { + + var beamWidthDeg: Double by mutableStateOf(prefs.getStn_antennaBeamWidthDeg()) + var gainDbi: Double by mutableStateOf(prefs.getStn_pathAnalysisOwnAntennaGainDbi()) + var heightMeters: Double by mutableStateOf(prefs.getStn_pathAnalysisOwnAntennaHeightMeters()) + var txPowerWatts: Double by mutableStateOf(prefs.getStn_pathAnalysisOwnTxPowerWatts()) + + /** The site elevation above sea level as the operator types it; empty for the model. */ + var heightAslText: String by mutableStateOf(elevationText(prefs.getStn_pathAnalysisOwnHeightAslMeters())) + + /** A site elevation that is neither empty nor a number in the accepted range. */ + val heightAslRefused: Boolean + get() = StationTabState.parseOwnHeightAsl(heightAslText) == null + + /** Whether every answer can be stored as it stands. */ + val complete: Boolean + get() = beamWidthDeg.isFinite() && gainDbi.isFinite() && heightMeters.isFinite() && + txPowerWatts.isFinite() && !heightAslRefused + + /** Puts the answers into [prefs]. Call only while [complete]. */ + fun writeTo(prefs: ChatPreferences) { + prefs.setStn_antennaBeamWidthDeg(beamWidthDeg) + prefs.setStn_pathAnalysisOwnAntennaGainDbi(gainDbi) + prefs.setStn_pathAnalysisOwnAntennaHeightMeters(heightMeters) + prefs.setStn_pathAnalysisOwnTxPowerWatts(txPowerWatts) + prefs.setStn_pathAnalysisOwnHeightAslMeters( + StationTabState.parseOwnHeightAsl(heightAslText) ?: Double.NaN + ) + } + + private companion object { + /** Empty for "unset"; a whole number without ".0", so the field shows what one types. */ + fun elevationText(meters: Double): String = when { + meters.isNaN() -> "" + meters == Math.floor(meters) && !meters.isInfinite() -> meters.toLong().toString() + else -> meters.toString() + } + } +} diff --git a/app-desktop/src/test/kotlin/kst4contest/view/compose/wizard/WizardAntennaTest.kt b/app-desktop/src/test/kotlin/kst4contest/view/compose/wizard/WizardAntennaTest.kt new file mode 100644 index 00000000..8cd22471 --- /dev/null +++ b/app-desktop/src/test/kotlin/kst4contest/view/compose/wizard/WizardAntennaTest.kt @@ -0,0 +1,108 @@ +package kst4contest.view.compose.wizard + +import kst4contest.model.ChatPreferences +import org.junit.jupiter.api.Assertions.assertEquals +import org.junit.jupiter.api.Assertions.assertFalse +import org.junit.jupiter.api.Assertions.assertTrue +import org.junit.jupiter.api.Test +import java.nio.file.Path + +/** + * The antenna and power answers: always proposals taken from what is stored, never empty, + * and the site elevation read the way the Station tab reads it. + */ +class WizardAntennaTest { + + private fun prefs(configure: ChatPreferences.() -> Unit = {}): ChatPreferences = + ChatPreferences(Path.of("wizard-antenna-test-unused.xml")).apply(configure) + + private fun stored() = prefs { + setStn_antennaBeamWidthDeg(28.0) + setStn_pathAnalysisOwnAntennaGainDbi(16.5) + setStn_pathAnalysisOwnAntennaHeightMeters(18.0) + setStn_pathAnalysisOwnTxPowerWatts(400.0) + setStn_pathAnalysisOwnHeightAslMeters(612.0) + } + + @Test + fun theAnswersStartAsTheStoredValues() { + val antenna = WizardAntenna(stored()) + + assertEquals(28.0, antenna.beamWidthDeg) + assertEquals(16.5, antenna.gainDbi) + assertEquals(18.0, antenna.heightMeters) + assertEquals(400.0, antenna.txPowerWatts) + assertEquals("612", antenna.heightAslText, "a whole number is shown without a decimal point") + assertTrue(antenna.complete) + } + + @Test + fun anUnsetSiteElevationIsAnEmptyField() { + val antenna = WizardAntenna(prefs { setStn_pathAnalysisOwnHeightAslMeters(Double.NaN) }) + + assertEquals("", antenna.heightAslText) + assertFalse(antenna.heightAslRefused, "empty means the elevation model, not an error") + assertTrue(antenna.complete) + } + + @Test + fun aFractionalSiteElevationKeepsItsFraction() { + val antenna = WizardAntenna(prefs { setStn_pathAnalysisOwnHeightAslMeters(250.5) }) + + assertEquals("250.5", antenna.heightAslText) + } + + @Test + fun theSiteElevationIsReadTheWayTheStationTabReadsIt() { + val antenna = WizardAntenna(stored()) + + listOf("", " ", "250", "250,5", "250.5", "-100").forEach { + antenna.heightAslText = it + assertFalse(antenna.heightAslRefused, "'$it' must be accepted") + } + listOf("abc", "99999", "-501", "12 m").forEach { + antenna.heightAslText = it + assertTrue(antenna.heightAslRefused, "'$it' must be refused") + assertFalse(antenna.complete) + } + } + + @Test + fun aNumberThatIsNotOneMakesThePageIncomplete() { + val antenna = WizardAntenna(stored()) + + antenna.gainDbi = Double.NaN + assertFalse(antenna.complete) + + antenna.gainDbi = 12.0 + antenna.txPowerWatts = Double.POSITIVE_INFINITY + assertFalse(antenna.complete) + } + + @Test + fun writingPutsTheAnswersIntoThePreferences() { + val target = prefs() + val antenna = WizardAntenna(stored()) + antenna.beamWidthDeg = 35.0 + antenna.heightAslText = "250,5" + + antenna.writeTo(target) + + assertEquals(35.0, target.getStn_antennaBeamWidthDeg()) + assertEquals(16.5, target.getStn_pathAnalysisOwnAntennaGainDbi()) + assertEquals(18.0, target.getStn_pathAnalysisOwnAntennaHeightMeters()) + assertEquals(400.0, target.getStn_pathAnalysisOwnTxPowerWatts()) + assertEquals(250.5, target.getStn_pathAnalysisOwnHeightAslMeters()) + } + + @Test + fun anEmptySiteElevationIsWrittenAsUnset() { + val target = prefs { setStn_pathAnalysisOwnHeightAslMeters(612.0) } + val antenna = WizardAntenna(stored()) + antenna.heightAslText = "" + + antenna.writeTo(target) + + assertTrue(target.getStn_pathAnalysisOwnHeightAslMeters().isNaN(), "empty hands the elevation back to the model") + } +}