Reduced opentopo api calls // added 4 char locator new-filter // added new band and tropo filter and priority sorter // decreased map load (#43)

* Added a map to show where other stn are // refactored message adding to tables for performance, max 30.000 msg now

* debugging map failure

* debugging map failure

* debugging map failure

* fix Pipeline Modules n map Linux

* changed UI design to save some space. Made the UI more reactive for smaller screens. Maximized resolution at startup to the possible maximum of the current display of the user

* Docs added for new Features

* Added filters and sorters for Tropo reachability, AS availability and new big fields / locators. Added reachability band selector for tropo calculation based on a choosen band

* Fixed worked-23cm-tag when working with dxlog/n1mm logger

* delete not needed files from repo

* Reduced opentopo api calls // added 4 char locator new-filter // added new band and tropo filter and priority sorter // decreased map load

---------

Co-authored-by: Marc Froehlich <praktimarc@gmail.com>

SimpleLogFile.txt

@@ -1,2 +0,0 @@
-S53MM
-PA9R

github_docs/de-Changelog.md

@@ -8,6 +8,18 @@ Versionsverlauf von KST4Contest / PraktiKST.
 
 letzter Changelog bitte aus GitHub entnehmen. Der bisherige Changelog
 
+## v1.41
+**Stationskarte, Performance, Reaktionsfähiges UI**
+
+**Neu:**
+- **Stationskarte**: Interaktive OpenStreetMap-Karte zeigt die geografische Position aller aktiven Chatmember. Enthält Stationsmarker, Antennen-Kegel, Verbindungslinie zur ausgewählten Station, Maidenhead-Raster-Overlay und ein Wegprofil-Diagramm mit Geländehöhen-Analyse (Fresnel-Zonen, Horizonterkennung). Geländedaten aus Copernicus GLO-30, Open-Meteo API oder Offline-DEM-Import. Aircraft-Scatter-Weganalyse integriert. Funktioniert in AppImage und Flatpak ohne externe CDN-Verbindung (lokaler Tile-Proxy, eingebettetes Leaflet.js).
+
+**Geändert:**
+- **Nachrichten-Tabellen-Limit auf 30.000 erhöht**: Chat- und Nachrichtentabellen sind auf 30.000 Einträge begrenzt. Ältere Nachrichten werden automatisch verworfen, was die Performance bei mehrtägigem Contest-Betrieb stabil hält.
+- **Bildschirmgerechte Fenstergröße**: Beim Start wird das Hauptfenster auf den aktuellen Bildschirm angepasst. Wenn KST4Contest zuletzt auf einem größeren Monitor betrieben wurde, wird das Fenster automatisch verkleinert. Das UI-Layout ist kompakter und reaktionsfähiger auf kleineren Bildschirmen.
+
+---
+
 ## v1.40 (2026-02-16)
 **Großes Feature-Release: Score-System, AP-Timeline, Win-Test, PSTRotator**
 

github_docs/de-Funktionen.md

@@ -235,3 +235,39 @@ Dateibasierte Log-Auswertung per Regex. Details: [Log-Synchronisation](Log-Synch
 Ein separates Fenster zeigt den QSO-Fluss zwischen anderen Stationen. Besonders interessant in ruhigeren Nacht-Stunden während des Contests, wenn weniger Verkehr herrscht.
 
 Dieses Fenster kann miniaturisiert werden, wenn es nicht benötigt wird. Zukünftig geplant: Filterung auf Stationen im ausgewählten QTF.
+
+---
+
+## Stationskarte (ab v1.41)
+
+Eine interaktive OpenStreetMap-Karte zeigt die geografische Position aller aktiven Chatmember.
+
+**Funktionen:**
+
+- Stationsmarker mit Rufzeichen-Labels, farblich nach Aktivität und Sked-Status
+- **Antennen-Kegel** für die eigene Station
+- **Verbindungslinie** zur aktuell ausgewählten Station
+- **Maidenhead-Raster** (QRA-Locator-Gitter als Overlay)
+- **Wegprofil-Diagramm**: Geländehöhen-Querschnitt zwischen eigener und ausgewählter Station, inklusive Fresnel-Zonen-Analyse und Horizonterkennung
+- Mehrere Terrainquellen: **Copernicus GLO-30** (hochauflösendes DEM), **Open-Meteo API**, synthetischer Fallback und **Offline-DEM-Import** für den Betrieb ohne Internetverbindung
+- Aircraft-Scatter-Weganalyse verknüpft mit den Geländedaten
+
+Die Karte funktioniert in gepackten Umgebungen (AppImage, Flatpak) ohne Zugriff auf externe CDNs: Die Kartenkacheln werden über einen lokalen Tile-Proxy abgerufen, die Leaflet.js-Bibliothek ist in der Anwendung eingebettet.
+
+---
+
+## Optimierte Nachrichtenverarbeitung / 30.000-Nachrichten-Limit (ab v1.41)
+
+Die internen Chat- und Nachrichtentabellen sind auf **30.000 Einträge** begrenzt. Ältere Nachrichten werden automatisch verworfen, sobald das Limit erreicht wird. Damit bleiben Speicherverbrauch und Darstellungsperformance auch bei mehrtägigen Contest-Betrieb stabil.
+
+---
+
+## Bildschirmgerechte Fenstergröße (ab v1.41)
+
+Beim Programmstart berechnet KST4Contest eine bildschirmgerechte Startgröße für das Hauptfenster:
+
+- Die gespeicherte Fenstergröße aus der letzten Session wird verwendet – aber **niemals größer als der aktuelle Bildschirm**.
+- Wenn KST4Contest zuletzt auf einem größeren Monitor betrieben wurde, wird das Fenster automatisch auf die aktuelle Anzeige verkleinert.
+- Das UI-Layout ist **kompakter und reaktionsfähiger auf kleineren Bildschirmen**.
+
+Damit werden unbrauchbare, abgeschnittene Fenster beim Wechsel zwischen Geräten oder Monitoren verhindert.

github_docs/en-Changelog.md

@@ -8,6 +8,18 @@ Version history of KST4Contest / PraktiKST.
 
 For the latest changelog, please refer to GitHub. The previous changelog is below.
 
+## v1.41
+**Station Map, Performance, Responsive UI**
+
+**New:**
+- **Station Map**: Interactive OpenStreetMap-based map showing the geographic position of all active chat members. Includes station markers, antenna beam cone, connection line to the selected station, Maidenhead grid overlay, and a path profile chart with terrain elevation analysis (Fresnel zones, horizon detection). Terrain data from Copernicus GLO-30, Open-Meteo API, or offline DEM import. Aircraft scatter path analysis integrated. Works in AppImage and Flatpak without external CDN access (local tile proxy, bundled Leaflet.js).
+
+**Changed:**
+- **Message table limit raised to 30,000**: Chat and message tables are capped at 30,000 entries. Older messages are automatically discarded, keeping performance stable during multi-day contest operations.
+- **Screen-aware window sizing**: On startup, the main window is sized to fit the current screen. If KST4Contest was last used on a larger monitor, the window is automatically scaled down. The UI layout is more compact and responsive on smaller screens.
+
+---
+
 ## v1.40 (2026-02-16)
 **Major Feature Release: Score System, AP Timeline, Win-Test, PSTRotator**
 

github_docs/en-Features.md

@@ -233,3 +233,39 @@ File-based log evaluation using regex. Details: [Log Synchronisation](Log-Sync#m
 ## Cluster & QSO of Others
 
 A separate window showing the QSO flow between other stations. Particularly interesting during quieter night-time hours of a contest. This window can be minimised when not needed. Future plan: filtering to stations in your selected QTF.
+
+---
+
+## Station Map (from v1.41)
+
+An interactive OpenStreetMap-based map showing the geographic position of all active chat members.
+
+**Features:**
+
+- Station markers with callsign labels, coloured by activity and sked state
+- Antenna **beam cone** visualisation for the own station
+- **Connection line** to the currently selected station
+- **Maidenhead grid** overlay (QRA locator grid)
+- **Path profile chart**: Terrain elevation cross-section between own station and the selected station, including Fresnel zone analysis and obstruction/horizon detection
+- Multiple terrain data sources: **Copernicus GLO-30** (high-resolution DEM), **Open-Meteo API**, synthetic fallback, and **offline DEM import** for air-gapped use
+- Aircraft scatter path analysis integrated with the terrain data
+
+The map works in packaged environments (AppImage, Flatpak) without internet access to external CDNs: map tiles are fetched via a local tile proxy, and the Leaflet.js library is bundled inside the application.
+
+---
+
+## Optimised Message Handling / 30,000 Message Limit (from v1.41)
+
+The internal chat and message tables are capped at **30,000 entries**. Older messages are automatically discarded when the limit is reached. This keeps memory usage and rendering performance stable during multi-day contest operations.
+
+---
+
+## Screen-Aware Window Sizing (from v1.41)
+
+On startup, KST4Contest calculates a screen-aware size for the main window:
+
+- The stored window size from the previous session is used – but **never larger than the current screen**.
+- If KST4Contest was last used on a larger monitor, the window is automatically scaled down to fit the current display without clipping.
+- The UI layout is more **compact and responsive on smaller screens**, showing the same information in less space.
+
+This prevents unusable oversized windows when switching between machines or monitors.

src/main/java/kst4contest/controller/ChatController.java

@@ -1077,6 +1077,10 @@ public class ChatController implements ThreadStatusCallback, PstRotatorEventList
 
 	private DBController dbHandler;
 
+	private ReachabilityService reachabilityService;
+	private final WorkedGrossFieldCache workedGrossFieldCache = new WorkedGrossFieldCache();
+
+
 	private Socket socket;
 	private ServerSocket cluster_telnetServerSocket; // socket that accepts telnet client connects (cluster client)
 //	private ServerSocketChannel cluster_telnetServerSocketChannel;
@@ -1201,10 +1205,24 @@ public class ChatController implements ThreadStatusCallback, PstRotatorEventList
 	}
 
 
+	/**
+	 * Notifies the UI that station-list derived values have changed.
+	 *
+	 * <p>This method may be called from parser threads, UDP listener threads and
+	 * reachability worker threads. Therefore the listener is always invoked on the
+	 * JavaFX application thread.</p>
+	 *
+	 * @param reason short debug reason for the UI log
+	 */
 	public void fireUserListUpdate(String reason) {
-        if (statusListener != null) {
+		if (statusListener == null) {
-            // Da UI Updates im JavaFX Thread passieren müssen, hier oder im Listener Platform.runLater nutzen
+			return;
+		}
+
+		if (Platform.isFxApplicationThread()) {
 			statusListener.onUserListUpdated(reason);
+		} else {
+			Platform.runLater(() -> statusListener.onUserListUpdated(reason));
 		}
 	}
 
@@ -1624,6 +1642,8 @@ public class ChatController implements ThreadStatusCallback, PstRotatorEventList
 		});
 
 		dbHandler = new DBController();
+		reachabilityService = new ReachabilityService(this);
+		rebuildWorkedGrossFieldCacheFromDatabase();
 
 //		chatPreferences = new ChatPreferences();
 //		chatPreferences.readPreferencesFromXmlFile(); // set the praktikst Prefs by file or default if file is corrupted
@@ -2090,6 +2110,103 @@ public class ChatController implements ThreadStatusCallback, PstRotatorEventList
 
 	}
 
