fix(angle-calibration): keep one calibration across every panel

Angle Calibration is a single profile-wide setting that Gyro Mouse,
Trackpad Mouse, Joystick Mouse, both Flick Sticks and the Flick Turn
bind all read, and each panel keeps its own cached copy of it. Those
copies had drifted apart.

Editing RWC in Real World Calibration mode wrote the new value to the
profile but never recomputed the panel's own Counts. The panel kept
showing the pre-edit Counts, and switching to Counts mode afterwards
re-derived RWC from that stale number, silently reverting the edit that
had just been made. The Flick Turn panel already did this correctly;
the shared panel now does the same.

A Game Calibration Preset names an RWC and nothing else, so picking one
now sets RWC and leaves In-Game Sensitivity exactly as the player set
it, in both modes. From Counts mode that means Counts moves to whatever
reproduces the preset's RWC at that sensitivity, rather than the
sensitivity being rewritten to fit the Counts total.

The Flick Turn panel's write reached the flick sticks and the camera
turn outputs but skipped Gyro Mouse, so calibrating from there left
gyro aiming on the old value until the profile was reloaded. It also
never listened for calibration changed elsewhere, so its cached copy
went stale and was written back over them on its next edit. Both are
fixed, and every panel now follows the profile for as long as it is on
screen: CalibrationModeControl attaches on Loaded and detaches on
Unloaded, which also ends the subscriptions that used to be held for
the life of the profile, one per panel rebuild.

Two ways an untouched panel could corrupt the calibration by itself are
closed as well. HandyControl's NumericUpDown fires ValueChanged with
its Minimum while initialising, and the Flick Turn panel's master field
did not guard against that init write, so opening the tab could push a
zeroed RWC into the profile; the guard now covers every bound field,
and re-arms per control rather than once per ViewModel. The mode's
hidden field also keeps a live two-way binding and clamps whatever it
is handed to its own Maximum before writing it back, so Counts totals
past a million came back truncated from a field that was not even on
screen; all three fields now share one range.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01QtStWXc9oKZRmxXfEUzEfg

Author: HelloHim

DS4MapperTest/Common/ICalibrationPanelViewModel.cs

@@ -0,0 +1,28 @@
+namespace DS4MapperTest.Common
+{
+    // Angle Calibration is one profile-wide setting (Profile.CalibMode/CalibRwc/
+    // CalibInGameSens/CalibCounts/CalibPresetName) surfaced by every panel that shows
+    // CalibrationModeControl: Gyro, Stick/Trackpad Mouse, Stick/Touchpad Flick Stick,
+    // Hybrid Aim and the Flick Turn output binding. Each of those panels caches the
+    // values in its own ViewModel, so a panel has to listen to the profile while it is
+    // on screen or it would show, and then write back, numbers another panel has since
+    // replaced.
+    //
+    // CalibrationModeControl drives this from its own Loaded/Unloaded, so the listening
+    // lasts exactly as long as the panel is in the visual tree instead of for the life
+    // of the profile. Attach is expected to pull the current profile values back in, and
+    // both calls are reference counted so several controls can share one ViewModel.
+    public interface ICalibrationPanelViewModel
+    {
+        void AttachProfileCalibEvents();
+        void DetachProfileCalibEvents();
+
+        // Called by the control before its own fields go live. HandyControl's NumericUpDown
+        // fires ValueChanged(Minimum) while it initialises, before the binding has handed it
+        // the real number, so a ViewModel has to ignore writes until the control settles or
+        // that init write lands in the profile as a zeroed calibration. A ViewModel that
+        // outlives its control -- a stick mode panel rebuilt when the user switches modes
+        // and back, for example -- gets a fresh control and so needs a fresh window here.
+        void BeginPanelInit();
+    }
+}

DS4MapperTest/ViewModels/ButtonActionEditViewModel.cs

