Fix FAT M7 field regressions: static RCB authority, embedded host, navigation

IoListTestingWindow.EmbeddedEngineeringHost.cs

@@ -0,0 +1,196 @@
+using System.Runtime.CompilerServices;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Threading;
+using ArIED61850Tester.Models;
+
+namespace ArIED61850Tester;
+
+/// <summary>
+/// Hosts the proven IoListTestingWindow production workspace inside MainWindow's FAT tab.
+/// The production Window remains loaded-but-hidden so its existing session controller,
+/// auto-capture lifecycle, persistence and report-preview code stay the single FAT authority.
+/// Only its central workspace + FAT status footer are re-parented into Engineering.
+/// </summary>
+public partial class IoListTestingWindow
+{
+    private bool _engineeringEmbeddedMountQueued;
+    private bool _engineeringEmbeddedMounted;
+    private FrameworkElement? _engineeringEmbeddedSurface;
+
+    [ModuleInitializer]
+    internal static void RegisterEmbeddedEngineeringFatHost()
+    {
+        EventManager.RegisterClassHandler(
+            typeof(IoListTestingWindow),
+            FrameworkElement.LoadedEvent,
+            new RoutedEventHandler(EmbeddedEngineeringFatHost_Loaded),
+            handledEventsToo: true);
+    }
+
+    internal void PrepareForEmbeddedEngineeringHost()
+    {
+        // WPF rejects Show() when a Window is both non-activating and Maximized.
+        // The donor only exists long enough to create the proven production visual tree,
+        // so normalize it before the hidden/off-screen bootstrap and let MainWindow own size.
+        if (WindowState == WindowState.Maximized)
+            WindowState = WindowState.Normal;
+
+        ShowActivated = false;
+        ShowInTaskbar = false;
+        Opacity = 0d;
+        WindowStartupLocation = WindowStartupLocation.Manual;
+        Left = -32000d;
+        Top = -32000d;
+    }
+
+    private static void EmbeddedEngineeringFatHost_Loaded(object sender, RoutedEventArgs e)
+    {
+        if (sender is not IoListTestingWindow window ||
+            !ReferenceEquals(e.OriginalSource, window) ||
+            window._engineeringEmbeddedMounted ||
+            window._engineeringEmbeddedMountQueued ||
+            window.Owner is not MainWindow owner ||
+            !owner.ProductionFatTabReady)
+        {
+            return;
+        }
+
+        window._engineeringEmbeddedMountQueued = true;
+
+        // MainWindow's legacy launcher still calls Show() on this Window. Make that bootstrap
+        // surface invisible immediately; the actual production visual is moved into Engineering
+        // on the next Loaded-priority dispatcher turn, before ContextIdle command-panel work.
+        window.PrepareForEmbeddedEngineeringHost();
+
+        window.Dispatcher.BeginInvoke(
+            DispatcherPriority.Loaded,
+            new Action(() => window.TryMountIntoEngineering(owner)));
+    }
+
+    private void TryMountIntoEngineering(MainWindow owner)
+    {
+        _engineeringEmbeddedMountQueued = false;
+        if (_engineeringEmbeddedMounted || !IsLoaded || !ReferenceEquals(Owner, owner) || !owner.ProductionFatTabReady)
+            return;
+
+        try
+        {
+            EnsureProductionFatPresentationForEmbeddedHost();
+            DisableLegacyEmbeddedCommandPanel();
+            var surface = DetachProductionFatCentralWorkspace();
+            if (surface == null)
+                return;
+
+            _engineeringEmbeddedSurface = surface;
+            _engineeringEmbeddedMounted = owner.MountProductionFatWorkspace(this, surface);
+            if (!_engineeringEmbeddedMounted)
+                return;
+
+            // The central FAT view now belongs to MainWindow. Keep this Window loaded and
+            // hidden because existing controller/session/event code is intentionally reused.
+            Hide();
+        }
+        catch (Exception ex)
+        {
+            Opacity = 1d;
+            ShowInTaskbar = true;
+            ShowActivated = true;
+            MessageBox.Show(
+                owner,
+                $"ARSAS could not embed the production FAT workspace. The standalone FAT window will remain available.\n\n{ex.Message}",
+                "FAT workspace host",
+                MessageBoxButton.OK,
+                MessageBoxImage.Warning);
+        }
+    }
+
+    private void EnsureProductionFatPresentationForEmbeddedHost()
+    {
+        // P1 normally installs this during Loaded. Calling it explicitly is safe/idempotent
+        // and guarantees the first embedded frame is the same V2 FAT grid as the old Window.
+        InstallFatV2WorkspaceUx();
+
+        // PrintPreview historically installs from OnContentRendered. The bootstrap Window is
+        // intentionally transparent, so install the exact same production preview explicitly
+        // before the central workspace is detached. This preserves full-center mode switching.
+        if (!_printPreviewInstalled)
+        {
+            InstallPerIedPrintPreview();
+            PropertyChanged += PrintPreviewWindow_PropertyChanged;
+            Session.PropertyChanged += PrintPreviewSession_PropertyChanged;
+            Closed += PrintPreviewWindow_Closed;
+            _printPreviewInstalled = true;
+        }
+
+        // The embedded center already declares WorkspacePreviewToggle in XAML. Make that
+        // visible button the production toggle authority instead of the hidden Window header.
+        if (WorkspacePreviewToggle != null)
+            _printPreviewToggle = WorkspacePreviewToggle;
+    }
+
+    private void DisableLegacyEmbeddedCommandPanel()
+    {
+        // Engineering already owns one shared Command Dock. Prevent the old FAT window's
+        // duplicate command panel from being created/refreshed while embedded. A non-null
+        // sentinel makes the queued legacy installer return immediately; null row/summary
+        // references make its queued refresh a no-op. No command runtime semantics change.
+        DetachFatCommandDevice();
+        if (_fatCommandPanelShell?.Parent is Grid existingHost)
+        {
+            var row = Grid.GetRow(_fatCommandPanelShell);
+            existingHost.Children.Remove(_fatCommandPanelShell);
+            if (row >= 0 && row < existingHost.RowDefinitions.Count)
+                existingHost.RowDefinitions[row].Height = new GridLength(0);
+            if (row - 1 >= 0 && row - 1 < existingHost.RowDefinitions.Count)
+                existingHost.RowDefinitions[row - 1].Height = new GridLength(0);
+        }
+
+        _fatCommandPanelShell ??= new Border { Visibility = Visibility.Collapsed };
+        _fatCommandRows = null;
+        _fatCommandSummary = null;
+        _fatCommandEmptyState = null;
+    }
+
+    private FrameworkElement? DetachProductionFatCentralWorkspace()
+    {
+        if (Content is not Grid root)
+            return null;
+
+        var middle = root.Children
+            .OfType<Grid>()
+            .FirstOrDefault(child => Grid.GetRow(child) == 2);
+        var workspaceBorder = middle?.Children
+            .OfType<Border>()
+            .FirstOrDefault(child => Grid.GetColumn(child) == 2);
+        if (middle == null || workspaceBorder == null)
+            return null;
+
+        var footer = root.Children
+            .OfType<Border>()
+            .FirstOrDefault(child => Grid.GetRow(child) == 4);
+
+        middle.Children.Remove(workspaceBorder);
+        if (footer != null)
+            root.Children.Remove(footer);
+
+        var host = new Grid
+        {
+            DataContext = this,
+            Margin = new Thickness(0)
+        };
+        host.RowDefinitions.Add(new RowDefinition { Height = new GridLength(1, GridUnitType.Star) });
+        if (footer != null)
+            host.RowDefinitions.Add(new RowDefinition { Height = GridLength.Auto });
+
+        Grid.SetRow(workspaceBorder, 0);
+        host.Children.Add(workspaceBorder);
+        if (footer != null)
+        {
+            Grid.SetRow(footer, 1);
+            host.Children.Add(footer);
+        }
+
+        return host;
+    }
+}

