P0: repair FAT relay-bench runtime latency

FaultRecordWindow.DownloadedSelectionBinding.cs

@@ -0,0 +1,199 @@
+using System.ComponentModel;
+using System.Runtime.CompilerServices;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Controls.Primitives;
+using System.Windows.Data;
+using System.Windows.Threading;
+
+namespace ArIED61850Tester;
+
+/// <summary>
+/// Single visual/state authority for downloaded COMTRADE re-download selection.
+/// The legacy row model intentionally rejects IsSelected for already-downloaded records,
+/// so a notifying proxy owns the native WPF CheckBox while the existing staged-overwrite
+/// HashSet remains the transfer authority. No synthetic glyph or manual IsChecked paint is used.
+/// </summary>
+public partial class FaultRecordWindow
+{
+    private readonly Dictionary<string, DownloadedSelectionProxy> _downloadedSelectionProxies =
+        new(StringComparer.OrdinalIgnoreCase);
+    private bool _downloadedSelectionBindingInstalled;
+
+    [ModuleInitializer]
+    internal static void RegisterDownloadedSelectionBindingAuthority()
+    {
+        EventManager.RegisterClassHandler(
+            typeof(FaultRecordWindow),
+            FrameworkElement.LoadedEvent,
+            new RoutedEventHandler(DownloadedSelectionBinding_WindowLoaded),
+            handledEventsToo: true);
+    }
+
+    private static void DownloadedSelectionBinding_WindowLoaded(object sender, RoutedEventArgs e)
+    {
+        if (sender is not FaultRecordWindow window || window._downloadedSelectionBindingInstalled)
+            return;
+
+        // Install after the normal window Loaded path has completed. This intentionally
+        // removes the old manual PreviewMouseDown checkbox toggle and lets WPF TwoWay binding
+        // own the native check mark from this point forward.
+        window.Dispatcher.BeginInvoke(
+            DispatcherPriority.ContextIdle,
+            new Action(window.InstallDownloadedSelectionBindingAuthority));
+    }
+
+    private void InstallDownloadedSelectionBindingAuthority()
+    {
+        if (_downloadedSelectionBindingInstalled)
+            return;
+
+        _downloadedSelectionBindingInstalled = true;
+        FaultRecordsGrid.PreviewMouseLeftButtonDown -= RedownloadGrid_PreviewMouseLeftButtonDown;
+        FaultRecordsGrid.LoadingRow += DownloadedSelectionBinding_LoadingRow;
+        Closed += DownloadedSelectionBinding_Closed;
+
+        RebindVisibleDownloadedSelectionRows();
+    }
+
+    private void DownloadedSelectionBinding_Closed(object? sender, EventArgs e)
+    {
+        FaultRecordsGrid.LoadingRow -= DownloadedSelectionBinding_LoadingRow;
+        Closed -= DownloadedSelectionBinding_Closed;
+        _downloadedSelectionProxies.Clear();
+    }
+
+    private void DownloadedSelectionBinding_LoadingRow(object? sender, DataGridRowEventArgs e)
+    {
+        // RedownloadUx.LoadingRow was registered first and performs the legacy setup at
+        // DispatcherPriority.Loaded. Re-apply the authoritative binding one turn later.
+        Dispatcher.BeginInvoke(
+            DispatcherPriority.ContextIdle,
+            new Action(() => BindDownloadedSelectionRow(e.Row)));
+    }
+
+    private void RebindVisibleDownloadedSelectionRows()
+    {
+        FaultRecordsGrid.UpdateLayout();
+        foreach (var row in Records)
+        {
+            if (FaultRecordsGrid.ItemContainerGenerator.ContainerFromItem(row) is DataGridRow gridRow)
+                BindDownloadedSelectionRow(gridRow);
+        }
+    }
+
+    private void BindDownloadedSelectionRow(DataGridRow gridRow)
+    {
+        if (gridRow.DataContext is not FaultRecordRow row ||
+            row.LocalState != FaultRecordLocalState.Downloaded)
+        {
+            return;
+        }
+
+        var checkBox = FindVisualDescendants<CheckBox>(gridRow).FirstOrDefault();
+        if (checkBox == null)
+            return;
+
+        var proxy = GetDownloadedSelectionProxy(row);
+
+        // Remove every legacy manual checkbox writer. The native CheckBox gets one TwoWay
+        // binding and therefore its visual tick can no longer diverge from transfer state.
+        checkBox.Click -= DownloadedRecordCheckBox_Click;
+        BindingOperations.ClearBinding(checkBox, ToggleButton.IsCheckedProperty);
+        BindingOperations.ClearBinding(checkBox, UIElement.IsEnabledProperty);
+        BindingOperations.SetBinding(
+            checkBox,
+            ToggleButton.IsCheckedProperty,
+            new Binding(nameof(DownloadedSelectionProxy.IsSelected))
+            {
+                Source = proxy,
+                Mode = BindingMode.TwoWay,
+                UpdateSourceTrigger = UpdateSourceTrigger.PropertyChanged
+            });
+        checkBox.IsEnabled = row.Record.Files.Count > 0 && !IsBusy;
+        checkBox.ToolTip = "Already downloaded. Check to download again and safely overwrite the existing local copy.";
+    }
+
+    private DownloadedSelectionProxy GetDownloadedSelectionProxy(FaultRecordRow row)
+    {
+        var recordId = row.Record.RecordId;
+        if (_downloadedSelectionProxies.TryGetValue(recordId, out var existing))
+            return existing;
+
+        var proxy = new DownloadedSelectionProxy(
+            _redownloadSelections.Contains(recordId),
+            selected => DownloadedSelectionProxy_Changed(row, selected));
+        _downloadedSelectionProxies[recordId] = proxy;
+        return proxy;
+    }
+
+    private void DownloadedSelectionProxy_Changed(FaultRecordRow row, bool selected)
+    {
+        if (selected)
+            _redownloadSelections.Add(row.Record.RecordId);
+        else
+            _redownloadSelections.Remove(row.Record.RecordId);
+
+        UpdateSmartSelectionUi();
+        RefreshFaultRecordHeaderSelection();
+    }
+
+    private bool IsDownloadedTransferSelected(FaultRecordRow row)
+        => _downloadedSelectionProxies.TryGetValue(row.Record.RecordId, out var proxy)
+            ? proxy.IsSelected
+            : _redownloadSelections.Contains(row.Record.RecordId);
+
+    private void SetDownloadedTransferSelection(FaultRecordRow row, bool selected)
+    {
+        if (row.LocalState != FaultRecordLocalState.Downloaded)
+            return;
+
+        var proxy = GetDownloadedSelectionProxy(row);
+        proxy.IsSelected = selected;
+
+        // If the state was already equal, the proxy intentionally emits no notification;
+        // still synchronize the backing set because scan/local-state transitions can rebuild it.
+        if (selected)
+            _redownloadSelections.Add(row.Record.RecordId);
+        else
+            _redownloadSelections.Remove(row.Record.RecordId);
+
+        Dispatcher.BeginInvoke(
+            DispatcherPriority.ContextIdle,
+            new Action(() =>
+            {
+                ConfigureRecordRow(row); // preserve legacy enabled/tooltip semantics
+                if (FaultRecordsGrid.ItemContainerGenerator.ContainerFromItem(row) is DataGridRow gridRow)
+                    BindDownloadedSelectionRow(gridRow); // then restore the one authoritative binding
+                UpdateSmartSelectionUi();
+                RefreshFaultRecordHeaderSelection();
+            }));
+    }
+
+    private sealed class DownloadedSelectionProxy : INotifyPropertyChanged
+    {
+        private readonly Action<bool> _changed;
+        private bool _isSelected;
+
+        public DownloadedSelectionProxy(bool isSelected, Action<bool> changed)
+        {
+            _isSelected = isSelected;
+            _changed = changed;
+        }
+
+        public bool IsSelected
+        {
+            get => _isSelected;
+            set
+            {
+                if (_isSelected == value)
+                    return;
+                _isSelected = value;
+                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(IsSelected)));
+                _changed(value);
+            }
+        }
+
+        public event PropertyChangedEventHandler? PropertyChanged;
+    }
+}

