fix(flight-planner): preserve viewport during waypoint redraws (#28)

* fix(flight-planner): preserve viewport across waypoint redraws

* test(flight-planner): cover waypoint viewport stability

* test(flight-planner): exercise deferred viewport repair

* docs(porting): record waypoint viewport handoff

Author: obazna

Controls/FlightPlannerMap.cs

@@ -54,6 +54,7 @@ private readonly
   private int _dragIndex = -1;
   private bool _pressedOnWaypoint;
   private readonly List<MPoint> _mapOverlayPoints = [];
+  private int _waypointRedrawVersion;
 
   private readonly HashSet<int> _groupSet = new();
   private readonly Dictionary<int, (double Lat, double Lng)> _groupSnapshot = new();
@@ -135,6 +136,11 @@ public void SetWaypoints(
       IReadOnlyList<(int Seq, double Lat, double Lng, ushort Cmd, double P1, double P2, double P3,
           double P4)> wps,
       double wpRadius, double loiterRadius, Firmwares firmware) {
+    var viewportBeforeRedraw = Map.Navigator.Viewport;
+    bool preserveViewport = _centered && viewportBeforeRedraw.HasSize()
+        && double.IsFinite(viewportBeforeRedraw.Resolution)
+        && viewportBeforeRedraw.Resolution > 0;
+    int redrawVersion = ++_waypointRedrawVersion;
     _wpRadius = RadiusInMeters(wpRadius, CurrentState.multiplierdist);
     _loiterRadius = RadiusInMeters(loiterRadius, CurrentState.multiplierdist);
     _firmware = firmware;
@@ -154,6 +160,29 @@ public void SetWaypoints(
       double res = 156543.03392804097 / Math.Pow(2, 17);
       Map.Navigator.CenterOnAndZoomTo(new MPoint(x, y), res);
       _centered = true;
+    } else if (preserveViewport) {
+      RestoreViewport(viewportBeforeRedraw);
+      // Mapsui may finish an extent-reactive refresh after this input callback returns.
+      Dispatcher.UIThread.Post(() => {
+        if (redrawVersion == _waypointRedrawVersion) {
+          RestoreViewport(viewportBeforeRedraw);
+        }
+      });
+    }
+  }
+
+  private void RestoreViewport(Viewport expected) {
+    Viewport current = Map.Navigator.Viewport;
+    if (current.CenterX.Equals(expected.CenterX)
+        && current.CenterY.Equals(expected.CenterY)
+        && current.Resolution.Equals(expected.Resolution)
+        && current.Rotation.Equals(expected.Rotation)) {
+      return;
+    }
+    Map.Navigator.CenterOnAndZoomTo(
+        new MPoint(expected.CenterX, expected.CenterY), expected.Resolution);
+    if (!Map.Navigator.Viewport.Rotation.Equals(expected.Rotation)) {
+      Map.Navigator.RotateTo(expected.Rotation);
     }
   }
 

MissionPlannerTests/Avalonia/MissionPlanner.Tests/FlightPlannerViewportTests.cs

@@ -0,0 +1,92 @@
+using Avalonia.Controls;
+using Avalonia.Headless.XUnit;
+using Avalonia.Threading;
+using Mapsui.Layers;
+using Mapsui.Nts;
+using Mapsui.Styles;
+using MissionPlanner.ArduPilot;
+using MissionPlanner.Controls;
+
+namespace MissionPlanner.Tests;
+
+public class FlightPlannerViewportTests {
+  [AvaloniaFact]
+  public void Waypoint_redraw_preserves_an_initialized_viewport() {
+    var map = new FlightPlannerMap();
+    var window = new Window { Width = 1200, Height = 800, Content = map };
+    try {
+      window.Show();
+      Dispatcher.UIThread.RunJobs();
+
+      map.CenterOnAndZoom(50.344, 30.88, 14);
+      map.SetHome(37.619373, -122.376637, 5.28);
+      map.SetWaypoints(KyivWaypoints(2), 50, 80, Firmwares.ArduPlane);
+      Dispatcher.UIThread.RunJobs();
+      Mapsui.Viewport expected = map.Map.Navigator.Viewport;
+
+      WritableLayer route = RouteLayer(map);
+      route.DataChanged += (_, _) => {
+        if (route.GetFeatures().OfType<GeometryFeature>().Count() == 2) {
+          Dispatcher.UIThread.Post(() => map.Map.Navigator.ZoomToBox(route.Extent));
+        }
+      };
+
+      map.SetWaypoints(KyivWaypoints(3), 50, 80, Firmwares.ArduPlane);
+      Dispatcher.UIThread.RunJobs();
+      Mapsui.Viewport actual = map.Map.Navigator.Viewport;
+
+      Assert.Equal(expected.CenterX, actual.CenterX, 3);
+      Assert.Equal(expected.CenterY, actual.CenterY, 3);
+      Assert.Equal(expected.Resolution, actual.Resolution, 6);
+    } finally {
+      window.Close();
+    }
+  }
+
+  [AvaloniaFact]
+  public void Distant_home_closing_route_remains_solid() {
+    var map = new FlightPlannerMap();
+    map.SetHome(37.619373, -122.376637, 5.28);
+    map.SetWaypoints(KyivWaypoints(3), 50, 80, Firmwares.ArduPlane);
+
+    GeometryFeature homeRoute = HomeRoute(map);
+    Assert.True(Assert.IsType<Mapsui.MRect>(homeRoute.Extent).Width > 10_000_000);
+    Assert.Equal(PenStyle.Solid, LineStyle(homeRoute));
+  }
+
+  [AvaloniaFact]
+  public void Nearby_home_closing_route_remains_dashed() {
+    var map = new FlightPlannerMap();
+    map.SetHome(50.3440, 30.8940, 100);
+    map.SetWaypoints(KyivWaypoints(3), 50, 80, Firmwares.ArduPlane);
+
+    Assert.Equal(PenStyle.Dash, LineStyle(HomeRoute(map)));
+  }
+
+  private static GeometryFeature HomeRoute(FlightPlannerMap map) {
+    GeometryFeature[] features = RouteLayer(map).GetFeatures().OfType<GeometryFeature>().ToArray();
+    Assert.Equal(2, features.Length);
+    return Assert.Single(features,
+        feature => Assert.Single(feature.Styles.OfType<VectorStyle>()).Line?.Width == 2);
+  }
+
+  private static PenStyle LineStyle(GeometryFeature feature) =>
+      Assert.IsType<Pen>(Assert.Single(feature.Styles.OfType<VectorStyle>()).Line).PenStyle;
+
+  private static WritableLayer RouteLayer(FlightPlannerMap map) =>
+      Assert.IsAssignableFrom<WritableLayer>(
+          Assert.Single(map.Map.Layers, candidate => candidate.Name == "Route"));
+
+  private static IReadOnlyList<(
+      int Seq, double Lat, double Lng, ushort Cmd, double P1, double P2, double P3, double P4)>
+      KyivWaypoints(int count) => new[] {
+        Waypoint(0, 50.3443012, 30.8947693),
+        Waypoint(1, 50.3475125, 30.8815415),
+        Waypoint(2, 50.3468588, 30.8318016),
+      }.Take(count).ToArray();
+
+  private static (
+      int Seq, double Lat, double Lng, ushort Cmd, double P1, double P2, double P3, double P4)
+      Waypoint(int seq, double lat, double lng) =>
+      (seq, lat, lng, (ushort)MAVLink.MAV_CMD.WAYPOINT, 0, 0, 0, 0);
+}

Porting/STATUS.md

@@ -2,6 +2,33 @@
 
 Updated: **2026-08-31**.
 
+## Flight Planner waypoint viewport stability
+
+- Dedicated branch `fix/flight-planner-waypoint-viewport-stability` starts from merged `master`
+  `fb7896112`. Commit `788d49d32` preserves an already initialized Flight Planner viewport across
+  waypoint redraws; commit `27a4a899a` adds the SFO-home/Kyiv-mission regression and official
+  closing-route style checks; reviewer follow-up `cd13dfbfd` exercises the deferred repair ordering.
+- `SetWaypoints` snapshots centre, resolution and rotation only after the planner has established a
+  valid viewport. It restores an inline redraw mutation immediately and posts one version-gated
+  restore for an extent-reactive mutation queued by the same redraw. Initial startup and first-point
+  centring remain unchanged. The official `last -> home -> first` route is still rendered: a distant
+  route remains solid and a route whose two home legs are both under 5 km remains dashed.
+- Behavior, integration and test reviewers approve exact HEAD `cd13dfbfd`. The focused
+  `FlightPlannerViewportTests` pass **3/3**, and `PlannerPortParityTests` pass **59/59**.
+  `dotnet build MissionPlanner.csproj -c Release -m:1 --no-restore` succeeds with **0 warnings / 0
+  errors**. The complete Avalonia suite ran **1558** cases: **1557 passed** and only the existing
+  environment-sensitive `VideoSourceResolverTests.NormalizesCommonStreamSources` `/dev/video0`
+  case failed; neither the resolver nor its test changes on this branch.
+- The worktree still contains the user's five pre-existing modifications in
+  `Drivers/inf2cat.bat`, `Drivers/uninstall_drivers.bat`, `ExtLibs/Mavlink/regenerate.bat`,
+  `ExtLibs/Mavlink/updatexmls.bat` and `graphs/updatexmls.bat`; none is staged or included in these
+  commits. Claude remains disabled.
+- The currently running Debug process loaded older commit `8f63d8d1`, so it must be stopped and
+  relaunched from the repository root before manual acceptance. Keep a connected SFO home, pan Plan
+  to Kyiv, add at least three waypoints and confirm the local centre/zoom does not change; the long
+  solid closing route must remain rendered. The separately observed Flight Data bearing-axis
+  behavior while zooming remains excluded and is the next independent bug.
+
 ## Flight Data vehicle-overlay marker rendering
 
 - Dedicated branch `fix/flight-data-vehicle-overlay-rendering` starts from pulled `master`