IoListTestingWindow.xaml.cs

@@ -119,18 +119,28 @@ private void SetAddingFatIeds(bool value)
 
     private async void StartSession_Click(object sender, RoutedEventArgs e)
     {
-        var selectedIed = SelectedIed;
-        if (selectedIed?.IsPreparing == true)
+        // M4 freezes both the IED owner and exact evidence scope before any asynchronous
+        // Engineering preparation. Explorer navigation may continue, but it cannot redirect
+        // this transaction or silently widen the production capture scope.
+        var requestedIed = SelectedIed;
+        if (requestedIed?.IsPreparing == true)
             return;
 
-        var preflight = IoTestSessionPreflight.Validate(selectedIed);
-        if (!preflight.Succeeded)
+        IoFatCaptureTargetLease captureLease;
+        try
+        {
+            captureLease = IoFatProductionControllerAdapter.LatchStartTarget(Project, requestedIed);
+        }
+        catch (InvalidOperationException ex)
         {
-            ShowActionResult(preflight, "FAT session scope is not ready");
+            ShowActionResult(
+                IoTestSessionActionResult.Failure(ex.Message),
+                "FAT session scope is not ready");
             return;
         }
 
-        PreparationStatusText = $"Connecting {selectedIed!.IedName} · {selectedIed.IpAddress}:102";
+        var selectedIed = captureLease.Ied;
+        PreparationStatusText = $"Connecting {selectedIed.IedName} · {selectedIed.IpAddress}:102";
         RaisePreparationProperties();
         try
         {
@@ -155,7 +165,10 @@ private async void StartSession_Click(object sender, RoutedEventArgs e)
                 }
             }
 