FaultRecordWindow.HeaderSelection.cs

@@ -9,9 +9,10 @@
 namespace ArIED61850Tester;
 
 /// <summary>
-/// Adds a tri-state select-all checkbox to the fault-record Get column. Selecting all
-/// affects only rows that are currently eligible for download; clearing always clears
-/// every row so stale disabled selections cannot remain hidden.
+/// Adds a tri-state select-all checkbox to the fault-record Get column. A record with relay
+/// files is selectable whether it is a first download or an intentional re-download. Native
+/// first-download rows use FaultRecordRow.IsSelected; downloaded rows use the notifying
+/// re-download selection authority so the native WPF checkbox and transfer state cannot diverge.
 /// </summary>
 public partial class FaultRecordWindow
 {
@@ -75,7 +76,7 @@ private void EnsureFaultRecordHeaderSelection()
             VerticalAlignment = VerticalAlignment.Center,
             Cursor = Cursors.Hand,
             Focusable = true,
-            ToolTip = "Check / uncheck all downloadable fault records"
+            ToolTip = "Check / uncheck all downloadable or re-downloadable fault records"
         };
         AutomationProperties.SetName(headerCheckBox, "Toggle all downloadable fault records");
         headerCheckBox.Click += FaultRecordHeaderSelectionCheckBox_Click;