@@ -16,7 +16,7 @@
 
 namespace DS4MapperTest.ViewModels
 {
-    public class ButtonActionEditViewModel : INotifyPropertyChanged
+    public class ButtonActionEditViewModel : INotifyPropertyChanged, ICalibrationPanelViewModel
     {
         public event PropertyChangedEventHandler PropertyChanged;
         public enum ActionComboBoxTypes
@@ -422,9 +422,11 @@ public GameCalibPreset SelectedCameraTurnPreset
                 _applyingCameraTurnPreset = true;
                 if (IsCountsMode)
                 {
-                    // Counts is this mode's fixed master: keep it as-is and let sensitivity
-                    // move to whatever value reproduces the preset's RWC at that Counts.
-                    if (CameraTurnCounts360 > 0.0) CameraTurnInGameSens = next.RWC * 360.0 / CameraTurnCounts360;
+                    // A preset only ever names an RWC, and In-Game Sensitivity is the player's
+                    // own game setting, so it stays exactly as they had it in either mode.
+                    // From Counts mode that means moving Counts to whatever reproduces the
+                    // preset's RWC at that sensitivity.
+                    if (CameraTurnInGameSens > 0.0) CameraTurnCounts360 = next.RWC * 360.0 / CameraTurnInGameSens;
                 }
                 else
                 {
@@ -529,6 +531,11 @@ public double MasterCalibrationValue
             get => IsCountsMode ? CameraTurnCounts360 : CameraTurnRWC;
             set
             {
+                // Same reason CameraTurnInGameSens and the preset check it: HandyControl's
+                // NumericUpDown fires ValueChanged(Minimum) while it initialises, before the
+                // binding has handed it the real number. Unguarded, that init write pushed a
+                // zeroed RWC/Counts straight into the profile the moment this panel appeared.
+                if (!_cameraTurnReady) return;
                 if (IsCountsMode) CameraTurnCounts360 = value;
                 else CameraTurnRWC = value;
             }
@@ -564,6 +571,78 @@ private void RaiseCalibModePropertyChanges()
             PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(DerivedValue)));
         }
 
+        // Reference counted for the same reason as GyroCalibrationViewModel's copy: the
+        // Angle Calibration panel attaches while it is on screen and detaches when it goes,
+        // so this editor never holds a subscription to a profile that outlives it.
+        private int _calibPanelAttachCount = 0;
+
+        public void AttachProfileCalibEvents()
+        {
+            _calibPanelAttachCount++;
+            if (_calibPanelAttachCount == 1)
+            {
+                mapper.ActionProfile.CalibModeChanged += ActionProfile_CalibModeChanged;
+                mapper.ActionProfile.CalibPresetNameChanged += ActionProfile_CalibPresetNameChanged;
+                mapper.ActionProfile.CalibRwcChanged += ActionProfile_CalibValuesChanged;
+                mapper.ActionProfile.CalibInGameSensChanged += ActionProfile_CalibValuesChanged;
+                mapper.ActionProfile.CalibCountsChanged += ActionProfile_CalibValuesChanged;
+            }
+
+            // Calibration is one profile-wide setting, so whatever another panel left in the
+            // profile is the current truth. BeginPanelInit reloads it and holds the fields
+            // read-only until the freshly built control has finished initialising.
+            BeginPanelInit();
+        }
+
+        // Reloads the profile-wide calibration and keeps this panel's fields from writing
+        // back until the control settles; see ICalibrationPanelViewModel.BeginPanelInit.
+        public void BeginPanelInit()
+        {
+            _cameraTurnReady = false;
+            LoadCameraTurnCalibFromProfile(updateSelectedSlot: true);
+            RaiseCameraTurnCalibPropertiesChanged();
+            System.Windows.Application.Current.Dispatcher.BeginInvoke(
+                System.Windows.Threading.DispatcherPriority.Background,
+                new Action(() =>
+                {
+                    LoadCameraTurnCalibFromProfile(updateSelectedSlot: true);
+                    RaiseCameraTurnCalibPropertiesChanged();
+                    System.Windows.Application.Current.Dispatcher.BeginInvoke(
+                        System.Windows.Threading.DispatcherPriority.ApplicationIdle,
+                        new Action(() =>
+                        {
+                            LoadCameraTurnCalibFromProfile(updateSelectedSlot: true);
+                            _cameraTurnReady = true;
+                            RaiseCameraTurnCalibPropertiesChanged();
+                        }));
+                }));
+        }
+
+        public void DetachProfileCalibEvents()
+        {
+            if (_calibPanelAttachCount == 0) return;
+            _calibPanelAttachCount--;
+            if (_calibPanelAttachCount > 0) return;
+
+            mapper.ActionProfile.CalibModeChanged -= ActionProfile_CalibModeChanged;
+            mapper.ActionProfile.CalibPresetNameChanged -= ActionProfile_CalibPresetNameChanged;
+            mapper.ActionProfile.CalibRwcChanged -= ActionProfile_CalibValuesChanged;
+            mapper.ActionProfile.CalibInGameSensChanged -= ActionProfile_CalibValuesChanged;
+            mapper.ActionProfile.CalibCountsChanged -= ActionProfile_CalibValuesChanged;
+        }
+
+        // A gyro, stick or touchpad panel changed the profile-wide calibration. Take those
+        // values as they are: this editor shows the same setting, and its cached copy would
+        // otherwise be written back over them the next time anything here is edited.
+        // Skipped while this ViewModel is the one writing the profile, since its own
+        // multi-field write leaves the profile briefly inconsistent between steps.
+        private void ActionProfile_CalibValuesChanged(object sender, EventArgs e)
+        {
+            if (_syncingProfileCalib) return;
+            LoadCameraTurnCalibFromProfile(updateSelectedSlot: true);
+            RaiseCameraTurnCalibPropertiesChanged();
+        }
+
         private void ActionProfile_CalibModeChanged(object sender, EventArgs e)
         {
             RaiseCalibModePropertyChanges();
@@ -602,24 +681,7 @@ public bool ShowCameraTurnOptions
                 showCameraTurnOptions = value;
                 if (value)
                 {
-                    _cameraTurnReady = false;
-                    LoadCameraTurnCalibFromProfile(updateSelectedSlot: true);
-                    RaiseCameraTurnCalibPropertiesChanged();
-                    System.Windows.Application.Current.Dispatcher.BeginInvoke(
-                        System.Windows.Threading.DispatcherPriority.Background,
-                        new Action(() =>
-                        {
-                            LoadCameraTurnCalibFromProfile(updateSelectedSlot: true);
-                            RaiseCameraTurnCalibPropertiesChanged();
-                            System.Windows.Application.Current.Dispatcher.BeginInvoke(
-                                System.Windows.Threading.DispatcherPriority.ApplicationIdle,
-                                new Action(() =>
-                                {
-                                    LoadCameraTurnCalibFromProfile(updateSelectedSlot: true);
-                                    _cameraTurnReady = true;
-                                    RaiseCameraTurnCalibPropertiesChanged();
-                                }));
-                        }));
+                    BeginPanelInit();
                 }
                 ShowCameraTurnOptionsChanged?.Invoke(this, EventArgs.Empty);
             }