+
+	/**
+	 * Returns the background reachability service used by the station table.
+	 *
+	 * @return reachability service
+	 */
+	public ReachabilityService getReachabilityService() {
+		return reachabilityService;
+	}
+
+	/**
+	 * Returns the runtime gross-field cache used by the new-locator filter.
+	 *
+	 * @return worked gross-field cache
+	 */
+	public WorkedGrossFieldCache getWorkedGrossFieldCache() {
+		return workedGrossFieldCache;
+	}
+
+	/**
+	 * Rebuilds the gross-field cache from persistent SQLite data and enriches it with
+	 * legacy ChatMember worked/qra rows where possible.
+	 */
+	public void rebuildWorkedGrossFieldCacheFromDatabase() {
+		if (dbHandler == null) {
+			return;
+		}
+
+		try {
+			workedGrossFieldCache.rebuildFromDatabaseSnapshot(dbHandler.fetchWorkedGrossFieldsFromDB());
+			workedGrossFieldCache.addWorkedBandsFromStoredChatMembers(dbHandler.fetchChatMemberWkdDataFromDB().values());
+		} catch (Exception exception) {
+			System.out.println("[ChatController, warning]: could not rebuild worked gross-field cache: "
+					+ exception.getMessage());
+		}
+	}
+
+	/**
+	 * Persists and caches one worked gross field after a logger QSO packet.
+	 *
+	 * @param band worked band
+	 * @param locator6 six-character Maidenhead locator
+	 * @param workedCall worked station
+	 * @param source logger/source name
+	 */
+	public void registerWorkedGrossField(Band band, String locator6, ChatMember workedCall, String source) {
+		if (band == null || locator6 == null) {
+			return;
+		}
+
+		String normalizedLocator6 = WorkedGrossFieldCache.extractLocator6(locator6);
+		if (normalizedLocator6 == null) {
+			return;
+		}
+
+		String callSignRaw = workedCall == null ? null : workedCall.getCallSignRaw();
+
+		try {
+			dbHandler.upsertWorkedGrossField(band, normalizedLocator6, callSignRaw, source);
+		} catch (Exception exception) {
+			System.out.println("[ChatController, warning]: could not persist worked gross field: "
+					+ exception.getMessage());
+		}
+
+		workedGrossFieldCache.addWorked(band, normalizedLocator6);
+		fireUserListUpdate("Worked gross field updated");
+	}
+
+	/**
+	 * Returns true when the member's gross field is not worked on at least one enabled
+	 * station band. This is the predicate behind the "new locator" filter.
+	 *
+	 * @param member member to inspect
+	 * @return true if the station is still a new locator on any enabled band
+	 */
+	public boolean isNewLocatorOnAnyEnabledBand(ChatMember member) {
+		if (member == null || member.getQra() == null) {
+			return false;
+		}
+
+		EnumSet<Band> enabledBands = reachabilityService == null
+				? getMyEnabledBandsFromPrefs(chatPreferences)
+				: reachabilityService.getEnabledStationBands();
+
+		if (enabledBands.isEmpty()) {
+			return false;
+		}
+
+		for (Band band : enabledBands) {
+			if (!workedGrossFieldCache.isGrossFieldWorked(band, member.getQra())) {
+				return true;
+			}
+		}
+
+		return false;
+	}
+
 	public long getCurrentEpochTime() {
 
 		OffsetDateTime currentTimeInUtc = OffsetDateTime.now(ZoneOffset.UTC);
@@ -2368,6 +2485,8 @@ public class ChatController implements ThreadStatusCallback, PstRotatorEventList
 			return;
 		}
 