-            var result = Session.Start(selectedIed);
+            // Revalidate the frozen identity/configuration only after Engineering has
+            // completed connection preparation. The adapter delegates to the unchanged
+            // production session controller, which remains the sole evidence writer.
+            var result = IoFatProductionControllerAdapter.StartLatched(Project, Session, captureLease);
             ShowActionResult(result, "FAT evidence session could not start");
             RaiseStatusProperties();
             if (result.Succeeded)
@@ -187,23 +200,28 @@ private async void StartSession_Click(object sender, RoutedEventArgs e)
 
     private void PauseSession_Click(object sender, RoutedEventArgs e)
     {
-        var result = Session.Pause();
+        var targetIed = SelectedIed;
+        var result = Session.Pause(targetIed);
         ShowActionResult(result, "FAT session could not pause");
         if (result.Succeeded)
             Storage?.SaveNow();
     }
 
     private void ResumeSession_Click(object sender, RoutedEventArgs e)
     {
-        var result = Session.Resume();
+        // Continue is explicitly IED-targeted. A later Explorer change cannot make the
+        // production controller rebind this active evidence session to another device.
+        var targetIed = SelectedIed;
+        var result = Session.Resume(targetIed);
         ShowActionResult(result, "FAT session could not resume");
         if (result.Succeeded)
             Storage?.ScheduleSave();
     }
 
     private void StopSession_Click(object sender, RoutedEventArgs e)
     {
-        var result = Session.Stop();
+        var targetIed = SelectedIed;
+        var result = Session.Stop(targetIed);
         ShowActionResult(result, "FAT session could not stop");
         if (result.Succeeded)
             Storage?.SaveNow();

MainWindow.IoTesting.cs

@@ -494,6 +494,8 @@ private Task ShowIoTestingWorkspaceAsync(IoTestWorkspaceLaunchResult launch, int
         var controller = launch.Session;
         var persistence = launch.Workspace;
         var window = new IoListTestingWindow(launch.Project, controller, persistence) { Owner = this };
+        if (ProductionFatTabReady)
+            window.PrepareForEmbeddedEngineeringHost();
         RegisterLoadedIoFatWindow(window);
         _activeIoTestSessionController = controller;
         Interlocked.Exchange(ref _ioTestObservationSequence, DateTime.UtcNow.Ticks);
@@ -525,7 +527,8 @@ void WindowClosed(object? sender, EventArgs args)
         }
 
         window.Closed += WindowClosed;
-        Hide();
+        if (!ProductionFatTabReady)
+            Hide();
         window.Show();
         return Task.CompletedTask;
     }

MainWindow.NativeFatWorkspace.cs