@@ -730,8 +792,9 @@ public ButtonActionEditViewModel(Mapper mapper, ButtonAction currentAction, Acti
                 CameraTurnRWC = cameraTurnCalculatedRWC;
             });
 
-            mapper.ActionProfile.CalibModeChanged += ActionProfile_CalibModeChanged;
-            mapper.ActionProfile.CalibPresetNameChanged += ActionProfile_CalibPresetNameChanged;
+            // The calibration subscriptions belong to the Angle Calibration panel's own
+            // Loaded/Unloaded (see AttachProfileCalibEvents), so this editor follows the
+            // profile-wide values exactly while that panel is on screen.
             mapper.ActionProfile.OutputGamepadSettings.OutputGamepadChanged += OutputGamepadSettings_OutputGamepadChanged;
 
             SetupEvents();
@@ -1863,20 +1926,39 @@ private void UpdateCameraTurnPresetFromCurrentRwc()
             mapper.ActionProfile.CalibPresetName = matchedName;
         }
 
+        private bool _syncingProfileCalib = false;
+
         private void SyncCalibFromCameraTurnToProfile()
         {
             double counts = cameraTurnCounts360;
             double inGameSens = cameraTurnInGameSens;
             double rwc = inGameSens > 0.0 ? inGameSens * counts / 360.0 : 0.0;
-            mapper.ActionProfile.CalibCounts = counts;
-            mapper.ActionProfile.CalibInGameSens = inGameSens;
-            mapper.ActionProfile.CalibRwc = rwc;
+            // Guards ActionProfile_CalibValuesChanged against this instance's own writes:
+            // the three profile fields are written one at a time, so reloading from the
+            // profile between them would pull back a half-updated calibration.
+            _syncingProfileCalib = true;
+            try
+            {
+                mapper.ActionProfile.CalibCounts = counts;
+                mapper.ActionProfile.CalibInGameSens = inGameSens;
+                mapper.ActionProfile.CalibRwc = rwc;
+            }
+            finally { _syncingProfileCalib = false; }
             mapper.ProcessMappingChangeAction(() =>
             {
                 foreach (var set in mapper.ActionProfile.ActionSets)
                     foreach (var layer in set.ActionLayers)
                         foreach (var mapAction in layer.normalActionDict.Values)
                         {
+                            // Gyro Mouse reads the same profile calibration as the flick stick
+                            // and camera turn outputs, so an edit made from this panel has to
+                            // reach its live params too; leaving it out kept gyro aiming on the
+                            // pre-edit calibration until the profile was reloaded.
+                            if (mapAction is GyroMouse gyroMouse)
+                            {
+                                gyroMouse.mouseParams.realWorldCalibration = rwc;
+                                gyroMouse.mouseParams.inGameSens = inGameSens;
+                            }
                             if (mapAction is ButtonAction ba)
                                 foreach (var func in ba.ActionFuncs)
                                     foreach (var data in func.OutputActions)