+		rebuildWorkedGrossFieldCacheFromDatabase();
+
 		HashMap<String, ChatMember> finalWorkedDataFromDatabase = workedDataFromDatabase;
 
 		Platform.runLater(() -> {

src/main/java/kst4contest/controller/DBController.java

@@ -14,6 +14,12 @@ import kst4contest.ApplicationConstants;
 import kst4contest.model.ChatMember;
 import kst4contest.utils.ApplicationFileUtils;
 
+import java.util.EnumMap;
+import java.util.HashSet;
+import java.util.Set;
+
+import kst4contest.model.Band;
+
 public class DBController {
 
 	/**
@@ -37,7 +43,7 @@ public class DBController {
 	 * marker. The marker is stored in SQLite PRAGMA user_version so the expensive
 	 * normalization rebuild is executed only once per database file.
 	 */
-	private static final int CURRENT_DATABASE_SCHEMA_VERSION = 13;
+	private static final int CURRENT_DATABASE_SCHEMA_VERSION = 14;
 
 	/**
 	 * Minimum interval between two expiration cleanup runs. This avoids repeated full
@@ -136,6 +142,7 @@ public class DBController {
 	 */
 	private synchronized void ensureChatMemberTableCompatibility() {
 		createChatMemberTableIfRequired();
+		createWorkedGrossFieldTableIfRequired();
 		versionUpdateOfDBCheckAndChangeV11ToV12();
 		versionUpdateOfDBCheckAndChangeV12ToV13();
 
@@ -240,6 +247,30 @@ public class DBController {
 		}
 	}
 
+	/**
+	 * Creates the persistent gross-field table used by the new-locator filter.
+	 * The primary key is band + gross field because the filter only needs to know
+	 * whether a large locator square has already been worked on a band.
+	 */
+	private synchronized void createWorkedGrossFieldTableIfRequired() {
+
+		String createTableSql =
+				"CREATE TABLE IF NOT EXISTS WorkedGrossField ("
+						+ "band TEXT NOT NULL, "
+						+ "grossField TEXT NOT NULL, "
+						+ "locator TEXT, "
+						+ "callsign TEXT, "
+						+ "source TEXT, "
+						+ "lastWorkedEpochMs INTEGER NOT NULL, "
+						+ "PRIMARY KEY (band, grossField)"
+						+ ");";
+
+		try (Statement statement = connection.createStatement()) {
+			statement.executeUpdate(createTableSql);
+		} catch (SQLException e) {
+			throw new RuntimeException("[DBH, ERROR:] Could not create WorkedGrossField table", e);
+		}
+	}
 	/**
 	 * Updates old v1.1 databases to the v1.2 schema by adding the not-QRV fields if
 	 * they are missing.
@@ -477,6 +508,14 @@ public class DBController {
 		} catch (SQLException e) {
 			throw new RuntimeException("[DBH, ERROR:] Could not reset expired worked data", e);
 		}
+
+		try (PreparedStatement deleteGrossFieldsStatement = connection.prepareStatement(
+				"DELETE FROM WorkedGrossField WHERE lastWorkedEpochMs > 0 AND lastWorkedEpochMs < ?;")) {
+			deleteGrossFieldsStatement.setLong(1, expirationThresholdEpochMs);
+			deleteGrossFieldsStatement.executeUpdate();
+		} catch (SQLException e) {
+            throw new RuntimeException(e);
+        }
     }
 
 	/**
@@ -612,8 +651,14 @@ public class DBController {
 						+ "lastFlagsChangeEpochMs = 0;";
 
 		try (Statement statement = connection.createStatement()) {
-			return statement.executeUpdate(resetAllWorkedDataSql);
+//			return statement.executeUpdate(resetAllWorkedDataSql);
+			int affectedRows = statement.executeUpdate(resetAllWorkedDataSql);
+			statement.executeUpdate("DELETE FROM WorkedGrossField;");
+			return affectedRows;
+
+
 		} catch (SQLException e) {
+
 			System.err.println("[DBH, ERROR:] Couldn't reset the worked data");
 			e.printStackTrace();
 			return -1;
@@ -641,12 +686,27 @@ public class DBController {
 			return false;
 		}
 
+//		String updateWorkedSql =
+//				"UPDATE ChatMember SET worked = 1, " + workedBandColumnName + " = 1, lastFlagsChangeEpochMs = ? WHERE callsign = ?;";
+
 		String updateWorkedSql =
-				"UPDATE ChatMember SET worked = 1, " + workedBandColumnName + " = 1, lastFlagsChangeEpochMs = ? WHERE callsign = ?;";
+				"UPDATE ChatMember SET worked = 1, "
+						+ workedBandColumnName
+						+ " = 1, "
+						+ "qra = CASE WHEN ? IS NOT NULL AND TRIM(?) <> '' AND LOWER(TRIM(?)) <> 'unknown' THEN ? ELSE qra END, "
+						+ "lastFlagsChangeEpochMs = ? WHERE callsign = ?;";
 
 		try (PreparedStatement preparedStatement = connection.prepareStatement(updateWorkedSql)) {
-			preparedStatement.setLong(1, System.currentTimeMillis());
+//			preparedStatement.setLong(1, System.currentTimeMillis());
-			preparedStatement.setString(2, chatMemberToStore.getCallSignRaw());
+//			preparedStatement.setString(2, chatMemberToStore.getCallSignRaw());
+
+			String qra = chatMemberToStore.getQra();
+			preparedStatement.setString(1, qra);
+			preparedStatement.setString(2, qra);
+			preparedStatement.setString(3, qra);
+			preparedStatement.setString(4, qra);
+			preparedStatement.setLong(5, System.currentTimeMillis());
+			preparedStatement.setString(6, chatMemberToStore.getCallSignRaw());
 
 			int affectedRows = preparedStatement.executeUpdate();
 			return affectedRows > 0;
@@ -955,4 +1015,79 @@ public class DBController {
 		// dbc.storeChatMember(dummy);
 		// dbc.updateWkdInfoOnChatMember(dummy);
 	}
+
+	/**
+	 * Inserts or updates a worked gross field for the new-locator filter.
+	 *
+	 * @param band worked band
+	 * @param locator6 six-character Maidenhead locator
+	 * @param callsignRaw normalized raw callsign or null
+	 * @param source source identifier such as UCXLOG or WINTEST
+	 */
+	public synchronized void upsertWorkedGrossField(Band band, String locator6, String callsignRaw, String source) {
+
+		String grossField = WorkedGrossFieldCache.extractGrossField(locator6);
+		String normalizedLocator6 = WorkedGrossFieldCache.extractLocator6(locator6);
+
+		if (band == null || grossField == null) {
+			return;
+		}
+
+		String upsertSql =
+				"INSERT INTO WorkedGrossField (band, grossField, locator, callsign, source, lastWorkedEpochMs) "
+						+ "VALUES (?, ?, ?, ?, ?, ?) "
+						+ "ON CONFLICT(band, grossField) DO UPDATE SET "
+						+ "locator = COALESCE(excluded.locator, WorkedGrossField.locator), "
+						+ "callsign = COALESCE(excluded.callsign, WorkedGrossField.callsign), "
+						+ "source = excluded.source, "
+						+ "lastWorkedEpochMs = excluded.lastWorkedEpochMs;";
+
+		try (PreparedStatement preparedStatement = connection.prepareStatement(upsertSql)) {
+			preparedStatement.setString(1, band.name());
+			preparedStatement.setString(2, grossField);
+			preparedStatement.setString(3, normalizedLocator6);
+			preparedStatement.setString(4, callsignRaw);
+			preparedStatement.setString(5, source == null ? "UNKNOWN" : source);
+			preparedStatement.setLong(6, System.currentTimeMillis());
+			preparedStatement.executeUpdate();
+		} catch (SQLException e) {
+			throw new RuntimeException("[DBH, ERROR:] Could not upsert worked gross field", e);
+		}
+	}
+
+	/**
+	 * Loads all non-expired worked gross fields from the database.
+	 *
+	 * @return map of band to worked gross fields
+	 */
+	public synchronized Map<Band, Set<String>> fetchWorkedGrossFieldsFromDB() {
+
+		resetExpiredWorkedDataIfRequired();
+
+		Map<Band, Set<String>> result = new EnumMap<>(Band.class);
+
+		try (Statement statement = connection.createStatement();
+		     ResultSet resultSet = statement.executeQuery("SELECT band, grossField FROM WorkedGrossField ORDER BY band, grossField;")) {
+
+			while (resultSet.next()) {
+				Band band;
+				try {
+					band = Band.valueOf(resultSet.getString("band"));
+				} catch (Exception ignored) {
+					continue;
+				}
+
+				String grossField = WorkedGrossFieldCache.extractGrossField(resultSet.getString("grossField"));
+				if (grossField == null) {
+					continue;
+				}
+
+				result.computeIfAbsent(band, ignored -> new HashSet<>()).add(grossField);
+			}
+		} catch (SQLException e) {
+			throw new RuntimeException("[DBH, ERROR:] Could not fetch worked gross fields", e);
+		}
+
+		return result;
+	}
 }

src/main/java/kst4contest/controller/MessageBusManagementThread.java

@@ -327,6 +327,8 @@ public class MessageBusManagementThread extends Thread {
 				// 1. Store in the new Map (for future context/history)
 
 				sender.addKnownFrequency(finalDetectedBand, finalDetectedFrequency);
+				// No automatic full terrain analysis here.
+				// The frequency is stored for later map/manual reachability requests.
 
 				//propagate known frequency to all instances of the same callsign (callRaw may exist multiple times)
 				try {
@@ -335,6 +337,8 @@ public class MessageBusManagementThread extends Thread {
 						ChatMember cm = client.getLst_chatMemberList().get(idx);
 						if (cm != null && cm != sender) {
 							cm.addKnownFrequency(finalDetectedBand, finalDetectedFrequency);
+							// No automatic full terrain analysis here.
+							// Avoids exhausting the online terrain API when many stations mention QRGs.
 						}
 					}
 				} catch (Exception e) {
@@ -587,6 +591,8 @@ public class MessageBusManagementThread extends Thread {
 
 				if (!client.getChatPreferences().getStn_loginCallSign().equals(newMember.getCallSign())) {
 					this.client.getLst_chatMemberList().add(newMember); //the own call will not be in the list
+//					this.client.getReachabilityService().ensureAutoTropoMarginCalculated(newMember);
+					// Reachability is calculated on demand only: map click, selected station, or manual request.
 				}
 
 
@@ -632,6 +638,7 @@ public class MessageBusManagementThread extends Thread {
 					newMember = this.client.getDbHandler().fetchChatMemberWkdDataForOnlyOneCallsignFromDB(newMember);
 
 					this.client.getLst_chatMemberList().add(newMember);
+//					this.client.getReachabilityService().ensureAutoTropoMarginCalculated(newMember);
 
 					this.client.getDbHandler().storeChatMember(newMember);
 				}
@@ -1754,190 +1761,6 @@ public class MessageBusManagementThread extends Thread {
 					break;// TODO Change at may24, avoid uncloadability. Check if this could lead to further errors on instable link!
 	//				client.getMessageRXBus().clear();
 				}
-			{
-//				System.out.println("MessagebusmgtThread: Readthread is interrupted! Queue will be resetted");
-//				this.interrupt();
-//				client.getMessageRXBus().clear();
-			} 
-
-//			if (client.getMessageRXBus().peek() == null) {
-//
-//				Timer doNothingTimer = new Timer();
-//				doNothingTimer.schedule(new TimerTask() {
-//
-//					@Override
-//					public void run() {
-//
-//						//do nothing
-//
-//					}
-//				}, 100);// TODO: Temporary
-//			}
-//
-//
-//			if (client.getMessageRXBus().peek() == null && client.getMessageTXBus().peek() == null) {
-//
-//				if (this.client.isDisconnectionPerformedByUser()) {
-//					break;//TODO: what if it´s not the finally closage but a band channel change?
-//				}
-//				// do nothing
-////				try {
-////					this.sleep(20);
-////				} catch (InterruptedException e) {
-////					// TODO Auto-generated catch block
-////					e.printStackTrace();
-////				} catch (Exception e2) {
-////					// TODO Auto-generated catch block
-////					e2.printStackTrace();
-////				}
-//			}
-//			else
-			{
-
-//				messageLine = messageTextRaw.getMessageText();
-//
-//				/***********************************************
-//				 * CASE RX
-//				 ***********************************************/
-//
-////				if (client.getMessageRXBus().peek() != null) {
-//
-////					try {
-////						messageTextRaw = client.getMessageRXBus().take();
-////
-//////						System.out.println("MSBGBUS: rxed: " + messageTextRaw);
-////					} catch (InterruptedException e) {
-////						// TODO Auto-generated catch block
-////						e.printStackTrace();
-////					}
-//
-//					if (messageTextRaw.getMessageText() == null) {
-//						System.out.println("[MSGBUSMGT:] ERROR! got NULL message! BYE!");
-////					this.interrupt();
-////					break;
-//					}
-//
-//					messageLine = messageTextRaw.getMessageText();
-//
-////					try {
-////						bufwrtrRawMSGOut.write(messageLine + "\n");
-////						bufwrtrRawMSGOut.flush();
-////
-////					} catch (IOException e) {
-////						// TODO Auto-generated catch block
-////						e.printStackTrace();
-////					}
-//
-//					System.out.println(messageTextRaw.getMessageText() + " <- RXed"); // Stdout at
-//					// Console#######################################################TODO:Wichtig
-//
-//					try {
-//						processRXMessage23001(messageTextRaw);
-//					} catch (IOException e) {
-//						// TODO Auto-generated catch block
-//						e.printStackTrace();
-//					} catch (SQLException e) {
-//						// TODO Auto-generated catch block
-//						e.printStackTrace();
-//					}
-
-//				} //end peek != null
-
-				/**************************************************************
-				 * End of case RX
-				 **************************************************************/
-
-				/**************************************************************
-				 * Start of case TX
-				 **************************************************************/
-
-//				if (client.getMessageTXBus().peek() != null) {
-//					/***********************************************
-//					 * CASE TX
-//					 ***********************************************/
-//
-//					if (this.isServerready()) {
-//						// then send the line
-//
-//						try {
-//							messageTextRaw = client.getMessageTXBus().take();
-////						this.setServerready(false); // after tx always wait for an answer prompt //23000
-//							this.setServerready(true);
-//
-//						} catch (InterruptedException e) {
-//							// TODO Auto-generated catch block
-//							e.printStackTrace();
-//						}
-//
-//						messageLine = messageTextRaw.getMessageText();
-//
-//						if (messageTextRaw.isMessageDirectedToServer()) {
-//							/**
-//							 * We have to check if we only commands the server (keepalive) or want do talk
-//							 * to the community
-//							 */
-//
-//							try {
-//								client.getWriteThread().tx(messageTextRaw);
-//								System.out.println("BUS: tx: " + messageTextRaw.getMessageText());
-//
-//							} catch (InterruptedException e) {
-//								// TODO Auto-generated catch block
-//								e.printStackTrace();
-//							}
-//
-//							//////////////////////// bgfx ab here//////////////////////////////
-////						try {
-////							bufwrtrRawMSGOut.write(messageLine + "\r");
-//////							bw.write(messageLine + "\n");//kst4contest.test 4 23001
-////							bufwrtrRawMSGOut.flush();
-////
-////						} catch (IOException e) {
-////							// TODO Auto-generated catch block
-////							e.printStackTrace();
-////						}
-//							///////////////////////////////////////////////////////////////////
-//						} else {
-//
-//							ChatMessage ownMSG = new ChatMessage();
-//
-////						ownMSG.setMessageText(
-////								"MSG|" + this.client.getCategory().getCategoryNumber() + "|0|" + messageLine + "|0|");
-//
-//							ownMSG.setMessageText(
-//									"MSG|" + this.client.getChatPreferences().getLoginChatCategory().getCategoryNumber()
-//											+ "|0|" + messageLine + "|0|");
-//
-//							try {
-//								client.getWriteThread().tx(ownMSG);
-//								System.out.println("BUS: tx: " + ownMSG.getMessageText());
-//
-//							} catch (InterruptedException e) {
-//								// TODO Auto-generated catch block
-//								e.printStackTrace();
-//							}
-//						}
-//
-//						if (messageTextRaw.equals("/QUIT")) {
-//							try {
-//								this.client.getReadThread().terminateConnection();
-//								this.client.getReadThread().interrupt();
-//								this.client.getWriteThread().terminateConnection();
-//								this.client.getWriteThread().interrupt();
-//								this.interrupt();
-//
-//							} catch (IOException e) {
-//								// TODO Auto-generated catch block
-//								e.printStackTrace();
-//							}
-//						}
-//
-//					} else {
-////					System.out.println("msgbus no elements yet");
-//					}
-//				} //end tx.peek != null
-			}
-
 			
 		} // while true end
 		System.out.println("Msgbusmgt: interrupt");

src/main/java/kst4contest/controller/ReachabilityService.java

@@ -0,0 +1,657 @@
+package kst4contest.controller;
+import kst4contest.view.map.MapCallsignRawSnapshot;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.function.Consumer;
+
+import javafx.application.Platform;
+import kst4contest.locatorUtils.Location;
+import kst4contest.model.Band;
+import kst4contest.model.ChatCategory;
+import kst4contest.model.ChatMember;
+import kst4contest.model.ChatPreferences;
+import kst4contest.view.map.GeometryOnlyPathAnalysisService;
+
+import kst4contest.view.map.OpenMeteoTerrainProfileProvider;
+import kst4contest.view.map.PathAnalysisRequest;
+import kst4contest.view.map.PathAnalysisResult;
+import kst4contest.view.map.PathAnalysisService;
+import kst4contest.view.map.PathGeometryUtils;
+import java.util.Comparator;
+import java.util.EnumSet;
+import java.util.Objects;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ThreadFactory;
+import java.util.function.Consumer;
+
+/**
+ * Central service for tropo/path reachability calculations.
+ *
+ * <p>This service is now the single calculation path for:
+ * <ul>
+ *     <li>the station table Tropo column</li>
+ *     <li>the Tropo filter/sorter</li>
+ *     <li>the station map path-analysis detail panel</li>
+ * </ul>
+ *
+ * <p>The service always calculates a full {@link PathAnalysisResult}. When the
+ * result contains a usable link budget, the bidirectional SSB margin is copied
+ * into all matching {@link ChatMember} objects. The UI can then sort/filter by
+ * a simple number while the map still receives the full path result.</p>
+ */
+public final class ReachabilityService {
+
+    private static final long FAILED_ANALYSIS_RETRY_DELAY_MS = 5L * 60L * 1000L;
+
+    private final ChatController chatController;
+    private final PathAnalysisService pathAnalysisService;
+    private final ExecutorService executor;
+
+    /**
+     * Prevents duplicate jobs for the same path while a calculation is already
+     * queued or running.
+     */
+    private final Set<String> queuedCalculationKeys = ConcurrentHashMap.newKeySet();
+
+
+
+    /**
+     * Stores completed usable path-analysis results. Failed/no-budget results are
+     * not permanently cached so transient terrain/network problems can be retried.
+     */
+    private final Map<String, PathAnalysisResult> pathAnalysisResultCache = new ConcurrentHashMap<>();
+
+    /**
+     * Temporary callback list for map requests waiting for an already running
+     * background calculation.
+     */
+    private final Map<String, List<Consumer<PathAnalysisResult>>> pendingMapCallbacksByKey = new ConcurrentHashMap<>();
+
+    /**
+     * Prevents immediate retry loops for failed/no-budget analyses, especially
+     * when a TableView cell repeatedly asks for the same value.
+     */
+    private final Map<String, Long> failedCalculationRetryAfterEpochMs = new ConcurrentHashMap<>();
+
+    public ReachabilityService(ChatController chatController) {
+        this.chatController = Objects.requireNonNull(chatController, "chatController");
+        this.pathAnalysisService = new GeometryOnlyPathAnalysisService(new OpenMeteoTerrainProfileProvider());
+        this.executor = Executors.newSingleThreadExecutor(new ReachabilityThreadFactory());
+    }
+
+    /**
+     * Ensures that the automatically selected reachability band is calculated.
+     *
+     * @param member chatmember to evaluate
+     */
+    public void ensureAutoTropoMarginCalculated(ChatMember member) {
+        ensureTropoMarginCalculated(member, resolveAutoBand(member));
+    }
+
+    /**
+     * Ensures that a station/band SSB-margin value exists if it is already cached.
+     *
+     * <p>This method deliberately does not start online terrain analysis anymore.
+     * It is safe to call from table cells and filters because it will not consume
+     * API quota. Full calculations are now started only by explicit map/manual
+     * requests.</p>
+     *
+     * @param member chatmember to evaluate
+     * @param band band to evaluate
+     */
+    public void ensureTropoMarginCalculated(ChatMember member, Band band) {
+        if (member == null || band == null) {
+            return;
+        }
+
+        if (member.hasFiniteTropoSsbMarginDb(band)) {
+            return;
+        }
+
+        PathAnalysisRequest request = buildRequestForChatMember(member, band);
+        if (request == null) {
+            return;
+        }
+
+        PathAnalysisResult cachedResult = pathAnalysisResultCache.get(buildCalculationKey(request));
+        if (cachedResult != null) {
+            storePathAnalysisResultInChatMembers(member, band, cachedResult);
+        }
+    }
+
+
+
+    /**
+     * Requests a full path analysis for the station map.
+     *
+     * <p>This is the only normal automatic entry point for online/full terrain
+     * analysis. The map needs the full PathAnalysisResult, and the station table
+     * needs the SSB margin. Both are produced here through the same calculation.</p>
+     *
+     * @param member best matching ChatMember, may be null when only a map snapshot exists
+     * @param selectedSnapshot selected map snapshot
+     * @param fxCallback callback executed on the JavaFX thread
+     */
+    public void requestPathAnalysisForMap(ChatMember member,
+                                          MapCallsignRawSnapshot selectedSnapshot,
+                                          Consumer<PathAnalysisResult> fxCallback) {
+
+        String ownLocator6 = normalizeLocator6(chatController.getChatPreferences().getStn_loginLocatorMainCat());
+
+        if (selectedSnapshot == null) {
+            dispatchFxCallback(fxCallback, PathAnalysisResult.waitingForSelection(ownLocator6));
+            return;
+        }
+
+        String targetLocator6 = normalizeLocator6(selectedSnapshot.locator6());
+
+        if (ownLocator6.length() != 6) {
+            dispatchFxCallback(fxCallback,
+                    PathAnalysisResult.waitingForValidHomeLocator(ownLocator6, targetLocator6));
+            return;
+        }
+
+        if (!selectedSnapshot.hasUsablePosition()) {
+            dispatchFxCallback(fxCallback,
+                    PathAnalysisResult.waitingForValidTarget(ownLocator6, targetLocator6));
+            return;
+        }
+
+        double analysisFrequencyMHz = PathGeometryUtils.resolveAnalysisFrequencyMHz(
+                selectedSnapshot.lastKnownFrequenciesByBand()
+        );
+
+        if (!Double.isFinite(analysisFrequencyMHz) || analysisFrequencyMHz <= 0.0) {
+            Band fallbackBand = member == null ? Band.B_144 : resolveAutoBand(member);
+            analysisFrequencyMHz = resolveAnalysisFrequencyForBand(member, fallbackBand);
+        }
+
+        Band analysisBand = Band.fromFrequency(analysisFrequencyMHz);
+        if (analysisBand == null) {
+            analysisBand = member == null ? Band.B_144 : resolveAutoBand(member);
+        }
+
+        PathAnalysisRequest request = buildRequest(
+                ownLocator6,
+                selectedSnapshot.callSignRaw(),
+                targetLocator6,
+                selectedSnapshot.latitudeDeg(),
+                selectedSnapshot.longitudeDeg(),
+                analysisFrequencyMHz
+        );
+
+        requestPathAnalysisAndStore(member, analysisBand, request, fxCallback);
+    }
+
+
+
+    /**
+     * Starts a full on-demand reachability calculation for one station row.
+     *
+     * <p>Use this for explicit operator actions only. It may call the online terrain
+     * API and therefore must not be used from TableView cell factories or automatic
+     * chat-join processing.</p>
+     *
+     * @param member station to calculate
+     * @param band selected reachability band
+     */
+    public void calculateSelectedStationOnDemand(ChatMember member, Band band) {
+        if (member == null || band == null) {
+            return;
+        }
+
+        PathAnalysisRequest request = buildRequestForChatMember(member, band);
+        if (request == null) {
+            member.setTropoSsbMarginDb(band, Double.NaN);
+            chatController.fireUserListUpdate("Reachability unavailable");
+            return;
+        }
+
+        requestPathAnalysisAndStore(member, band, request, null);
+    }
+
+    /**
+     * Resolves the auto reachability band.
+     *
+     * <ol>
+     *     <li>Use the lowest band detected in this session.</li>
+     *     <li>If no session band exists and the station is in the microwave category, use 1296 MHz.</li>
+     *     <li>Otherwise use 144 MHz.</li>
+     * </ol>
+     *
+     * @param member member to inspect
+     * @return resolved band
+     */
+    public Band resolveAutoBand(ChatMember member) {
+        if (member != null && member.getKnownActiveBands() != null && !member.getKnownActiveBands().isEmpty()) {
+            return member.getKnownActiveBands().keySet().stream()
+                    .filter(Objects::nonNull)
+                    .min(Comparator.comparingDouble(Band::getDefaultAnalysisFrequencyMHz))
+                    .orElse(Band.B_144);
+        }
+
+        if (member != null
+                && member.getChatCategory() != null
+                && member.getChatCategory().getCategoryNumber() == ChatCategory.MICROWAVE) {
+            return Band.B_1296;
+        }
+
+        return Band.B_144;
+    }
+
+    /**
+     * Returns the active own bands configured in the station preferences. High bands
+     * above 10 GHz are intentionally ignored for the first version.
+     *
+     * @return set of enabled bands
+     */
+    public EnumSet<Band> getEnabledStationBands() {
+        ChatPreferences preferences = chatController.getChatPreferences();
+        EnumSet<Band> enabledBands = EnumSet.noneOf(Band.class);
+
+        if (preferences == null) {
+            return enabledBands;
+        }
+
+        if (preferences.isStn_bandActive144()) enabledBands.add(Band.B_144);
+        if (preferences.isStn_bandActive432()) enabledBands.add(Band.B_432);
+        if (preferences.isStn_bandActive1240()) enabledBands.add(Band.B_1296);
+        if (preferences.isStn_bandActive2300()) enabledBands.add(Band.B_2320);
+        if (preferences.isStn_bandActive3400()) enabledBands.add(Band.B_3400);
+        if (preferences.isStn_bandActive5600()) enabledBands.add(Band.B_5760);
+        if (preferences.isStn_bandActive10G()) enabledBands.add(Band.B_10G);
+
+        return enabledBands;
+    }
+
+    /**
+     * Stops the background executor.
+     */
+    public void shutdown() {
+        executor.shutdownNow();
+    }
+
+    /**
+     * Starts or reuses one shared path-analysis calculation.
+     *
+     * @param member matching ChatMember, may be null for map-only snapshots
+     * @param band band under which the value is stored in ChatMember
+     * @param request full path-analysis request
+     * @param fxCallback optional map callback
+     */
+    private void requestPathAnalysisAndStore(ChatMember member,
+                                             Band band,
+                                             PathAnalysisRequest request,
+                                             Consumer<PathAnalysisResult> fxCallback) {
+
+        if (request == null || band == null) {
+            return;
+        }
+
+        String calculationKey = buildCalculationKey(request);
+
+        PathAnalysisResult cachedResult = pathAnalysisResultCache.get(calculationKey);
+        if (cachedResult != null) {
+            storePathAnalysisResultInChatMembers(member, band, cachedResult);
+            dispatchFxCallback(fxCallback, cachedResult);
+            return;
+        }
+
+        Long retryAfterEpochMs = failedCalculationRetryAfterEpochMs.get(calculationKey);
+        if (retryAfterEpochMs != null && System.currentTimeMillis() < retryAfterEpochMs) {
+            dispatchFxCallback(fxCallback, createNoProfileResult(
+                    request,
+                    "Previous path analysis failed or the terrain API limit was reached. Retry is delayed briefly."
+            ));
+            return;
+        }
+
+        addPendingCallback(calculationKey, fxCallback);
+
+        if (!queuedCalculationKeys.add(calculationKey)) {
+            return;
+        }
+
+        executor.submit(() -> {
+            PathAnalysisResult result;
+
+            try {
+                result = pathAnalysisService.analyze(request);
+                if (result == null) {
+                    result = createNoProfileResult(request, "Path analysis returned no result.");
+                }
+            } catch (Exception exception) {
+                result = createNoProfileResult(
+                        request,
+                        "Path analysis failed: " + exception.getMessage()
+                );
+            }
+
+            boolean usableBudget = hasUsableLinkBudget(result);
+
+            if (usableBudget) {
+                pathAnalysisResultCache.put(calculationKey, result);
+                failedCalculationRetryAfterEpochMs.remove(calculationKey);
+            } else {
+                failedCalculationRetryAfterEpochMs.put(
+                        calculationKey,
+                        System.currentTimeMillis() + FAILED_ANALYSIS_RETRY_DELAY_MS
+                );
+            }
+
+            queuedCalculationKeys.remove(calculationKey);
+
+            PathAnalysisResult finalResult = result;
+            Runnable updateTask = () -> {
+                storePathAnalysisResultInChatMembers(member, band, finalResult);
+                dispatchAndClearPendingCallbacks(calculationKey, finalResult);
+                chatController.fireUserListUpdate("Reachability calculated");
+            };
+
+            if (Platform.isFxApplicationThread()) {
+                updateTask.run();
+            } else {
+                Platform.runLater(updateTask);
+            }
+        });
+    }
+
+    /**
+     * Builds a path-analysis request from a ChatMember row.
+     *
+     * @param member station row
+     * @param band selected reachability band
+     * @return request or null if locators are not usable
+     */
+    private PathAnalysisRequest buildRequestForChatMember(ChatMember member, Band band) {
+        String ownLocator6 = normalizeLocator6(chatController.getChatPreferences().getStn_loginLocatorMainCat());
+        String targetLocator6 = normalizeLocator6(member.getQra());
+
+        if (ownLocator6.length() != 6 || targetLocator6.length() != 6) {
+            return null;
+        }
+
+        Location targetLocation = new Location(targetLocator6);
+        double analysisFrequencyMHz = resolveAnalysisFrequencyForBand(member, band);
+
+        return buildRequest(
+                ownLocator6,
+                member.getCallSignRaw(),
+                targetLocator6,
+                targetLocation.getLatitude().toDegrees(),
+                targetLocation.getLongitude().toDegrees(),
+                analysisFrequencyMHz
+        );
+    }
+
+    /**
+     * Builds the shared PathAnalysisRequest used by map and table/manual requests.
+     */
+    private PathAnalysisRequest buildRequest(String ownLocator6,
+                                             String targetCallsignRaw,
+                                             String targetLocator6,
+                                             double targetLatitudeDeg,
+                                             double targetLongitudeDeg,
+                                             double analysisFrequencyMHz) {
+
+        Location homeLocation = new Location(ownLocator6);
+
+        return new PathAnalysisRequest(
+                ownLocator6,
+                homeLocation.getLatitude().toDegrees(),
+                homeLocation.getLongitude().toDegrees(),
+                targetCallsignRaw,
+                targetLocator6,
+                targetLatitudeDeg,
+                targetLongitudeDeg,
+                analysisFrequencyMHz,
+                chatController.getChatPreferences().getStn_pathAnalysisOwnAntennaHeightMeters(),
+                chatController.getChatPreferences().getStn_pathAnalysisDefaultTargetAntennaHeightMeters(),
+                PathGeometryUtils.DEFAULT_EFFECTIVE_EARTH_RADIUS_FACTOR,
+                chatController.getChatPreferences().buildPathLinkBudgetSettings()
+        );
+    }
+
+    /**
+     * Stores the SSB margin from a completed analysis in all matching ChatMember
+     * objects. Matching uses raw callsign and locator.
+     */
+    private void storePathAnalysisResultInChatMembers(ChatMember primaryMember,
+                                                      Band band,
+                                                      PathAnalysisResult result) {
+
+        if (band == null || result == null) {
+            return;
+        }
+
+        double marginDb = hasUsableLinkBudget(result)
+                ? result.linkBudgetSummary().bidirectionalSsbMarginDb()
+                : Double.NaN;
+
+        if (primaryMember != null) {
+            primaryMember.setTropoSsbMarginDb(band, marginDb);
+        }
+
+        String resultCallSignRaw = normalizeCallsignRaw(result.toCallsignRaw());
+        String resultLocator6 = normalizeLocator6(result.toLocator6());
+
+        for (ChatMember member : chatController.snapshotChatMembers()) {
+            if (member == null) {
+                continue;
+            }
+
+            String memberCallSignRaw = normalizeCallsignRaw(member.getCallSignRaw());
+            if (!resultCallSignRaw.isBlank() && !resultCallSignRaw.equals(memberCallSignRaw)) {
+                continue;
+            }
+
+            String memberLocator6 = normalizeLocator6(member.getQra());
+            if (!resultLocator6.isBlank() && !resultLocator6.equals(memberLocator6)) {
+                continue;
+            }
+
+            member.setTropoSsbMarginDb(band, marginDb);
+        }
+    }
+
+    /**
+     * Resolves the analysis frequency from a map snapshot first, because the map
+     * aggregates all visible ChatMember variants and often knows the best current
+     * frequency per band.
+     *
+     * @param member fallback member
+     * @param selectedSnapshot selected map snapshot
+     * @return analysis frequency in MHz
+     */
+    private double resolveAnalysisFrequencyForSnapshot(ChatMember member, MapCallsignRawSnapshot selectedSnapshot) {
+        if (selectedSnapshot != null) {
+            double snapshotFrequencyMHz =
+                    PathGeometryUtils.resolveAnalysisFrequencyMHz(selectedSnapshot.lastKnownFrequenciesByBand());
+
+            if (Double.isFinite(snapshotFrequencyMHz) && snapshotFrequencyMHz > 0.0) {
+                return snapshotFrequencyMHz;
+            }
+        }
+
+        Band fallbackBand = member == null ? Band.B_144 : resolveAutoBand(member);
+        return resolveAnalysisFrequencyForBand(member, fallbackBand);
+    }
+
+    /**
+     * Resolves the analysis frequency for one member/band pair.
+     *
+     * <p>Preference order:
+     * <ol>
+     *     <li>knownActiveBands frequency for the band</li>
+     *     <li>current displayed QRG if it belongs to the same band</li>
+     *     <li>band default frequency</li>
+     * </ol>
+     */
+    private double resolveAnalysisFrequencyForBand(ChatMember member, Band band) {
+        if (member != null && member.getKnownActiveBands() != null) {
+            ChatMember.ActiveFrequencyInfo activeFrequencyInfo = member.getKnownActiveBands().get(band);
+            if (activeFrequencyInfo != null
+                    && Double.isFinite(activeFrequencyInfo.frequency)
+                    && activeFrequencyInfo.frequency > 0.0) {
+                return activeFrequencyInfo.frequency;
+            }
+        }
+
+        if (member != null && member.getFrequency() != null && member.getFrequency().getValue() != null) {
+            double parsedFrequencyMHz = PathGeometryUtils.tryParseFrequencyMHz(member.getFrequency().getValue());
+            if (Double.isFinite(parsedFrequencyMHz) && parsedFrequencyMHz > 0.0) {
+                Band parsedBand = Band.fromFrequency(parsedFrequencyMHz);
+                if (parsedBand == null || parsedBand == band) {
+                    return parsedFrequencyMHz;
+                }
+            }
+        }
+
+        return band.getDefaultAnalysisFrequencyMHz();
+    }
+
+    /**
+     * Adds a map callback to the pending callback list for one calculation key.
+     *
+     * @param calculationKey path key
+     * @param fxCallback callback to add
+     */
+    private void addPendingCallback(String calculationKey, Consumer<PathAnalysisResult> fxCallback) {
+        if (fxCallback == null) {
+            return;
+        }
+
+        pendingMapCallbacksByKey
+                .computeIfAbsent(
+                        calculationKey,
+                        ignored -> Collections.synchronizedList(new ArrayList<>())
+                )
+                .add(fxCallback);
+    }
+
+    /**
+     * Dispatches and removes all callbacks waiting for one completed calculation.
+     *
+     * @param calculationKey path key
+     * @param result completed result
+     */
+    private void dispatchAndClearPendingCallbacks(String calculationKey, PathAnalysisResult result) {
+        List<Consumer<PathAnalysisResult>> callbacks = pendingMapCallbacksByKey.remove(calculationKey);
+        if (callbacks == null || callbacks.isEmpty()) {
+            return;
+        }
+
+        List<Consumer<PathAnalysisResult>> callbackSnapshot;
+        synchronized (callbacks) {
+            callbackSnapshot = new ArrayList<>(callbacks);
+        }
+
+        for (Consumer<PathAnalysisResult> callback : callbackSnapshot) {
+            dispatchFxCallback(callback, result);
+        }
+    }
+
+    /**
+     * Executes a map callback on the JavaFX application thread.
+     *
+     * @param fxCallback callback to execute
+     * @param result result to pass
+     */
+    private void dispatchFxCallback(Consumer<PathAnalysisResult> fxCallback, PathAnalysisResult result) {
+        if (fxCallback == null) {
+            return;
+        }
+
+        if (Platform.isFxApplicationThread()) {
+            fxCallback.accept(result);
+        } else {
+            Platform.runLater(() -> fxCallback.accept(result));
+        }
+    }
+
+    /**
+     * Checks whether the result contains a usable link-budget summary.
+     *
+     * @param result path-analysis result
+     * @return true if SSB margin can be read
+     */
+    private boolean hasUsableLinkBudget(PathAnalysisResult result) {
+        return result != null
+                && result.linkBudgetSummary() != null
+                && result.linkBudgetSummary().hasUsableBudget();
+    }
+
+    /**
+     * Creates a no-profile/no-budget result for failed service calculations.
+     *
+     * @param request original request
+     * @param statusText status shown in the map detail panel
+     * @return placeholder path result
+     */
+    private PathAnalysisResult createNoProfileResult(PathAnalysisRequest request, String statusText) {
+        return PathAnalysisResult.noProfile(
+                "Reachability",
+                request.fromLocator6(),
+                request.toLocator6(),
+                request.toCallsignRaw(),
+                Double.NaN,
+                Double.NaN,
+                request.homeAntennaHeightMeters(),
+                request.targetAntennaHeightMeters(),
+                request.frequencyMHz(),
+                statusText
+        );
+    }
+
+    /**
+     * Builds a stable calculation key.
+     *
+     * <p>The key includes station, locators, frequency, antenna heights and link
+     * budget settings. If any relevant input changes, a new calculation is allowed.</p>
+     */
+    private String buildCalculationKey(PathAnalysisRequest request) {
+        return normalizeLocator6(request.fromLocator6())
+                + "|"
+                + normalizeCallsignRaw(request.toCallsignRaw())
+                + "|"
+                + normalizeLocator6(request.toLocator6())
+                + "|"
+                + String.format(Locale.US, "%.5f", request.toLatitudeDeg())
+                + "|"
+                + String.format(Locale.US, "%.5f", request.toLongitudeDeg())
+                + "|"
+                + String.format(Locale.US, "%.3f", request.frequencyMHz())
+                + "|"
+                + String.format(Locale.US, "%.1f", request.homeAntennaHeightMeters())
+                + "|"
+                + String.format(Locale.US, "%.1f", request.targetAntennaHeightMeters())
+                + "|"
+                + request.linkBudgetSettings();
+    }
+
+    private String normalizeCallsignRaw(String callSignRaw) {
+        return callSignRaw == null ? "" : callSignRaw.trim().toUpperCase(Locale.ROOT);
+    }
+
+    private String normalizeLocator6(String locator) {
+        return locator == null ? "" : locator.trim().toUpperCase(Locale.ROOT);
+    }
+
+
+
+    private static final class ReachabilityThreadFactory implements ThreadFactory {
+        @Override
+        public Thread newThread(Runnable runnable) {
+            Thread thread = new Thread(runnable, "reachability-service");
+            thread.setDaemon(true);
+            return thread;
+        }
+    }
+}

src/main/java/kst4contest/controller/ReadUDPByWintestThread.java

@@ -2,6 +2,7 @@ package kst4contest.controller;
 
 import javafx.application.Platform;
 import kst4contest.ApplicationConstants;
+import kst4contest.model.Band;
 import kst4contest.model.ChatMember;
 import kst4contest.model.ThreadStateMessage;
 import kst4contest.view.GuiUtils;
@@ -286,6 +287,72 @@ public class ReadUDPByWintestThread extends Thread {
 //        socket.send(new DatagramPacket(bytes, bytes.length, broadcast, 9871));
 //    }
 
+
+    /**
+     * Resolves the project Band enum from Win-Test band IDs.
+     *
+     * <p>Only bands that exist in the current Band enum are returned. 50/70 MHz are
+     * still represented as worked flags in ChatMember, but they are not part of the
+     * current Reachability/New-Locator band enum.</p>
+     *
+     * @param bandId Win-Test band id from ADDQSO
+     * @return matching Band or null
+     */
+    private Band helper_resolveBandFromWinTestBandId(String bandId) {
+        if (bandId == null) {
+            return null;
+        }
+
+        switch (bandId.trim()) {
+            case "12": return Band.B_144;
+            case "14": return Band.B_432;
+            case "16": return Band.B_1296;
+            case "17": return Band.B_2320;
+            case "18": return Band.B_3400;
+            case "19": return Band.B_5760;
+            case "20": return Band.B_10G;
+            case "21": return Band.B_24G;
+            default: return null;
+        }
+    }
+
+    /**
+     * Extracts the locator from a Win-Test ADDQSO packet.
+     *
+     * <p>Current parser model based on the existing split-by-quotes code:
+     * <ul>
+     *     <li>{@code split("\"")[7]}  = callsign</li>
+     *     <li>{@code split("\"")[11]} = received exchange, e.g. 599001</li>
+     *     <li>{@code split("\"")[13]} = locator, e.g. JO51UM</li>
+     * </ul>
+     *
+     * <p>If the dedicated locator field is empty, the exchange is used as fallback.</p>
+     *
+     * @param msg raw ADDQSO message
+     * @return normalized six-character locator or null
+     */
+    private String helper_resolveLocatorFromWinTestAddQso(String msg) {
+        if (msg == null) {
+            return null;
+        }
+
+        String[] quotedParts = msg.split("\"");
+
+        if (quotedParts.length > 13) {
+            String locator = WorkedGrossFieldCache.extractLocator6(quotedParts[13]);
+            if (locator != null) {
+                return locator;
+            }
+        }
+
+        if (quotedParts.length > 11) {
+            return WorkedGrossFieldCache.extractLocator6(quotedParts[11]);
+        }
+
+        return null;
+    }
+
+
     /**
      * Catches add-qso messages of wintest if a new qso gets into the log<br/>
      *
@@ -310,16 +377,22 @@ public class ReadUDPByWintestThread extends Thread {
 //            receivedQsos.put(qsoNumber, msg);
 //            lastKnownQso = Math.max(lastKnownQso, qsoNumber);
             String callSignCatched = msg.split("\"") [7];
+            String locatorFromLogger = helper_resolveLocatorFromWinTestAddQso(msg);
 
             ChatMember workedCall = new ChatMember();
             workedCall.setCallSign(callSignCatched);
             workedCall.setWorked(true); //its worked at this place, for sure!
 
+            if (locatorFromLogger != null) {
+                workedCall.setQra(locatorFromLogger);
+            }
+
             ArrayList<Integer> markTheseChattersAsWorked = client.checkListForChatMemberIndexesByCallSign(workedCall);
 
             String bandId;
             bandId = msg.split("\"")[6].split(" ")[4].trim();
 
+            Band workedBand = helper_resolveBandFromWinTestBandId(bandId);
             switch (bandId) {
                 case "10" -> workedCall.setWorked50(true);
                 case "11" -> workedCall.setWorked70(true);
@@ -336,6 +409,10 @@ public class ReadUDPByWintestThread extends Thread {
                 default -> System.out.println("[WinTestUDPRcvr: warning] Unbekannte Band-ID: " + bandId);
             }
 
+            if (workedBand != null && locatorFromLogger != null) {
+                this.client.registerWorkedGrossField(workedBand, locatorFromLogger, workedCall, "WINTEST");
+            }
+
             if (!markTheseChattersAsWorked.isEmpty()) {
                 //Worked call is part of the current chatmember list
 
@@ -345,6 +422,13 @@ public class ReadUDPByWintestThread extends Thread {
 
                     modifyThat.setWorked(true); //worked its for sure
 
+                    if (locatorFromLogger != null
+                            && (modifyThat.getQra() == null
+                            || modifyThat.getQra().isBlank()
+                            || "unknown".equalsIgnoreCase(modifyThat.getQra()))) {
+                        modifyThat.setQra(locatorFromLogger);
+                    }
+
                     if (workedCall.isWorked50()) {
                         modifyThat.setWorked50(true);
                     } else if (workedCall.isWorked70()) {
@@ -398,7 +482,11 @@ public class ReadUDPByWintestThread extends Thread {
             if (!isInChat) {
 
                 workedCall.setName("unknown");
+
+                if (workedCall.getQra() == null || workedCall.getQra().isBlank()) {
                     workedCall.setQra("unknown");
+                }
+
                 workedCall.setLastActivity(new Utils4KST().time_generateActualTimeInDateFormat());
                 this.client.getDbHandler().storeChatMember(workedCall);
             }

src/main/java/kst4contest/controller/ReadUDPbyUCXMessageThread.java

@@ -22,6 +22,9 @@ import org.xml.sax.InputSource;
 import org.xml.sax.SAXException;
 
 import kst4contest.model.ChatMember;
+import kst4contest.model.Band;
+
+import javafx.application.Platform;
 
 /**
  * This thread is responsible for reading server's input and printing it to the
@@ -64,6 +67,110 @@ public class ReadUDPbyUCXMessageThread extends Thread {
 		}
 	}
 
+	/**
+	 * Strips binary logger framing bytes before the XML payload. Some UCXLog packets
+	 * contain transport bytes before the XML declaration.
+	 *
+	 * @param rawPacket raw UDP payload
+	 * @return cleaned XML string or trimmed original text
+	 */
+	private String helper_extractXmlPayload(String rawPacket) {
+		if (rawPacket == null) {
+			return "";
+		}
+
+		int xmlStart = rawPacket.indexOf("<?xml");
+		if (xmlStart < 0) {
+			xmlStart = rawPacket.indexOf("<contactinfo");
+		}
+		if (xmlStart < 0) {
+			xmlStart = rawPacket.indexOf("<RadioInfo");
+		}
+
+		return xmlStart >= 0
+				? rawPacket.substring(xmlStart).trim()
+				: rawPacket.trim();
+	}
+
+	/**
+	 * Reads an optional XML child node.
+	 *
+	 * @param element parent element
+	 * @param tagName tag to read
+	 * @return trimmed value or empty string
+	 */
+	private String helper_getOptionalElementText(Element element, String tagName) {
+		if (element == null || tagName == null) {
+			return "";
+		}
+
+		NodeList nodeList = element.getElementsByTagName(tagName);
+		if (nodeList == null || nodeList.getLength() == 0 || nodeList.item(0) == null) {
+			return "";
+		}
+
+		String textContent = nodeList.item(0).getTextContent();
+		return textContent == null ? "" : textContent.trim();
+	}
+
+	/**
+	 * Resolves the QSO locator from UCXLog contactinfo. gridsquare is preferred,
+	 * rcvnr is used as fallback for exchanges such as 001JO41HK.
+	 *
+	 * @param element contactinfo XML element
+	 * @return normalized six-character locator or null
+	 */
+	private String helper_resolveLocatorFromContactInfo(Element element) {
+		String gridSquare = WorkedGrossFieldCache.extractLocator6(helper_getOptionalElementText(element, "gridsquare"));
+		if (gridSquare != null) {
+			return gridSquare;
+		}
+
+		return WorkedGrossFieldCache.extractLocator6(helper_getOptionalElementText(element, "rcvnr"));
+	}
+
+	/**
+	 * Resolves the project Band enum from logger band values.
+	 *
+	 * @param band logger band text
+	 * @return matching Band or null
+	 */
+	private Band helper_resolveBandFromLoggerBand(String band) {
+		if (band == null) {
+			return null;
+		}
+
+		switch (band.trim()) {
+			case "144":
+			case "2m":
+				return Band.B_144;
+			case "432":
+			case "70cm":
+				return Band.B_432;
+			case "1240":
+			case "1296":
+			case "23cm":
+				return Band.B_1296;
+			case "2300":
+			case "2320":
+			case "13cm":
+				return Band.B_2320;
+			case "3400":
+			case "9cm":
+				return Band.B_3400;
+			case "5600":
+			case "5760":
+			case "6cm":
+				return Band.B_5760;
+			case "10G":
+			case "10368":
+			case "3cm":
+				return Band.B_10G;
+			default:
+				return null;
+		}
+	}
+
 	public void run() {
 
         System.out.println("ReadUDPByUCXLogThread: started Thread for UCXLog getUDP");
@@ -177,7 +284,7 @@ public class ReadUDPbyUCXMessageThread extends Thread {
 
 		File logUDPMessageToThisFile;
 
-		String udpMsg = udpPacketToProcess;
+		String udpMsg = helper_extractXmlPayload(udpPacketToProcess);
 
 		ChatMember modifyThat = null;
 
@@ -221,10 +328,9 @@ public class ReadUDPbyUCXMessageThread extends Thread {
 						Element element = (Element) node;
 
 						String call = element.getElementsByTagName("call").item(0).getTextContent();
-//						call = call.toLowerCase();
+						String band = helper_getOptionalElementText(element, "band");
-						String band = element.getElementsByTagName("band").item(0).getTextContent();
+						String gridSquare = helper_resolveLocatorFromContactInfo(element);
-
+						String points = helper_getOptionalElementText(element, "points");
-						String points = element.getElementsByTagName("points").item(0).getTextContent();
 
 						System.out.println("[Readudp, info ]: received Current Element :" + node.getNodeName()
 								+ "call: " + call + " / " + band + " ----> " + points + " POINTS");
@@ -235,89 +341,69 @@ public class ReadUDPbyUCXMessageThread extends Thread {
 						workedCall.setCallSign(call);
 						workedCall.setWorked(true);
 
+						if (gridSquare != null) {
+							workedCall.setQra(gridSquare);
+						}
+
+						Band workedBand = helper_resolveBandFromLoggerBand(band);
+
 						switch (band) {
-						case "144": {
+						case "144":
+						case "2m": //minos contest logger
+						{
 							workedCall.setWorked144(true);
 							break;
 						}
 
-						case "432": {
+						case "432":
+						case "70cm":
+							{
 								workedCall.setWorked432(true);
 								break;
 							}
 
-						case "1240": {
+						case "1240": //ucxlog style
+						case "1296": //used for n1mm / Dxlog
+						case "23cm": //minos contest logger
+						{
 							workedCall.setWorked1240(true);
 							break;
 						}
 
-						case "2300": {
+						case "2300":
+						case "13cm":
+							{
 							workedCall.setWorked2300(true);
 							break;
 						}
 
-						case "3400": {
+						case "3400":
+						case "9cm":
+						{
 							workedCall.setWorked3400(true);
 							break;
 						}
 
-						case "5600": {
+						case "5600":
+						case "6cm":
+						{
 							workedCall.setWorked5600(true);
 							break;
 						}
 
-						case "10G": {
+						case "10G":
+						case "3cm":
+						{
 							workedCall.setWorked10G(true);
                             break;
 						}
 
-						/**
-						 * cases hotfix for MINOS logger, which tells band like "2m", not "144"
-						 */
-						case "2m": {
-							workedCall.setWorked144(true);
-							break;
-						}
-
-						case "70cm": {
-							workedCall.setWorked432(true);
-							break;
-						}
-
-						case "23cm": {
-							workedCall.setWorked1240(true);
-							break;
-						}
-
-						case "13cm": {
-							workedCall.setWorked2300(true);
-							break;
-						}
-
-						case "9cm": {
-							workedCall.setWorked3400(true);
-							break;
-						}
-
-						case "6cm": {
-							workedCall.setWorked5600(true);
-							break;
-						}
-
-						case "3cm": {
-							workedCall.setWorked10G(true);
-
-						}
 
 							default:
 								System.out.println("[ReadUDPFromUCX, Error:] unexpected band value: \"" + band + "\"");
 								break;
 						}
 
-//						if (!client.getMap_ucxLogInfoWorkedCalls().containsKey("call")) {
-//							client.getMap_ucxLogInfoWorkedCalls().put(call, workedCall);
-
-//						} else 
 						{
 							/**
 							 * That means, the station is worked already but maybe at another band. So we
@@ -452,6 +538,10 @@ public class ReadUDPbyUCXMessageThread extends Thread {
 							 */
 						}
 
+						if (workedBand != null && gridSquare != null) {
+							this.client.registerWorkedGrossField(workedBand, gridSquare, workedCall, "UCXLOG");
+						}
+
 						boolean isInChat = this.client.getDbHandler().updateWkdInfoOnChatMember(workedCall);
 						// This will update the worked info on a worked chatmember. DBHandler will
 						// check, if an entry at the db had been modified. If not, then the worked
@@ -459,7 +549,11 @@ public class ReadUDPbyUCXMessageThread extends Thread {
 						if (!isInChat) {
 
 							workedCall.setName("unknown");
+
+							if (workedCall.getQra() == null || workedCall.getQra().isBlank()) {
 								workedCall.setQra("unknown");
+							}
+
 							workedCall.setLastActivity(new Utils4KST().time_generateActualTimeInDateFormat());
 							this.client.getDbHandler().storeChatMember(workedCall);
 						}
@@ -550,7 +644,12 @@ public class ReadUDPbyUCXMessageThread extends Thread {
 //						System.out.println("Radio Mode: " + mode);
 //						System.out.println("[ReadUDPFromUCX, Info:] Setted QRG pref to: \"" + qrg + "\"" );
 
-						this.client.getChatPreferences().getMYQRGFirstCat().set(formattedQRG);
+//						this.client.getChatPreferences().getMYQRGFirstCat().set(formattedQRG);
+
+						final String finalFormattedQRG = formattedQRG;
+						helper_runOnFxThread(() ->
+								this.client.getChatPreferences().getMYQRGFirstCat().set(finalFormattedQRG)
+						);
 
 //						System.out.println("[ReadUDPbyUCXTh: ] Radioinfo processed: " + formattedQRG);
 					}
@@ -604,6 +703,28 @@ public class ReadUDPbyUCXMessageThread extends Thread {
 		this.socket.close();
 
 		return true;
+
+	}
+
+	/**
+	 * Runs UI-bound changes on the JavaFX application thread.
+	 *
+	 * <p>UCXLog UDP packets are processed in a background thread. Some preference
+	 * properties are bound to JavaFX controls, so setting them directly from this
+	 * thread can crash JavaFX with "Not on FX application thread".</p>
+	 *
+	 * @param runnable UI-bound update
+	 */
+	private void helper_runOnFxThread(Runnable runnable) {
+		if (runnable == null) {
+			return;
+		}
+
+		if (Platform.isFxApplicationThread()) {
+			runnable.run();
+		} else {
+			Platform.runLater(runnable);
+		}
 	}
 
 }

src/main/java/kst4contest/controller/ScoreService.java

@@ -182,6 +182,7 @@ public final class ScoreService {
 
         // 4) Publish to UI in ONE batched runLater
         Platform.runLater(() -> {
+            applyScoreSnapshotToChatMembers(snap);
             topCandidatesFx.setAll(snap.getTopCandidates());
             updateSelectedScoreFromSnapshot(snap);
             uiPulse.set(uiPulse.get() + 1);
@@ -237,6 +238,31 @@ public final class ScoreService {
 
         return representative;
     }
+    /**
+     * Projects the immutable score snapshot back into ChatMember display fields so
+     * the normal station table can sort/filter by score without knowing the score
+     * calculation internals.
+     *
+     * @param snap latest score snapshot
+     */
+    private void applyScoreSnapshotToChatMembers(ScoreSnapshot snap) {
+        if (snap == null) {
+            return;
+        }
+
+        Map<String, Double> scoreByCallSignRaw = snap.getScoreByCallSignRaw();
+
+        for (ChatMember member : controller.snapshotChatMembers()) {
+            if (member == null || member.getCallSignRaw() == null) {
+                continue;
+            }
+
+            Double score = scoreByCallSignRaw.get(normalizeCallRaw(member.getCallSignRaw()));
+            member.setCurrentPriorityScore(score == null ? 0.0 : score);
+        }
+
+        controller.fireUserListUpdate("Priority scores projected to ChatMember");
+    }
 
     private void updateSelectedScoreFromSnapshot(ScoreSnapshot snap) {
         if (snap == null || selectedCallSignRaw == null) {

src/main/java/kst4contest/controller/WorkedGrossFieldCache.java

@@ -0,0 +1,175 @@
+package kst4contest.controller;
+
+import kst4contest.model.Band;
+import kst4contest.model.ChatMember;
+
+import java.util.Collection;
+import java.util.EnumMap;
+import java.util.HashSet;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Set;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * Runtime cache for worked Maidenhead gross fields per band.
+ *
+ * <p>The cache is used by the "new locator" station filter. It is kept in memory
+ * for fast UI predicates and rebuilt from SQLite on startup/refresh. New QSO log
+ * packets update both SQLite and this cache immediately.</p>
+ */
+public final class WorkedGrossFieldCache {
+
+    private static final Pattern MAIDENHEAD_6_PATTERN =
+            Pattern.compile("(?i)([A-R]{2}[0-9]{2}[A-X]{2})");
+
+    private final Map<Band, Set<String>> workedGrossFieldsByBand = new EnumMap<>(Band.class);
+
+    /**
+     * Replaces the full cache content with data read from the database.
+     *
+     * @param databaseSnapshot map of band to worked gross fields
+     */
+    public synchronized void rebuildFromDatabaseSnapshot(Map<Band, Set<String>> databaseSnapshot) {
+        workedGrossFieldsByBand.clear();
+
+        if (databaseSnapshot == null) {
+            return;
+        }
+
+        for (Map.Entry<Band, Set<String>> entry : databaseSnapshot.entrySet()) {
+            Band band = entry.getKey();
+            Set<String> grossFields = entry.getValue();
+
+            if (band == null || grossFields == null) {
+                continue;
+            }
+
+            Set<String> normalizedGrossFields = workedGrossFieldsByBand.computeIfAbsent(band, ignored -> new HashSet<>());
+            for (String grossField : grossFields) {
+                String normalizedGrossField = normalizeGrossField(grossField);
+                if (normalizedGrossField != null) {
+                    normalizedGrossFields.add(normalizedGrossField);
+                }
+            }
+        }
+    }
+
+    /**
+     * Adds one worked locator to the cache.
+     *
+     * @param band worked band
+     * @param locatorOrGrossField six-character locator or four-character gross field
+     */
+    public synchronized void addWorked(Band band, String locatorOrGrossField) {
+        String grossField = extractGrossField(locatorOrGrossField);
+        if (band == null || grossField == null) {
+            return;
+        }
+
+        workedGrossFieldsByBand
+                .computeIfAbsent(band, ignored -> new HashSet<>())
+                .add(grossField);
+    }
+
+    /**
+     * Adds all worked-band flags from stored ChatMember rows. This is only a fallback
+     * for legacy data before WorkedGrossField existed or when logger packets did not
+     * provide a locator.
+     *
+     * @param storedMembers stored ChatMember rows
+     */
+    public synchronized void addWorkedBandsFromStoredChatMembers(Collection<ChatMember> storedMembers) {
+        if (storedMembers == null) {
+            return;
+        }
+
+        for (ChatMember member : storedMembers) {
+            if (member == null) {
+                continue;
+            }
+
+            String locator = member.getQra();
+            if (member.isWorked144()) addWorked(Band.B_144, locator);
+            if (member.isWorked432()) addWorked(Band.B_432, locator);
+            if (member.isWorked1240()) addWorked(Band.B_1296, locator);
+            if (member.isWorked2300()) addWorked(Band.B_2320, locator);
+            if (member.isWorked3400()) addWorked(Band.B_3400, locator);
+            if (member.isWorked5600()) addWorked(Band.B_5760, locator);
+            if (member.isWorked10G()) addWorked(Band.B_10G, locator);
+        }
+    }
+
+    /**
+     * Checks whether a locator gross field is already worked on a band.
+     *
+     * @param band band to check
+     * @param locatorOrGrossField six-character locator or four-character gross field
+     * @return true if the gross field is already worked on that band
+     */
+    public synchronized boolean isGrossFieldWorked(Band band, String locatorOrGrossField) {
+        String grossField = extractGrossField(locatorOrGrossField);
+        if (band == null || grossField == null) {
+            return false;
+        }
+
+        return workedGrossFieldsByBand
+                .getOrDefault(band, Set.of())
+                .contains(grossField);
+    }
+
+    /**
+     * Tries to normalize a locator. Accepts a plain six-character locator or extracts
+     * one from exchange strings such as "001JO41HK".
+     *
+     * @param rawLocatorOrExchange raw locator/exchange text
+     * @return normalized six-character locator, or null if none was found
+     */
+    public static String extractLocator6(String rawLocatorOrExchange) {
+        if (rawLocatorOrExchange == null || rawLocatorOrExchange.isBlank()) {
+            return null;
+        }
+
+        Matcher matcher = MAIDENHEAD_6_PATTERN.matcher(rawLocatorOrExchange.trim());
+        if (!matcher.find()) {
+            return null;
+        }
+
+        return matcher.group(1).toUpperCase(Locale.ROOT);
+    }
+
+    /**
+     * Extracts and normalizes the four-character gross field.
+     *
+     * @param rawLocatorOrGrossField six-character locator, four-character gross field or exchange text
+     * @return normalized gross field, or null if no valid value is available
+     */
+    public static String extractGrossField(String rawLocatorOrGrossField) {
+        if (rawLocatorOrGrossField == null || rawLocatorOrGrossField.isBlank()) {
+            return null;
+        }
+
+        String trimmed = rawLocatorOrGrossField.trim().toUpperCase(Locale.ROOT);
+
+        if (trimmed.matches("[A-R]{2}[0-9]{2}")) {
+            return trimmed;
+        }
+
+        String locator6 = extractLocator6(trimmed);
+        if (locator6 == null || locator6.length() < 4) {
+            return null;
+        }
+
+        return locator6.substring(0, 4);
+    }
+
+    private static String normalizeGrossField(String grossField) {
+        if (grossField == null) {
+            return null;
+        }
+
+        String normalized = grossField.trim().toUpperCase(Locale.ROOT);
+        return normalized.matches("[A-R]{2}[0-9]{2}") ? normalized : null;
+    }
+}

src/main/java/kst4contest/model/Band.java

@@ -29,6 +29,35 @@ public enum Band {
         return prefix;
     }
 
+    /**
+     * Returns the lower edge used as practical analysis frequency when only the band
+     * is known. This keeps the batch reachability calculation deterministic.
+     *
+     * @return frequency in MHz
+     */
+    public double getDefaultAnalysisFrequencyMHz() {
+        return minFreq;
+    }
+
+    /**
+     * Returns a compact label for table display and filter controls.
+     *
+     * @return human readable band label
+     */
+    public String getDisplayLabel() {
+        switch (this) {
+            case B_144: return "144";
+            case B_432: return "432";
+            case B_1296: return "1296";
+            case B_2320: return "2320";
+            case B_3400: return "3400";
+            case B_5760: return "5760";
+            case B_10G: return "10G";
+            case B_24G: return "24G";
+            default: return prefix;
+        }
+    }
+
     /**
      * Checks if a specific frequency falls within this band's limits.
      */

src/main/java/kst4contest/model/ChatMember.java

@@ -10,10 +10,13 @@ import javafx.beans.property.SimpleBooleanProperty;
 import javafx.beans.property.BooleanProperty;
 import javafx.beans.property.SimpleStringProperty;
 import javafx.beans.property.StringProperty;
+import java.util.OptionalDouble;
 
 public class ChatMember {
 
 
+
+
 	long lastFlagsChangeEpochMs; // timestamp of the last worked/not-QRV flag change in the internal DB
 
 	//	private final BooleanProperty workedInfoChangeFireListEventTrigger = new SimpleBooleanProperty();
@@ -74,6 +77,10 @@ public class ChatMember {
 	// Stores the last known frequency per band (Context History)
 	private final Map<Band, ActiveFrequencyInfo> knownActiveBands = new ConcurrentHashMap<>();
 
+	// Stores the calculated bidirectional SSB tropo margin per band.
+	// Values are calculated by the reachability backend and used only for UI sorting/filtering.
+	private final Map<Band, Double> tropoSsbMarginDbByBand = new ConcurrentHashMap<>();
+
 
 	// --- INNER CLASS FOR QRG HISTORY ---
 	public class ActiveFrequencyInfo {
@@ -620,6 +627,108 @@ public class ChatMember {
 		return knownActiveBands;
 	}
 
+	/**
+	 * Stores the calculated bidirectional SSB tropo margin for one band.
+	 *
+	 * <p>The value is deliberately stored in ChatMember because the station table
+	 * can then sort and filter directly without triggering a new RF calculation.
+	 * The actual calculation stays outside ChatMember.</p>
+	 *
+	 * @param band band for which the margin was calculated
+	 * @param marginDb bidirectional SSB margin in dB; NaN marks an attempted but failed analysis
+	 */
+	public void setTropoSsbMarginDb(Band band, double marginDb) {
+		if (band == null) {
+			return;
+		}
+
+		this.tropoSsbMarginDbByBand.put(band, marginDb);
+	}
+
+	/**
+	 * Returns true if a tropo analysis result already exists for the given band.
+	 *
+	 * <p>A stored NaN also counts as an existing result because it means the analysis
+	 * was attempted and failed. This prevents endless retry loops when a terrain
+	 * provider is temporarily unavailable.</p>
+	 *
+	 * @param band band to check
+	 * @return true if a value or NaN marker is stored
+	 */
+	public boolean hasTropoSsbMarginDb(Band band) {
+		return band != null && this.tropoSsbMarginDbByBand.containsKey(band);
+	}
+
+
+
+	/**
+	 * Returns true only when a finite, usable tropo SSB margin is stored for the band.
+	 *
+	 * <p>This is intentionally different from {@link #hasTropoSsbMarginDb(Band)}:
+	 * a stored NaN means that an analysis was attempted but did not produce a usable
+	 * link budget. Such failed values should not permanently block later retries.</p>
+	 *
+	 * @param band band to check
+	 * @return true if a finite SSB margin exists
+	 */
+	public boolean hasFiniteTropoSsbMarginDb(Band band) {
+		if (band == null || !this.tropoSsbMarginDbByBand.containsKey(band)) {
+			return false;
+		}
+
+		Double storedValue = this.tropoSsbMarginDbByBand.get(band);
+		return storedValue != null && Double.isFinite(storedValue);
+	}
+
+	/**
+	 * Reads the calculated tropo SSB margin for one band.
+	 *
+	 * @param band band to read
+	 * @return OptionalDouble with the stored value, or empty if no calculation exists yet
+	 */
+	public OptionalDouble getTropoSsbMarginDb(Band band) {
+		if (band == null || !this.tropoSsbMarginDbByBand.containsKey(band)) {
+			return OptionalDouble.empty();
+		}
+
+		Double storedValue = this.tropoSsbMarginDbByBand.get(band);
+		if (storedValue == null) {
+			return OptionalDouble.empty();
+		}
+
+		return OptionalDouble.of(storedValue);
+	}
+
+
+	/**
+	 * Formats the calculated tropo margin for direct table display.
+	 *
+	 * <p>The method distinguishes three states:
+	 * <ul>
+	 *     <li>{@code ... @144}: analysis has not run yet</li>
+	 *     <li>{@code ? @144}: analysis ran, but no usable link budget was produced</li>
+	 *     <li>{@code +8.4 dB @144}: finite SSB margin exists</li>
+	 * </ul>
+	 *
+	 * @param band selected/auto-resolved reachability band
+	 * @return display text such as "+8.4 dB @144", "? @144" or "... @144"
+	 */
+	public String formatTropoSsbMarginForBand(Band band) {
+		String bandLabel = band == null ? "?" : band.getDisplayLabel();
+
+		if (band == null || !this.tropoSsbMarginDbByBand.containsKey(band)) {
+			return "... @" + bandLabel;
+		}
+
+		Double storedValue = this.tropoSsbMarginDbByBand.get(band);
+
+		if (storedValue == null || !Double.isFinite(storedValue)) {
+			return "? @" + bandLabel;
+		}
+
+		return String.format(Locale.US, "%+.1f dB @%s", storedValue, bandLabel);
+	}
+
 
 	/**
 	 * If a sked fails and the user tells this to the client, this counter will be increased to give the station a

src/main/java/kst4contest/view/GuiUtils.java

@@ -51,26 +51,21 @@ public class GuiUtils {
         }
 	}
 
-    private static void triggerUpdate(ChatController chatController) {
-        {
-            //trick to trigger gui changes on property changes of obects
-
-            Predicate<ChatMember> dummyPredicate = new Predicate<ChatMember>() {
-                @Override
-                public boolean test(ChatMember chatMember) {
-                    return true;
-                }
-            };
-
 	/**
-             * //TODO: following 2 lines are a quick fix to making disappear worked chatmembers of the list
+	 * Requests a safe UI refresh of the filtered ChatMember list.
-             * Thats uncomfortable due to this also causes selection changes,
+	 *
-             * Better way is to change all worked and qrv values to observables and then trigger the underlying
+	 * <p>Older versions used the trick of adding/removing a dummy predicate. That can
-             * list to fire an invalidationevent. Really Todo!
+	 * break JavaFX SortedList internals when the table is sorted and a FilteredList
+	 * refilter happens at the same time. The controller-level refresh path is safer
+	 * because Kst4ContestApplication now re-applies the existing predicates directly.</p>
+	 *
+	 * @param chatController central controller
 	 */
-            chatController.getLst_chatMemberListFilterPredicates().add(dummyPredicate);
+	private static void triggerUpdate(ChatController chatController) {
-            chatController.getLst_chatMemberListFilterPredicates().remove(dummyPredicate);
+		if (chatController == null) {
+			return;
+		}
 
-        }
+		chatController.fireUserListUpdate("Forced filtered ChatMember refresh");
 	}
 }

src/main/java/kst4contest/view/map/StationMapBridge.java

@@ -6,7 +6,6 @@ import javafx.collections.ListChangeListener;
 import javafx.scene.control.TableView;
 import javafx.util.Duration;
 import kst4contest.controller.ChatController;
-import kst4contest.locatorUtils.Location;
 import kst4contest.model.ChatMember;
 import kst4contest.model.ChatPreferences;
 
@@ -15,12 +14,13 @@ import java.util.Comparator;
 import java.util.List;
 import java.util.Locale;
 import java.util.Objects;
-import java.util.concurrent.ExecutorService;
+
-import java.util.concurrent.Executors;
-import java.util.concurrent.ThreadFactory;
 import java.util.concurrent.atomic.AtomicLong;
 import java.util.function.Consumer;
 
+import kst4contest.model.Band;
+import java.util.function.Predicate;
+
 /**
  * Synchronizes the application state with the station map window.
  *
@@ -32,7 +32,7 @@ import java.util.function.Consumer;
  */
 public final class StationMapBridge {
 
-    private final ExecutorService pathAnalysisExecutor = Executors.newSingleThreadExecutor(new PathAnalysisThreadFactory());
+
     private final AtomicLong pathAnalysisGeneration = new AtomicLong(0);
 
     private final ChatController chatController;
@@ -45,8 +45,7 @@ public final class StationMapBridge {
 
 
     private final MapCallsignRawSnapshotBuilder snapshotBuilder = new MapCallsignRawSnapshotBuilder();
-//    private final OfflineDemManager offlineDemManager = new OfflineDemManager();
+
-    private final PathAnalysisService pathAnalysisService;
 
     private String lastPathAnalysisRequestSignature = "";
 
@@ -64,9 +63,7 @@ public final class StationMapBridge {
 
         this.refreshCoalescer.setOnFinished(event -> refreshNow());
 
-        this.pathAnalysisService = new GeometryOnlyPathAnalysisService(
+
-                new OpenMeteoTerrainProfileProvider()
-        );
     }
 
     public void install() {
@@ -85,6 +82,10 @@ public final class StationMapBridge {
                 (obs, oldValue, newValue) -> scheduleRefresh()
         );
 
+        chatController.getLst_chatMemberListFilterPredicates().addListener(
+                (ListChangeListener<Predicate<ChatMember>>) change -> requestImmediateRefresh()
+        );
+
         requestImmediateRefresh();
     }
 
@@ -170,6 +171,17 @@ public final class StationMapBridge {
         requestPathAnalysisAsync(preferences.getStn_loginLocatorMainCat(), selectedSnapshot);
     }
 
+    /**
+     * Requests the selected station path analysis through the central reachability
+     * service.
+     *
+     * <p>The map no longer owns a separate PathAnalysisService. This ensures that
+     * the map detail panel, the Tropo table column and the station filters all use
+     * exactly the same path/link-budget calculation.</p>
+     *
+     * @param ownLocator6 own locator from preferences
+     * @param selectedSnapshot selected map marker snapshot
+     */
     private void requestPathAnalysisAsync(String ownLocator6, MapCallsignRawSnapshot selectedSnapshot) {
         String normalizedOwnLocator6 = normalizeLocator6(ownLocator6);
 
@@ -202,20 +214,28 @@ public final class StationMapBridge {
                 PathAnalysisResult.loading(normalizedOwnLocator6, normalizedTargetLocator6, targetCallsignRaw)
         );
 
-        pathAnalysisExecutor.submit(() -> {
+        ChatMember selectedMember = resolveBestChatMember(targetCallsignRaw);
-            PathAnalysisResult result = buildPathAnalysisResult(normalizedOwnLocator6, selectedSnapshot);
 
-            Platform.runLater(() -> {
+        chatController.getReachabilityService().requestPathAnalysisForMap(
+                selectedMember,
+                selectedSnapshot,
+                result -> {
                     if (generation != pathAnalysisGeneration.get()) {
                         return;
                     }
                     stationMapView.setPathAnalysisResult(result);
-            });
+                }
-        });
+        );
     }
 
+    /**
+     * Invalidates pending map callbacks.
+     *
+     * <p>The actual calculation executor is owned by ReachabilityService now, so
+     * this bridge no longer shuts down any path-analysis thread directly.</p>
+     */
     public void dispose() {
-        pathAnalysisExecutor.shutdownNow();
+        pathAnalysisGeneration.incrementAndGet();
     }
 
     private void handleMapCallsignSelection(String callSignRaw) {
@@ -286,43 +306,6 @@ public final class StationMapBridge {
         return callSignRaw.trim().toUpperCase(Locale.ROOT);
     }
 
-    private PathAnalysisResult buildPathAnalysisResult(String ownLocator6, MapCallsignRawSnapshot selectedSnapshot) {
-        String normalizedOwnLocator6 = normalizeLocator6(ownLocator6);
-
-        if (selectedSnapshot == null) {
-            return PathAnalysisResult.waitingForSelection(normalizedOwnLocator6);
-        }
-
-        String normalizedTargetLocator6 = normalizeLocator6(selectedSnapshot.locator6());
-
-        if (normalizedOwnLocator6.length() != 6) {
-            return PathAnalysisResult.waitingForValidHomeLocator(normalizedOwnLocator6, normalizedTargetLocator6);
-        }
-
-        if (!selectedSnapshot.hasUsablePosition()) {
-            return PathAnalysisResult.waitingForValidTarget(normalizedOwnLocator6, normalizedTargetLocator6);
-        }
-
-        Location homeLocation = new Location(normalizedOwnLocator6);
-        double analysisFrequencyMHz = resolveAnalysisFrequencyMHz(selectedSnapshot);
-
-        PathAnalysisRequest request = new PathAnalysisRequest(
-                normalizedOwnLocator6,
-                homeLocation.getLatitude().toDegrees(),
-                homeLocation.getLongitude().toDegrees(),
-                selectedSnapshot.callSignRaw(),
-                normalizedTargetLocator6,
-                selectedSnapshot.latitudeDeg(),
-                selectedSnapshot.longitudeDeg(),
-                analysisFrequencyMHz,
-                chatController.getChatPreferences().getStn_pathAnalysisOwnAntennaHeightMeters(),
-                chatController.getChatPreferences().getStn_pathAnalysisDefaultTargetAntennaHeightMeters(),
-                PathGeometryUtils.DEFAULT_EFFECTIVE_EARTH_RADIUS_FACTOR,
-                chatController.getChatPreferences().buildPathLinkBudgetSettings()
-        );
-
-        return pathAnalysisService.analyze(request);
-    }
 
     private double resolveAnalysisFrequencyMHz(MapCallsignRawSnapshot selectedSnapshot) {
         if (selectedSnapshot == null) {
@@ -376,12 +359,5 @@ public final class StationMapBridge {
         return locator.trim().toUpperCase(Locale.ROOT);
     }
 
-    private static final class PathAnalysisThreadFactory implements ThreadFactory {
+
-        @Override
-        public Thread newThread(Runnable runnable) {
-            Thread thread = new Thread(runnable, "station-map-path-analysis");
-            thread.setDaemon(true);
-            return thread;
-        }
-    }
 }

src/main/java/module-info.java

@@ -15,5 +15,6 @@ module praktiKST {
 	exports kst4contest.model;
 	exports kst4contest.view;
 
+
 	opens kst4contest.view.map to javafx.web;
 }

udpReaderBackup.txt

@@ -2366,3 +2366,8 @@ OZ1FDH;Claus;JO55QX;StringProperty [value: null]; wkd true; wkd144 true; wkd432f
 OZ7KJ;Skive Club;JO46ML;StringProperty [value: 144.225]; wkd true; wkd144 true; wkd432false; wkd1240false; wkd2300false; wkd3400false; wkd5600false; wkd10Gfalse ; 2: 144/432 MHz
 SM7VUK;Bengt;JO66LI;StringProperty [value: 144.304]; wkd true; wkd144 true; wkd432false; wkd1240false; wkd2300false; wkd3400false; wkd5600false; wkd10Gfalse ; 2: 144/432 MHz
 OZ1HDF;Ken;JO55UN;StringProperty [value: null]; wkd true; wkd144 true; wkd432false; wkd1240false; wkd2300false; wkd3400false; wkd5600false; wkd10Gfalse ; 2: 144/432 MHz
+DO5SA;unknown;unknown;StringProperty [value: null]; wkd true; wkd144 true; wkd432false; wkd1240false; wkd2300false; wkd3400false; wkd5600false; wkd10Gfalse ; null
+9A2HM;unknown;unknown;StringProperty [value: null]; wkd true; wkd144 false; wkd432false; wkd1240false; wkd2300false; wkd3400false; wkd5600false; wkd10Gfalse ; null
+9A2HM;null;null;StringProperty [value: null]; wkd true; wkd144 false; wkd432true; wkd1240false; wkd2300false; wkd3400false; wkd5600false; wkd10Gfalse ; null
+9A2HM;null;null;StringProperty [value: null]; wkd true; wkd144 false; wkd432false; wkd1240false; wkd2300true; wkd3400false; wkd5600false; wkd10Gfalse ; null
+OV3T;Thomas;JO46CM;StringProperty [value: null]; wkd true; wkd144 true; wkd432false; wkd1240false; wkd2300false; wkd3400false; wkd5600false; wkd10Gfalse ; 2: 144/432 MHz