@@ -105,10 +106,26 @@ private void FaultRecordHeaderSelectionCheckBox_Click(object sender, RoutedEvent
         {
             foreach (var row in Records)
             {
-                if (target)
-                    row.IsSelected = row.CanSelectForDownload;
-                else
+                if (!HasTransferableFiles(row))
+                {
+                    row.IsSelected = false;
+                    if (row.LocalState == FaultRecordLocalState.Downloaded)
+                        SetDownloadedTransferSelection(row, false);
+                    else
+                        _redownloadSelections.Remove(row.Record.RecordId);
+                    continue;
+                }
+
+                if (row.LocalState == FaultRecordLocalState.Downloaded)
+                {
                     row.IsSelected = false;
+                    SetDownloadedTransferSelection(row, target);
+                }
+                else
+                {
+                    _redownloadSelections.Remove(row.Record.RecordId);
+                    row.IsSelected = target && row.CanSelectForDownload;
+                }
             }
         }
         finally
@@ -117,6 +134,7 @@ private void FaultRecordHeaderSelectionCheckBox_Click(object sender, RoutedEvent
         }
 
         RaiseSelectionState();
+        UpdateSmartSelectionUi();
         RefreshFaultRecordHeaderSelection();
     }
 
@@ -161,25 +179,33 @@ private void RefreshFaultRecordHeaderSelection()
         if (header == null)
             return;
 
-        var eligibleCount = Records.Count(row => row.CanSelectForDownload);
+        var eligibleCount = Records.Count(HasTransferableFiles);
         header.IsEnabled = !IsBusy && eligibleCount > 0;
         header.IsChecked = GetFaultRecordHeaderSelectionState();
     }
 
     private bool? GetFaultRecordHeaderSelectionState()
     {
-        var eligible = Records.Where(row => row.CanSelectForDownload).ToArray();
+        var eligible = Records.Where(HasTransferableFiles).ToArray();
         if (eligible.Length == 0)
             return false;
 
-        var selected = eligible.Count(row => row.IsSelected);
+        var selected = eligible.Count(IsSelectedForTransfer);
         if (selected == 0)
             return false;
         if (selected == eligible.Length)
             return true;
         return null;
     }
 
