Pipelines back to 1ce468145c

* Fixed Map: leaflet rendering in Java 21 Webview (disabling 3D in leaflet)

* Added grid square coloring function and fixed bug of message categorizing after entering the chat and not selected a chatmember

---------

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

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

@@ -2179,32 +2179,39 @@ public class ChatController implements ThreadStatusCallback, PstRotatorEventList
 	}
 
 	/**
-	 * 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.
+	 * Returns true when the member's four-character grid square has already been
+	 * worked on any band.
+	 *
+	 * <p>This method intentionally ignores the currently enabled own bands. The grid
+	 * status in the user list is meant to be a simple and robust any-band indicator.</p>
 	 *
 	 * @param member member to inspect
-	 * @return true if the station is still a new locator on any enabled band
+	 * @return true if the gross grid square was worked on any band
 	 */
-	public boolean isNewLocatorOnAnyEnabledBand(ChatMember member) {
+	public boolean isGridSquareWorkedAny(ChatMember member) {
 		if (member == null || member.getQra() == null) {
 			return false;
 		}
 
-		EnumSet<Band> enabledBands = reachabilityService == null
-				? getMyEnabledBandsFromPrefs(chatPreferences)
-				: reachabilityService.getEnabledStationBands();
+		return workedGrossFieldCache.isGrossFieldWorkedAny(member.getQra());
+	}
 
-		if (enabledBands.isEmpty()) {
+	/**
+	 * Returns true when the member's four-character grid square has not been worked
+	 * on any band yet.
+	 *
+	 * <p>This is the predicate behind the optional "Only new grids" filter. It no
+	 * longer depends on active station band settings.</p>
+	 *
+	 * @param member member to inspect
+	 * @return true if the gross grid square is still new
+	 */
+	public boolean isNewGridSquare(ChatMember member) {
+		if (member == null || member.getQra() == null) {
 			return false;
 		}
 
-		for (Band band : enabledBands) {
-			if (!workedGrossFieldCache.isGrossFieldWorked(band, member.getQra())) {
-				return true;
-			}
-		}
-
-		return false;
+		return !workedGrossFieldCache.isGrossFieldWorkedAny(member.getQra());
 	}
 
 	public long getCurrentEpochTime() {

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

@@ -682,8 +682,7 @@ public class DBController {
 		String workedBandColumnName = helper_resolveWorkedBandColumnName(chatMemberToStore);
 
 		if (workedBandColumnName == null) {
-			System.out.println("[DBCtrl, Error]: unknown at which band the qso had been!");
-			return false;
+			return helper_updateWorkedAnyOnChatMember(chatMemberToStore);
 		}
 
 //		String updateWorkedSql =
@@ -717,6 +716,47 @@ public class DBController {
 		}
 	}
 
+	/**
+	 * Updates only the global worked-any flag of a stored chatmember row.
+	 *
+	 * <p>This is used when an external logger confirms that a station was worked,
+	 * but the software cannot reliably map the QSO to one of the persisted band
+	 * columns. The UI status "x" is based on this global worked flag, so this method
+	 * makes no-band or unsupported-band log entries persistent as worked-any.</p>
+	 *
+	 * @param chatMemberToStore chatmember that contains the worked call and optional locator
+	 * @return true if an existing database row was updated
+	 * @throws SQLException if the database write fails
+	 */
+	private synchronized boolean helper_updateWorkedAnyOnChatMember(ChatMember chatMemberToStore) throws SQLException {
+
+		if (chatMemberToStore == null
+				|| chatMemberToStore.getCallSignRaw() == null
+				|| chatMemberToStore.getCallSignRaw().isBlank()) {
+			return false;
+		}
+
+		String updateWorkedAnySql =
+				"UPDATE ChatMember SET worked = 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(updateWorkedAnySql)) {
+			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;
+		}
+	}
+
+
 	/**
 	 * Updates all not-QRV flags for a chatmember row. The method uses the normalized
 	 * raw callsign and updates the timestamp so that automatic contest cleanup can

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

@@ -119,6 +119,31 @@ public final class WorkedGrossFieldCache {
                 .contains(grossField);
     }
 
+    /**
+     * Checks whether a locator gross field has already been worked on any band.
+     *
+     * <p>The UI grid status and the "Only new grids" filter use this any-band logic.
+     * This avoids user errors caused by wrong active-band settings and fits single
+     * band contests such as NAC better.</p>
+     *
+     * @param locatorOrGrossField six-character locator or four-character gross field
+     * @return true if the gross field exists in the cache on any band
+     */
+    public synchronized boolean isGrossFieldWorkedAny(String locatorOrGrossField) {
+        String grossField = extractGrossField(locatorOrGrossField);
+        if (grossField == null) {
+            return false;
+        }
+
+        for (Set<String> workedGrossFields : workedGrossFieldsByBand.values()) {
+            if (workedGrossFields != null && workedGrossFields.contains(grossField)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
     /**
      * Tries to normalize a locator. Accepts a plain six-character locator or extracts
      * one from exchange strings such as "001JO41HK".

src/main/java/kst4contest/view/Kst4ContestApplication.java

@@ -67,12 +67,17 @@ import kst4contest.utils.ApplicationFileUtils;
 import kst4contest.view.map.StationMapBridge;
 import kst4contest.view.map.StationMapView;
 import kst4contest.view.map.OfflineDemImportService;
+import kst4contest.controller.WorkedGrossFieldCache;
 
 
 public class Kst4ContestApplication extends Application implements StatusUpdateListener  {
 //	private static final Kst4ContestApplication dbcontroller = new DBController();
 	// Null means Auto: use the lowest session band, or category fallback.
 
+	// Enables optional color highlighting of the QRA/grid cell.
+// The status text itself remains visible independently of this flag.
+	private boolean gridSquareHighlightEnabled = false;
+
 	private PauseTransition userListRefreshCoalescer;
 	private String pendingUserListUpdateReason = "";
 
@@ -1260,6 +1265,75 @@ public class Kst4ContestApplication extends Application implements StatusUpdateL
 			}
 		});
 
+		/**
+		 * Optionally highlights already worked grid squares in the QRA column.
+		 *
+		 * <p>The default table design is preserved as much as possible:
+		 * <ul>
+		 *     <li>If grid coloring is disabled, the cell uses the standard JavaFX style.</li>
+		 *     <li>If the grid is not worked yet, the cell also uses the standard style.</li>
+		 *     <li>Only already worked grids get a subtle background color.</li>
+		 *     <li>Selected rows keep the normal table selection style.</li>
+		 * </ul>
+		 *
+		 * <p>No font weight is changed here. The compact worked/grid status such as
+		 * {@code xo} is emphasized only in the worked-any column.</p>
+		 */
+		qraCol.setCellFactory(column -> new TableCell<ChatMember, String>() {
+			@Override
+			protected void updateItem(String item, boolean empty) {
+				super.updateItem(item, empty);
+
+				if (empty || item == null) {
+					setText(null);
+					setTooltip(null);
+					setStyle("");
+					return;
+				}
+
+				ChatMember member = getTableRow() == null ? null : getTableRow().getItem();
+				boolean gridWorked = member != null
+						&& chatcontroller != null
+						&& chatcontroller.isGridSquareWorkedAny(member);
+
+				String grossField = WorkedGrossFieldCache.extractGrossField(item);
+
+				setText(item);
+				setTooltip(new Tooltip(
+						"Grid status: "
+								+ (grossField == null ? "unknown" : grossField)
+								+ "\nGrid worked any: "
+								+ (gridWorked ? "yes" : "no")
+				));
+
+				/*
+				 * Important:
+				 * Do not style the cell unless the Grid color button is active AND the
+				 * grid has already been worked. This keeps normal/new grids visually
+				 * identical to the standard table design.
+				 */
+				if (!gridSquareHighlightEnabled || !gridWorked) {
+					setStyle("");
+					return;
+				}
+
+				/*
+				 * Preserve normal selection appearance. A selected row should look like a
+				 * selected row, not like a custom-colored QRA cell.
+				 */
+				if (isSelected() || (getTableRow() != null && getTableRow().isSelected())) {
+					setStyle("");
+					return;
+				}
+
+				/*
+				 * Already worked grid:
+				 * Use a subtle background derived from the current theme. No bold text.
+				 */
+				setStyle("-fx-background-color: derive(-fx-control-inner-background, -18%);");
+			}
+		});
+
 		TableColumn<ChatMember, String> qrBCol = new TableColumn<ChatMember, String>("QRB");
 		qrBCol.setCellValueFactory(new Callback<CellDataFeatures<ChatMember, String>, ObservableValue<String>>() {
 
@@ -1484,19 +1558,60 @@ public class Kst4ContestApplication extends Application implements StatusUpdateL
 
 					@Override
 					public ObservableValue<String> call(CellDataFeatures<ChatMember, String> cellDataFeatures) {
-						SimpleStringProperty wkd = new SimpleStringProperty();
-
-						if (cellDataFeatures.getValue().isWorked()) {
-							wkd.setValue("X");
-						} else {
-							wkd.setValue("");
-						}
-
-						return wkd;
+						return new SimpleStringProperty(formatWorkedAnyGridStatus(cellDataFeatures.getValue()));
 					}
 				});
 		wkdAny_subcol.prefWidthProperty().bind(tbl_chatMemberTable.widthProperty().divide(14));
 
+		/**
+		 * Shows the compact worked/grid status and explains it by tooltip.
+		 */
+		wkdAny_subcol.setCellFactory(column -> new TableCell<ChatMember, String>() {
+			@Override
+			protected void updateItem(String item, boolean empty) {
+				super.updateItem(item, empty);
+
+				if (empty) {
+					setText(null);
+					setTooltip(null);
+					setStyle("");
+					return;
+				}
+
+				ChatMember member = getTableRow() == null ? null : getTableRow().getItem();
+
+				setText(item);
+				setTooltip(new Tooltip(buildWorkedAnyGridStatusTooltip(member)));
+				setAlignment(Pos.CENTER);
+				setStyle("-fx-font-weight: bold;");
+			}
+		});
+
+		/**
+		 * Shows the compact worked/grid status and explains it by tooltip.
+		 */
+		wkdAny_subcol.setCellFactory(column -> new TableCell<ChatMember, String>() {
+			@Override
+			protected void updateItem(String item, boolean empty) {
+				super.updateItem(item, empty);
+
+				if (empty) {
+					setText(null);
+					setTooltip(null);
+					setStyle("");
+					return;
+				}
+
+				ChatMember member = getTableRow() == null ? null : getTableRow().getItem();
+
+				setText(item);
+				setTooltip(new Tooltip(buildWorkedAnyGridStatusTooltip(member)));
+				setAlignment(Pos.CENTER);
+				setStyle("-fx-font-weight: bold;");
+			}
+		});
+
+
 		TableColumn<ChatMember, String> vhfCol_subcol = new TableColumn<ChatMember, String>("144");
 		vhfCol_subcol
 				.setCellValueFactory(new Callback<CellDataFeatures<ChatMember, String>, ObservableValue<String>>() {
@@ -5487,29 +5602,79 @@ public class Kst4ContestApplication extends Application implements StatusUpdateL
 
 					ChatMessage sendMe = new ChatMessage();
 
-					/**
-					 * testing bugfix
+					/*
+					 * Resolve the selected station safely.
+					 *
+					 * Normal case:
+					 * - selectedCallSignInfoStageChatMember is set by clicking/selecting a station.
+					 *
+					 * Fallbacks:
+					 * - current table selection
+					 * - ScoreService selected member
+					 *
+					 * If no station is selected at all, the message is sent to the main category.
 					 */
+					ChatMember effectiveSelectedMember = selectedCallSignInfoStageChatMember;
 
-					ChatCategory sendMeInThisCat;
-					String categoryNumber = selectedCallSignInfoStageChatMember.getChatCategory().getCategoryNumber() +"";
-
-					if (categoryNumber.equals(chatcontroller.getChatCategoryMain().getCategoryNumber() + "")) {
-						sendMeInThisCat = chatcontroller.getChatCategoryMain();
-
-					} else if (categoryNumber.equals(chatcontroller.getChatCategorySecondChat().getCategoryNumber() + "")) {
-						sendMeInThisCat = chatcontroller.getChatCategorySecondChat();
-
-					} else {
-						sendMeInThisCat = chatcontroller.getChatCategoryMain(); //Chatcategory default decision
+					if (effectiveSelectedMember == null
+							&& tbl_chatMember != null
+							&& tbl_chatMember.getSelectionModel() != null) {
+						effectiveSelectedMember = tbl_chatMember.getSelectionModel().getSelectedItem();
 					}
 
-					System.out.println("<<<<<<<<<<<<<<<<<<<<< detected Category for sending message is " + sendMeInThisCat + " // selected member: " + selectedCallSignInfoStageChatMember.getChatCategory() + " evt " + event.isConsumed() );
-					/**
-					 * end testing bugfix
-					 */
+					if (effectiveSelectedMember == null
+							&& chatcontroller != null
+							&& chatcontroller.getScoreService() != null) {
+						effectiveSelectedMember = chatcontroller.getScoreService().getSelectedChatMember();
+					}
 
-					sendMe.setChatCategory(sendMeInThisCat); //new in 1.26, answer in channel of the selected member
+					/*
+					 * Default decision:
+					 * If no station is selected, use the main category.
+					 */
+					ChatCategory sendMeInThisCat = chatcontroller.getChatCategoryMain();
+
+					/*
+					 * If a station is selected and its category matches one of our active chat
+					 * categories, send in that category. This keeps the old behaviour, but avoids
+					 * NullPointerExceptions when no station has been selected yet.
+					 */
+					if (effectiveSelectedMember != null && effectiveSelectedMember.getChatCategory() != null) {
+
+						String categoryNumber = effectiveSelectedMember.getChatCategory().getCategoryNumber() + "";
+
+						if (chatcontroller.getChatCategoryMain() != null
+								&& categoryNumber.equals(chatcontroller.getChatCategoryMain().getCategoryNumber() + "")) {
+
+							sendMeInThisCat = chatcontroller.getChatCategoryMain();
+
+						} else if (chatcontroller.getChatCategorySecondChat() != null
+								&& categoryNumber.equals(chatcontroller.getChatCategorySecondChat().getCategoryNumber() + "")) {
+
+							sendMeInThisCat = chatcontroller.getChatCategorySecondChat();
+
+						} else {
+							sendMeInThisCat = chatcontroller.getChatCategoryMain(); // Chatcategory default decision
+						}
+					}
+
+					String selectedMemberDebugText;
+					if (effectiveSelectedMember == null) {
+						selectedMemberDebugText = "none, using main category";
+					} else {
+						selectedMemberDebugText = effectiveSelectedMember.getCallSignRaw()
+								+ " / "
+								+ effectiveSelectedMember.getChatCategory();
+					}
+
+					System.out.println("<<<<<<<<<<<<<<<<<<<<< detected Category for sending message is "
+							+ sendMeInThisCat
+							+ " // selected member: "
+							+ selectedMemberDebugText
+							+ " evt "
+							+ event.isConsumed());
+
+					sendMe.setChatCategory(sendMeInThisCat); // new in 1.26, answer in channel of the selected member if available
 					sendMe.setMessageText(txt_chatMessageUserInput.getText());
 
 					// If operator sends "/cq CALL ..." => arm pending ping metrics for reply-time / no-reply tracking
@@ -5518,11 +5683,9 @@ public class Kst4ContestApplication extends Application implements StatusUpdateL
 
 					sendMe.setMessageDirectedToServer(false);
 
-					chatcontroller.getMessageTXBus().add(sendMe); //move the message to the tx queue
+					chatcontroller.getMessageTXBus().add(sendMe); // move the message to the tx queue
 
 					txt_chatMessageUserInput.clear();
-
-
 				}
 			});
 
@@ -6120,13 +6283,14 @@ public class Kst4ContestApplication extends Application implements StatusUpdateL
 			chatMemberTableFilterMaxQrbTF.setFocusTraversable(false);
 
 
-			ToggleButton btnTglNewLocator = new ToggleButton("New locator");
+			ToggleButton btnTglNewLocator = new ToggleButton("Only new grids");
 			Predicate<ChatMember> newLocatorPredicate = new Predicate<ChatMember>() {
 				@Override
 				public boolean test(ChatMember chatMember) {
-					return chatcontroller.isNewLocatorOnAnyEnabledBand(chatMember);
+					return chatcontroller.isNewGridSquare(chatMember);
 				}
 			};
+
 			btnTglNewLocator.setOnAction(new EventHandler<ActionEvent>() {
 				@Override
 				public void handle(ActionEvent actionEvent) {
@@ -6137,7 +6301,26 @@ public class Kst4ContestApplication extends Application implements StatusUpdateL
 					}
 				}
 			});
-			btnTglNewLocator.setTooltip(new Tooltip("Show only stations whose gross locator is still new on at least one active own band"));
+			btnTglNewLocator.setTooltip(new Tooltip("Show only stations whose 4-character grid square has not been worked on any band yet"));
+
+
+			ToggleButton btnTglGridColor = new ToggleButton("Grid color");
+
+			/**
+			 * Enables optional QRA-cell coloring for grid status.
+			 *
+			 * <p>This does not filter the list. It only colors the locator field:
+			 * worked grid = darker, new grid = brighter.</p>
+			 */
+			btnTglGridColor.setOnAction(new EventHandler<ActionEvent>() {
+				@Override
+				public void handle(ActionEvent actionEvent) {
+					gridSquareHighlightEnabled = btnTglGridColor.isSelected();
+					tbl_chatMember.refresh();
+				}
+			});
+
+			btnTglGridColor.setTooltip(new Tooltip("Color the QRA field by grid status without filtering the station list"));
 
 			ToggleButton btnTglReachableTropo = new ToggleButton("Tropo >=0dB");
 			Predicate<ChatMember> reachableTropoPredicate = new Predicate<ChatMember>() {
@@ -6807,6 +6990,7 @@ public class Kst4ContestApplication extends Application implements StatusUpdateL
 
 			chatMemberTableFilterWorkedBandFiltersHbx.getChildren().addAll(
 					btnTglNewLocator,
+					btnTglGridColor,
 					btnTglReachableTropo,
 					btnTglNewBands,
 					btnTglAsNext5Min
@@ -9426,6 +9610,75 @@ public class Kst4ContestApplication extends Application implements StatusUpdateL
 		return sb.toString();
 	}
 
+
+	/**
+	 * Formats the global worked/grid status for the worked-any column.
+	 *
+	 * <p>Status characters follow the user feedback:
+	 * <ul>
+	 *     <li>empty = call not worked, grid not worked</li>
+	 *     <li>x = call worked</li>
+	 *     <li>o = grid worked, call not worked</li>
+	 *     <li>xo = call and grid worked</li>
+	 * </ul>
+	 *
+	 * <p>The call status is based on {@link ChatMember#isWorked()}, i.e. worked-any.
+	 * The grid status is based on the four-character grid square worked on any band.</p>
+	 *
+	 * @param member station row
+	 * @return compact status text
+	 */
+	private String formatWorkedAnyGridStatus(ChatMember member) {
+		if (member == null) {
+			return "";
+		}
+
+		boolean callWorked = member.isWorked();
+		boolean gridWorked = chatcontroller != null && chatcontroller.isGridSquareWorkedAny(member);
+
+		if (callWorked && gridWorked) {
+			return "xo";
+		}
+
+		if (callWorked) {
+			return "x";
+		}
+
+		if (gridWorked) {
+			return "o";
+		}
+
+		return "";
+	}
+
+	/**
+	 * Builds a tooltip for the worked-any/grid-status cell.
+	 *
+	 * @param member station row
+	 * @return tooltip text
+	 */
+	private String buildWorkedAnyGridStatusTooltip(ChatMember member) {
+		if (member == null) {
+			return "empty = call not worked, grid not worked\n"
+					+ "x = call worked\n"
+					+ "o = grid worked\n"
+					+ "xo = call and grid worked";
+		}
+
+		String grossField = WorkedGrossFieldCache.extractGrossField(member.getQra());
+		String gridText = grossField == null ? "unknown grid" : "grid " + grossField;
+
+		return "Worked status:\n"
+				+ "empty = call not worked, grid not worked\n"
+				+ "x = call worked\n"
+				+ "o = grid worked\n"
+				+ "xo = call and grid worked\n\n"
+				+ "This station:\n"
+				+ "Call worked: " + (member.isWorked() ? "yes" : "no") + "\n"
+				+ "Grid worked: " + (chatcontroller != null && chatcontroller.isGridSquareWorkedAny(member) ? "yes" : "no")
+				+ " (" + gridText + ")";
+	}
+
 //	/**
 //	 *
 //	 * resets the style of the not selected direction buttons
@@ -9706,6 +9959,72 @@ public class Kst4ContestApplication extends Application implements StatusUpdateL
 //	}
 
 
+	/**
+	 * Returns the best currently selected ChatMember for actions that depend on a
+	 * selected station.
+	 *
+	 * <p>The normal source is selectedCallSignInfoStageChatMember. As a fallback,
+	 * the current table selection and the ScoreService selection are checked. If
+	 * nothing is selected yet, null is returned. This is valid and must be handled
+	 * by the caller.</p>
+	 *
+	 * @return selected ChatMember or null if no station is selected
+	 */
+	private ChatMember getEffectiveSelectedChatMember() {
+		if (selectedCallSignInfoStageChatMember != null) {
+			return selectedCallSignInfoStageChatMember;
+		}
+
+		if (tbl_chatMember != null
+				&& tbl_chatMember.getSelectionModel() != null
+				&& tbl_chatMember.getSelectionModel().getSelectedItem() != null) {
+			return tbl_chatMember.getSelectionModel().getSelectedItem();
+		}
+
+		if (chatcontroller != null
+				&& chatcontroller.getScoreService() != null
+				&& chatcontroller.getScoreService().getSelectedChatMember() != null) {
+			return chatcontroller.getScoreService().getSelectedChatMember();
+		}
+
+		return null;
+	}
+
+	/**
+	 * Resolves the chat category for an outgoing operator message.
+	 *
+	 * <p>If a station is selected, the message is sent in the category of that
+	 * station. If no station is selected yet, the message is sent in the main chat
+	 * category. This prevents NullPointerExceptions when the operator writes to the
+	 * chat immediately after joining.</p>
+	 *
+	 * @param selectedMember selected station, may be null
+	 * @return category for the outgoing message, normally main or second category
+	 */
+	private ChatCategory resolveOutgoingChatCategory(ChatMember selectedMember) {
+		ChatCategory mainCategory = chatcontroller.getChatCategoryMain();
+		ChatCategory secondCategory = chatcontroller.getChatCategorySecondChat();
+
+		if (selectedMember == null || selectedMember.getChatCategory() == null) {
+			return mainCategory;
+		}
+
+		String categoryNumber = selectedMember.getChatCategory().getCategoryNumber() + "";
+
+		if (mainCategory != null
+				&& categoryNumber.equals(mainCategory.getCategoryNumber() + "")) {
+			return mainCategory;
+		}
+
+		if (secondCategory != null
+				&& categoryNumber.equals(secondCategory.getCategoryNumber() + "")) {
+			return secondCategory;
+		}
+
+		return mainCategory;
+	}
+
+
 	/**
 	 * helper method, in cases of QRG ending qith 0 as double values, it will fill the ending 0 to the qrg string
 	 * @param raw

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

@@ -214,6 +214,11 @@ public final class MapHtmlResources {
                 <body class="kst-theme-light">
                 <div id="map"></div>
 
+                <script>
+                    // JavaFX 21 WebView can render Leaflet's CSS translate3d tile positioning incorrectly.
+                    // Disable Leaflet 3D transforms before leaflet.js is loaded to keep tile rendering stable.
+                    window.L_DISABLE_3D = true;
+                </script>
                 <script>
                 """ + leafletJs + """
                 </script>
@@ -366,18 +371,31 @@ public final class MapHtmlResources {
                             applyThemeClass();
 
                             map = L.map('map', {
-                                zoomControl: true
+                                zoomControl: true,
+                                zoomAnimation: false,
+                                fadeAnimation: false,
+                                markerZoomAnimation: false,
+                                inertia: false
                             }).setView([51.0, 10.0], 6);
 
                             jsLog('Leaflet map initialized');
 
-                            L.tileLayer(
+                            const tileLayer = L.tileLayer(
                                 'http://127.0.0.1:' + window._kstTileProxyPort + '/tiles/{s}/{z}/{x}/{y}.png',
                                 {
                                     maxZoom: 18,
+                                    updateWhenZooming: false,
+                                    keepBuffer: 4,
                                     attribution: '&copy; <a href="https://www.openstreetmap.org/copyright">OpenStreetMap</a>'
                                 }
-                            ).addTo(map);
+                            );
+
+                            tileLayer.on('tileerror', function (event) {
+                                const source = event && event.tile ? event.tile.src : 'unknown';
+                                jsError('OSM tile load failed: ' + source);
+                            });
+
+                            tileLayer.addTo(map);
 
                             map.createPane('beamPane');
                             map.getPane('beamPane').style.zIndex = 410;
@@ -416,22 +434,47 @@ public final class MapHtmlResources {
                         }
 
                         function invalidateSize() {
-                             if (!map) {
-                                 return;
-                             }
-                
-                             jsLog('invalidateSize');
-                
-                             map.invalidateSize(false);
-                
-                             if (invalidateNotifyTimer) {
-                                 window.clearTimeout(invalidateNotifyTimer);
-                             }
-                
-                             invalidateNotifyTimer = window.setTimeout(function () {
-                                 notifyViewport();
-                             }, 120);
-                         }
+                            if (!map) {
+                                return;
+                            }
+
+                            const mapElement = document.getElementById('map');
+                            const domWidth = mapElement ? mapElement.clientWidth : -1;
+                            const domHeight = mapElement ? mapElement.clientHeight : -1;
+
+                            jsLog('invalidateSize dom=' + domWidth + 'x' + domHeight
+                                    + ' leafletBefore=' + map.getSize().x + 'x' + map.getSize().y);
+
+                            window.requestAnimationFrame(function () {
+                                map.invalidateSize({
+                                    animate: false,
+                                    pan: false,
+                                    debounceMoveend: true
+                                });
+
+                                window.setTimeout(function () {
+                                    map.invalidateSize({
+                                        animate: false,
+                                        pan: false,
+                                        debounceMoveend: true
+                                    });
+
+                                    jsLog('invalidateSize leafletAfter=' + map.getSize().x + 'x' + map.getSize().y);
+
+                                    if (invalidateNotifyTimer) {
+                                        window.clearTimeout(invalidateNotifyTimer);
+                                    }
+
+                                    invalidateNotifyTimer = window.setTimeout(function () {
+                                        notifyViewport();
+                                    }, 120);
+                                }, 80);
+                            });
+                        }
+
+                        function resize() {
+                            invalidateSize();
+                        }
 
                         function zoomIn() {
                             if (!map) {
@@ -693,6 +736,7 @@ public final class MapHtmlResources {
                         return {
                               init: init,
                               invalidateSize: invalidateSize,
+                              resize: resize,
                               zoomIn: zoomIn,
                               zoomOut: zoomOut,
                               inspectPoint: inspectPoint,

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

@@ -49,6 +49,17 @@ public final class StationMapView {
     private final Stage stage = new Stage();
     private final WebView webView = new WebView();
     private final WebEngine webEngine = webView.getEngine();
+
+    /**
+     * Keep a strong Java reference to the bridge object.
+     *
+     * JavaFX WebView/JSObject does not guarantee that a Java object passed through
+     * window.setMember(...) remains strongly reachable from the Java side. Newer
+     * JavaFX/WebKit/GC combinations can otherwise lose callbacks after a while.
+     */
+    private final JavaMapBridge javaMapBridge = new JavaMapBridge();
+
+
     private TileProxyServer tileProxyServer;
 
     private Scene scene;
@@ -85,6 +96,22 @@ public final class StationMapView {
     private List<MapCallsignRawSnapshot> lastSnapshots = List.of();
     private MapCallsignRawSnapshot lastSelectedSnapshot;
     private boolean filteredViewActive;
+    /**
+     * Last JSON payloads sent into Leaflet. Used to avoid clearing/recreating
+     * layers every score/table refresh. Rebuilding DOM markers every few seconds
+     * is visible as flicker in JavaFX 21 WebView.
+     */
+    private String lastRenderedStationsJson = "";
+    private String lastRenderedBeamJson = "";
+    private String lastRenderedConnectionJson = "";
+    private String lastRenderedGridJson = "";
+
+    /**
+     * Prevent periodic refreshes from panning the map back to the selected station.
+     * Explicit calls to focusCallsignRaw(...) still pan immediately.
+     */
+    private String lastAutoFocusedCallsignRaw = "";
+
 
     private double homeLatitudeDeg = Double.NaN;
     private double homeLongitudeDeg = Double.NaN;
@@ -192,8 +219,11 @@ public final class StationMapView {
             return;
         }
 
+        String normalizedCallsignRaw = callSignRaw.trim().toUpperCase(Locale.ROOT);
+        lastAutoFocusedCallsignRaw = normalizedCallsignRaw;
+
         executeMapScriptSafely(
-                "window.kstMapApi.focusCallsignRaw(" + toJsStringLiteral(callSignRaw.trim().toUpperCase(Locale.ROOT)) + ");"
+                "window.kstMapApi.focusCallsignRaw(" + toJsStringLiteral(normalizedCallsignRaw) + ");"
         );
     }
 
@@ -292,6 +322,8 @@ public final class StationMapView {
         webView.setMinWidth(0);
         webView.setMinHeight(220);
         webView.setPrefHeight(420);
+        webView.setMaxWidth(Double.MAX_VALUE);
+        webView.setMaxHeight(Double.MAX_VALUE);
         VBox.setVgrow(webView, Priority.ALWAYS);
 
         profileSection.setMinWidth(0);
@@ -623,7 +655,7 @@ public final class StationMapView {
         webEngine.getLoadWorker().stateProperty().addListener((obs, oldState, newState) -> {
             if (newState == javafx.concurrent.Worker.State.SUCCEEDED) {
                 JSObject window = (JSObject) webEngine.executeScript("window");
-                window.setMember("javaMapBridge", new JavaMapBridge());
+                window.setMember("javaMapBridge", javaMapBridge);
 
                 executeMapScriptSafely("window.kstMapApi.init();");
 
@@ -643,11 +675,13 @@ public final class StationMapView {
             return;
         }
 
-        Platform.runLater(() ->
-                Platform.runLater(() ->
-                        executeMapScriptSafely("window.kstMapApi.invalidateSize();")));
+        Platform.runLater(() -> Platform.runLater(() ->
+                executeMapScriptSafely("window.kstMapApi.resize();")
+        ));
     }
 
+
+
     private void handleWebViewClick(MouseEvent event) {
         logWebViewMouseEvent("MOUSE_CLICKED", event);
 
@@ -910,9 +944,6 @@ public final class StationMapView {
         detailPathProfileChart.setObstructionSummary(result.obstructionSummary());
     }
 
-
-
-
     private void renderAll() {
         if (!mapReady) {
             return;
@@ -930,49 +961,78 @@ public final class StationMapView {
         renderBeam();
         renderConnectionLine();
         renderGridIfViewportKnown();
+        focusSelectedStationOnlyWhenSelectionChanged();
+    }
 
-        if (lastSelectedSnapshot != null) {
-            focusCallsignRaw(lastSelectedSnapshot.callSignRaw());
+    private void focusSelectedStationOnlyWhenSelectionChanged() {
+        if (lastSelectedSnapshot == null || lastSelectedSnapshot.callSignRaw() == null) {
+            lastAutoFocusedCallsignRaw = "";
+            return;
         }
+
+        String selectedCallsignRaw = lastSelectedSnapshot.callSignRaw().trim().toUpperCase(Locale.ROOT);
+        if (selectedCallsignRaw.isBlank() || selectedCallsignRaw.equals(lastAutoFocusedCallsignRaw)) {
+            return;
+        }
+
+        focusCallsignRaw(selectedCallsignRaw);
     }
 
     private void renderStations() {
+        String stationsJson = toStationsJson(lastSnapshots);
+        if (stationsJson.equals(lastRenderedStationsJson)) {
+            return;
+        }
+
+        lastRenderedStationsJson = stationsJson;
+
         executeMapScriptSafely(
-                "window.kstMapApi.setStations(" + toJsStringLiteral(toStationsJson(lastSnapshots)) + ");"
+                "window.kstMapApi.setStations(" + toJsStringLiteral(stationsJson) + ");"
         );
     }
 
     private void renderBeam() {
-        if (!Double.isFinite(homeLatitudeDeg)
-                || !Double.isFinite(homeLongitudeDeg)
-                || beamWidthDeg <= 0.0
-                || maxQrbKm <= 0.0) {
+        String beamJson = "null";
 
-            executeMapScriptSafely("window.kstMapApi.setBeam('null');");
-            return;
+        if (Double.isFinite(homeLatitudeDeg)
+                && Double.isFinite(homeLongitudeDeg)
+                && beamWidthDeg > 0.0
+                && maxQrbKm > 0.0) {
+
+            List<double[]> sectorPoints = buildBeamPolygon(homeLatitudeDeg, homeLongitudeDeg, antennaAzimuthDeg, beamWidthDeg, maxQrbKm);
+            beamJson = toPointArrayJson(sectorPoints);
         }
 
-        List<double[]> sectorPoints = buildBeamPolygon(homeLatitudeDeg, homeLongitudeDeg, antennaAzimuthDeg, beamWidthDeg, maxQrbKm);
+        if (beamJson.equals(lastRenderedBeamJson)) {
+            return;
+        }
+        lastRenderedBeamJson = beamJson;
+
         executeMapScriptSafely(
-                "window.kstMapApi.setBeam(" + toJsStringLiteral(toPointArrayJson(sectorPoints)) + ");"
+                "window.kstMapApi.setBeam(" + toJsStringLiteral(beamJson) + ");"
         );
     }
 
     private void renderConnectionLine() {
-        if (lastSelectedSnapshot == null || !lastSelectedSnapshot.hasUsablePosition()
-                || !Double.isFinite(homeLatitudeDeg) || !Double.isFinite(homeLongitudeDeg)) {
+        String connectionJson = "null";
 
-            executeMapScriptSafely("window.kstMapApi.setConnection('null');");
-            return;
+        if (lastSelectedSnapshot != null && lastSelectedSnapshot.hasUsablePosition()
+                && Double.isFinite(homeLatitudeDeg) && Double.isFinite(homeLongitudeDeg)) {
+
+            List<double[]> points = List.of(
+                    new double[]{homeLatitudeDeg, homeLongitudeDeg},
+                    new double[]{lastSelectedSnapshot.latitudeDeg(), lastSelectedSnapshot.longitudeDeg()}
+            );
+            connectionJson = toPointArrayJson(points);
         }
 
-        List<double[]> points = List.of(
-                new double[]{homeLatitudeDeg, homeLongitudeDeg},
-                new double[]{lastSelectedSnapshot.latitudeDeg(), lastSelectedSnapshot.longitudeDeg()}
-        );
+        if (connectionJson.equals(lastRenderedConnectionJson)) {
+            return;
+        }
+        lastRenderedConnectionJson = connectionJson;
 
         executeMapScriptSafely(
-                "window.kstMapApi.setConnection(" + toJsStringLiteral(toPointArrayJson(points)) + ");"
+                "window.kstMapApi.setConnection(" + toJsStringLiteral(connectionJson) + ");"
         );
     }
 
@@ -1011,11 +1071,19 @@ public final class StationMapView {
                 + " cellPx=" + String.format(Locale.US, "%.1f/%.1f", renderPlan.estimatedCellWidthPx(), renderPlan.estimatedCellHeightPx())
                 + " cells=" + visibleGridCells.size());
 
+        String gridJson = toGridJson(visibleGridCells, renderPlan);
+        if (gridJson.equals(lastRenderedGridJson)) {
+            return;
+        }
+        lastRenderedGridJson = gridJson;
+
         executeMapScriptSafely(
-                "window.kstMapApi.setGrid(" + toJsStringLiteral(toGridJson(visibleGridCells, renderPlan)) + ");"
+                "window.kstMapApi.setGrid(" + toJsStringLiteral(gridJson) + ");"
         );
     }
 
+
+
     private List<double[]> buildBeamPolygon(double startLatDeg,
                                             double startLonDeg,
                                             double centerAzimuthDeg,

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

@@ -19,8 +19,10 @@ import java.util.concurrent.Executors;
  */
 final class TileProxyServer {
 
-    private static final int CACHE_MAX = 512;
+    private static final int CACHE_MAX = 2048;
     private static final String USER_AGENT = "kst4contest/1.0 amateur-radio-contest-tool";
+    private static final int TILE_PROXY_THREADS = 12;
+    private static final int TILE_PROXY_BACKLOG = 128;
 
     private final ServerSocket serverSocket;
     private final ExecutorService executor;
@@ -39,9 +41,9 @@ final class TileProxyServer {
             }
         });
 
-        this.serverSocket = new ServerSocket(0, 16, InetAddress.getByName("127.0.0.1"));
+        this.serverSocket = new ServerSocket(0, TILE_PROXY_BACKLOG, InetAddress.getByName("127.0.0.1"));
 
-        this.executor = Executors.newFixedThreadPool(4, r -> {
+        this.executor = Executors.newFixedThreadPool(TILE_PROXY_THREADS, r -> {
             Thread t = new Thread(r, "tile-proxy");
             t.setDaemon(true);
             return t;
@@ -132,6 +134,7 @@ final class TileProxyServer {
                     + "Content-Type: image/png\r\n"
                     + "Content-Length: " + tileData.length + "\r\n"
                     + "Cache-Control: max-age=86400\r\n"
+                    + "Access-Control-Allow-Origin: *\r\n"
                     + "Connection: close\r\n"
                     + "\r\n";
             out.write(header.getBytes());

src/main/java/module-info.java

@@ -18,4 +18,4 @@ module praktiKST {
 
 
 	opens kst4contest.view.map to javafx.web;
-}
+}