@@ -0,0 +1,28 @@
+using System;
+using System.Windows.Threading;
+
+namespace ArIED61850Tester;
+
+/// <summary>
+/// M7 compatibility bridge for the canonical seventh Engineering destination.
+///
+/// MainWindow.xaml owns the FAT tab and navigation button. Production FAT is mounted
+/// into that permanent XAML slot by MainWindow.ProductionFatTab.cs. This file deliberately
+/// owns no FAT rows, capture commands, evidence state, persistence, preview, export, or timers.
+/// It retains only the shared slot index and a deferred navigation-geometry refresh used by
+/// the canonical MainWindow shell.
+/// </summary>
+public partial class MainWindow
+{
+    private const int NativeFatWorkspaceIndex = 6;
+
+    private void QueueNativeFatNavigationGeometry()
+    {
+        if (!IsLoaded)
+            return;
+
+        Dispatcher.BeginInvoke(
+            DispatcherPriority.ApplicationIdle,
+            new Action(() => UpdateNavigationVisuals(MainTabs.SelectedIndex, animate: false)));
+    }
+}

MainWindow.NavigationLayoutFix.cs

@@ -10,7 +10,7 @@ namespace ArIED61850Tester;
 /// <summary>
 /// Owns the responsive geometry of the MainWindow workflow header.
 ///
-/// The original XAML used a 760 px shell split into six equal columns while the
+/// The original XAML used a 760 px shell split into seven equal columns while the
 /// selection pill moved in hard-coded 150 px steps. That was barely large enough for
 /// short labels and clipped "IEC 61850 Explorer" / "GOOSE Subscriber" once the center
 /// workspace switch and live connection/status chips were also present. This behavior
@@ -93,7 +93,7 @@ private static void OnMainWindowButtonClick(object sender, RoutedEventArgs e)
         if (sender is not MainWindow window || e.Source is not Button button)
             return;
 
-        if (button.Name is not ("NavExplorerButton" or "NavLiveButton" or "NavEventsButton" or "NavAlarmButton" or "NavGooseButton" or "NavDiagnosticsButton"))
+        if (button.Name is not ("NavExplorerButton" or "NavLiveButton" or "NavEventsButton" or "NavAlarmButton" or "NavGooseButton" or "NavDiagnosticsButton" or "NavNativeFatButton"))
             return;
 
         // A repeated click on the already-selected tab does not raise SelectionChanged,
@@ -195,7 +195,8 @@ private static void ApplyResponsiveLayout(MainWindow window)
             window.FindName("NavEventsButton") as Button,
             window.FindName("NavAlarmButton") as Button,
             window.FindName("NavGooseButton") as Button,
-            window.FindName("NavDiagnosticsButton") as Button
+            window.FindName("NavDiagnosticsButton") as Button,
+            window.FindName("NavNativeFatButton") as Button
         ];
 
     private static void UpdatePillGeometry(MainWindow window, double shellWidth)
@@ -204,9 +205,9 @@ private static void UpdatePillGeometry(MainWindow window, double shellWidth)
             return;
 
         // Border padding owns 10 px horizontally. The nav grid itself is divided into
-        // six equal star columns, so this is the exact width used by each button cell.
+        // seven equal star columns, so this is the exact width used by each button cell.
         var contentWidth = Math.Max(0d, shellWidth - 10d);
-        var cellWidth = contentWidth / 6d;
+        var cellWidth = contentWidth / 7d;
         pill.Width = Math.Max(1d, cellWidth - 2d);
         pill.Height = 36;
         pill.HorizontalAlignment = HorizontalAlignment.Left;
@@ -279,8 +280,8 @@ private static void PositionPill(MainWindow window, bool animate)
         if (contentWidth <= 0d)
             contentWidth = Math.Max(0d, shell.Width - shell.Padding.Left - shell.Padding.Right);
 
-        var cellWidth = contentWidth / 6d;
-        var target = Math.Clamp(tabs.SelectedIndex, 0, 5) * cellWidth;
+        var cellWidth = contentWidth / 7d;
+        var target = Math.Clamp(tabs.SelectedIndex, 0, 6) * cellWidth;
         pill.Width = Math.Max(1d, cellWidth - 2d);
 
         translate.BeginAnimation(TranslateTransform.XProperty, null);