+    private static bool HasTransferableFiles(FaultRecordRow row)
+        => row.Record.Files.Count > 0;
+
+    private bool IsSelectedForTransfer(FaultRecordRow row)
+        => row.LocalState == FaultRecordLocalState.Downloaded
+            ? IsDownloadedTransferSelected(row)
+            : row.IsSelected;
+
     private void FaultRecordHeaderSelectionWindow_Closed(object? sender, EventArgs e)
     {
         PropertyChanged -= FaultRecordHeaderSelectionWindow_PropertyChanged;

FaultRecordWindow.RedownloadSelectionAuthority.cs

@@ -0,0 +1,98 @@
+using System.Runtime.CompilerServices;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Input;
+using System.Windows.Media;
+
+namespace ArIED61850Tester;
+
+/// <summary>
+/// Row-body selection authority for the fault-record grid. Native WPF CheckBoxes own checkbox
+/// clicks. This class handles only clicks on the rest of a transferable row and routes downloaded
+/// rows through the same notifying selection proxy used by the checkbox and header selection.
+/// </summary>
+public partial class FaultRecordWindow
+{
+    [ModuleInitializer]
+    internal static void RegisterRedownloadSelectionAuthority()
+    {
+        EventManager.RegisterClassHandler(
+            typeof(DataGrid),
+            UIElement.PreviewMouseLeftButtonDownEvent,
+            new MouseButtonEventHandler(RedownloadSelectionAuthority_Down),
+            handledEventsToo: true);
+    }
+
+    private static void RedownloadSelectionAuthority_Down(object sender, MouseButtonEventArgs e)
+    {
+        if (sender is not DataGrid grid ||
+            Window.GetWindow(grid) is not FaultRecordWindow window ||
+            !ReferenceEquals(grid, window.FaultRecordsGrid) ||
+            window.IsBusy ||
+            e.ChangedButton != MouseButton.Left ||
+            e.OriginalSource is not DependencyObject source)
+        {
+            return;
+        }
+
+        // Native checkbox binding owns checkbox clicks. Row-body clicks are a fast-workflow
+        // convenience and must not create a second toggle for the same pointer action.
+        if (FindRedownloadSelectionAncestor<CheckBox>(source) != null)
+            return;
+
+        if (!TryResolveTransferRow(source, out var row) || row.Record.Files.Count == 0)
+            return;
+
+        if (row.LocalState == FaultRecordLocalState.Downloaded)
+        {
+            window.SetDownloadedTransferSelection(row, !window.IsDownloadedTransferSelected(row));
+        }
+        else
+        {
+            if (!row.CanSelectForDownload)
+                return;
+            row.IsSelected = !row.IsSelected;
+        }
+
+        e.Handled = true;
+        window.UpdateSmartSelectionUi();
+        window.RefreshFaultRecordHeaderSelection();
+    }
+
+    private static bool TryResolveTransferRow(DependencyObject? source, out FaultRecordRow row)
+    {
+        row = null!;
+        var dataGridRow = FindRedownloadSelectionAncestor<DataGridRow>(source);
+        if (dataGridRow?.DataContext is not FaultRecordRow candidate)
+            return false;
+
+        row = candidate;
+        return true;
+    }
+
+    private static T? FindRedownloadSelectionAncestor<T>(DependencyObject? source)
+        where T : DependencyObject
+    {
+        var current = source;
+        while (current != null)
+        {
+            if (current is T match)
+                return match;
+
+            DependencyObject? parent = null;
+            try
+            {
+                parent = VisualTreeHelper.GetParent(current);
+            }
+            catch (InvalidOperationException)
+            {
+            }
+
+            if (parent == null && current is FrameworkElement element)
+                parent = element.Parent;
+            current = parent;
+        }
+
+        return null;
+    }
+}