@pro-gram/flux 1.6.1 → 1.6.4

package/source/EditorMixer.cs

@@ -0,0 +1,267 @@
+using System;
+using System.Globalization;
+using System.Linq;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Controls.Primitives;
+using System.Windows.Input;
+using System.Windows.Media;
+
+namespace DrumBuddy
+{
+    public sealed class StereoLevelMeter : FrameworkElement
+    {
+        private float left, right;
+        public StereoLevelMeter() { Width = 21; Height = 96; IsHitTestVisible = false; }
+        public static double Level(float sample) { return sample <= .001f ? 0 : Math.Max(0, Math.Min(1, (20 * Math.Log10(sample) + 60) / 60)); }
+        public void SetLevels(float l, float r) { left = Math.Max(0, l); right = Math.Max(0, r); InvalidateVisual(); }
+        protected override void OnRender(DrawingContext drawing)
+        {
+            base.OnRender(drawing); double width = (ActualWidth - 3) / 2, height = ActualHeight;
+            for (int channel = 0; channel < 2; channel++) {
+                double level = Level(channel == 0 ? left : right);
+                for (int segment = 0; segment < 24; segment++) {
+                    bool lit = (segment + 1) / 24.0 <= level;
+                    var color = !lit ? "#D6E1DF" : segment >= 23 ? "#B52C36" : segment >= 19 ? "#D0772C" : "#007A6B";
+                    drawing.PushOpacity(lit ? 1 : .3);
+                    drawing.DrawRectangle(WorkspaceUi.Color(color), null, new Rect(channel * (width + 3), height - (segment + 1) * height / 24, width, Math.Max(1, height / 24 - 1)));
+                    drawing.Pop();
+                }
+            }
+        }
+    }
+
+    public sealed partial class EditorView
+    {
+        private sealed class MixerStrip
+        {
+            public Border Frame;
+            public Button Name, Peak;
+            public TextBlock NameText;
+            public StereoLevelMeter Meter;
+            public Slider Gain, Pan;
+            public TextBox GainText;
+            public ToggleButton Mute, Solo;
+            public TextBlock Source;
+            public float Left, Right, Hold;
+            public DateTime HoldUntil;
+            public bool Over;
+        }
+        private DockablePane mixerPane;
+        private readonly MixerStrip[] mixerStrips = new MixerStrip[16];
+        private MixerStrip masterStrip;
+        private ScrollViewer mixerTrackScroll;
+        private ComboBox mixerMeterMode;
+        private TextBlock mixerContext;
+        private readonly ToggleButton[] headerMutes = new ToggleButton[16], headerSolos = new ToggleButton[16];
+        private readonly ComboBox[] headerLevels = new ComboBox[16];
+        private bool updatingMixer;
+        private string mixerUndoKey;
+        private DateTime mixerUndoUntil, inputMeterUntil;
+        private readonly float[] recordingMixerPeaks = new float[16];
+        private readonly float[] recordingMixerLeft = new float[16], recordingMixerRight = new float[16];
+        private int lastMixerSelection = -1;
+        public bool MixerVisible { get { return mixerPane != null && mixerPane.IsPaneVisible; } }
+        public void ToggleMixer() { ShowMixer(!MixerVisible); }
+        public void ShowMixer(bool visible)
+        {
+            mixerPane.ShowPane(visible);
+            if (visible) { if (mix != null) mix.DrainMeters(); RefreshMixerControls(); }
+        }
+        private FrameworkElement CreateMixer()
+        {
+            var root = new Grid { Margin = new Thickness(7, 0, 7, 5) };
+            root.RowDefinitions.Add(new RowDefinition { Height = GridLength.Auto }); root.RowDefinitions.Add(new RowDefinition()); root.RowDefinitions.Add(new RowDefinition { Height = GridLength.Auto });
+            var toolbar = new WrapPanel(); root.Children.Add(toolbar);
+            mixerContext = WorkspaceUi.Text("Meters", 12); mixerContext.Margin = new Thickness(0, 0, 7, 4); toolbar.Children.Add(mixerContext);
+            mixerMeterMode = new ComboBox { ItemsSource = new[] { "After fader", "Before fader" }, SelectedIndex = 0, Width = 116, MinHeight = 25, FontSize = 11, Margin = new Thickness(0, 0, 8, 4) };
+            toolbar.Children.Add(mixerMeterMode);
+            mixerMeterMode.SelectionChanged += delegate { ResetMixerMeters(); };
+            var clear = WorkspaceUi.Button("Clear peaks", delegate { ResetMixerMeters(); }); clear.MinHeight = 25; clear.FontSize = 11; clear.Padding = new Thickness(6, 2, 6, 2); toolbar.Children.Add(clear);
+            var reset = WorkspaceUi.Button("Reset mix", delegate { ResetMixer(); }); reset.MinHeight = 25; reset.FontSize = 11; reset.Padding = new Thickness(6, 2, 6, 2); toolbar.Children.Add(reset);
+            var close = WorkspaceUi.Button("Hide mixer", delegate { ShowMixer(false); }); close.MinHeight = 25; close.FontSize = 11; close.Padding = new Thickness(6, 2, 6, 2); toolbar.Children.Add(close);
+            var channels = new Grid(); channels.ColumnDefinitions.Add(new ColumnDefinition()); channels.ColumnDefinitions.Add(new ColumnDefinition { Width = new GridLength(108) }); SetRow(channels, 1); root.Children.Add(channels);
+            var trackStrips = new StackPanel { Orientation = Orientation.Horizontal };
+            for (int i = 0; i < 16; i++) { mixerStrips[i] = CreateMixerStrip(i); trackStrips.Children.Add(mixerStrips[i].Frame); }
+            mixerTrackScroll = new ScrollViewer { Content = trackStrips, HorizontalScrollBarVisibility = ScrollBarVisibility.Auto, VerticalScrollBarVisibility = ScrollBarVisibility.Disabled };
+            channels.Children.Add(mixerTrackScroll);
+            masterStrip = CreateMixerStrip(-1); SetColumn(masterStrip.Frame, 1); channels.Children.Add(masterStrip.Frame);
+            var note = WorkspaceUi.Text("File peak shows the saved source level. Faders change playback/export; recording gain is set on the input device.", 11);
+            note.Margin = new Thickness(2, 3, 2, 0); SetRow(note, 2); root.Children.Add(note);
+            return root;
+        }
+        private MixerStrip CreateMixerStrip(int index)
+        {
+            bool master = index < 0; var strip = new MixerStrip();
+            var body = new StackPanel();
+            strip.Name = WorkspaceUi.Button(master ? "MASTER" : (index + 1).ToString("00"), delegate { if (!master && !IsBusy) { track = index; UpdateSelectionText(); BuildHeaders(); DrawCanvas(); } });
+            strip.Name.FontSize = 11; strip.Name.FontWeight = FontWeights.SemiBold; strip.Name.MinHeight = 25; strip.Name.Height = 25; strip.Name.Padding = new Thickness(2); strip.Name.Margin = new Thickness(0, 0, 0, 3);
+            strip.NameText = WorkspaceUi.Text(master ? "MASTER" : (index + 1).ToString("00"), 11); strip.NameText.MaxWidth = 80; strip.NameText.TextWrapping = TextWrapping.NoWrap; strip.NameText.TextTrimming = TextTrimming.CharacterEllipsis; strip.Name.Content = strip.NameText;
+            body.Children.Add(strip.Name);
+            strip.Source = WorkspaceUi.Text(master ? "Mix output" : "File peak —", 11); strip.Source.TextWrapping = TextWrapping.NoWrap; strip.Source.TextTrimming = TextTrimming.CharacterEllipsis;
+            strip.Source.Margin = new Thickness(0, 0, 0, 3); body.Children.Add(strip.Source);
+            var level = new Grid { Height = 96 }; level.ColumnDefinitions.Add(new ColumnDefinition { Width = new GridLength(27) }); level.ColumnDefinitions.Add(new ColumnDefinition()); level.ColumnDefinitions.Add(new ColumnDefinition { Width = new GridLength(21) }); body.Children.Add(level);
+            var scale = new Canvas { Height = 96 }; level.Children.Add(scale);
+            foreach (var mark in new[] { new { Text = master ? "+12" : "+24", Top = 0.0 }, new { Text = "0 dB", Top = 96.0 * (master ? 12 : 24) / (master ? 72 : 84) - 6 }, new { Text = "−60", Top = 83.0 } }) {
+                var label = WorkspaceUi.Text(mark.Text, 11); label.FontSize = 9; Canvas.SetTop(label, Math.Max(0, mark.Top)); scale.Children.Add(label);
+            }
+            strip.Gain = new Slider { Minimum = -60, Maximum = master ? 12 : 24, Value = 0, Orientation = Orientation.Vertical, SmallChange = 1, LargeChange = 3, TickFrequency = 1, IsSnapToTickEnabled = false, ToolTip = master ? "Master mix gain: playback and export, before the listening volume" : "Track gain: playback and export; original recording unchanged", Margin = new Thickness(1, 0, 1, 0) };
+            strip.Gain.Height = 96;
+            SetColumn(strip.Gain, 1); level.Children.Add(strip.Gain);
+            strip.Meter = new StereoLevelMeter(); SetColumn(strip.Meter, 2); level.Children.Add(strip.Meter);
+            strip.Gain.ValueChanged += delegate { if (!updatingMixer) SetMixerGain(index, Math.Round(strip.Gain.Value, 1)); };
+            strip.Gain.PreviewMouseLeftButtonUp += delegate { FinishMixerGesture(); }; strip.Gain.LostKeyboardFocus += delegate { FinishMixerGesture(); };
+            strip.GainText = new TextBox { Text = "0.0", FontSize = 11, FontFamily = new FontFamily("Consolas"), HorizontalContentAlignment = HorizontalAlignment.Center, Padding = new Thickness(2), MinHeight = 22, Height = 22, Margin = new Thickness(0, 3, 0, 2), ToolTip = "Gain in dB; enter 0 for unity" }; body.Children.Add(strip.GainText);
+            Action commit = delegate {
+                double value; if (!TempoGrid.TryTempo(strip.GainText.Text, out value) || double.IsNaN(value) || double.IsInfinity(value) || value < -60 || value > (master ? 12 : 24)) {
+                    status("Enter a mixer level between -60 and +" + (master ? 12 : 24) + " dB.");
+                } else SetMixerGain(index, value);
+                strip.GainText.Text = (master ? session.MasterGainDb : session.Tracks[index].GainDb).ToString("0.0", CultureInfo.InvariantCulture); FinishMixerGesture();
+            };
+            strip.GainText.LostKeyboardFocus += delegate { commit(); };
+            strip.GainText.TextChanged += delegate { double value; if (!updatingMixer && strip.GainText.IsKeyboardFocusWithin && TempoGrid.TryTempo(strip.GainText.Text, out value) && !double.IsNaN(value) && !double.IsInfinity(value) && value >= -60 && value <= (master ? 12 : 24)) SetMixerGain(index, value); };
+            strip.GainText.KeyDown += delegate(object sender, KeyEventArgs e) { if (e.Key == Key.Enter) { commit(); e.Handled = true; } };
+            strip.Pan = new Slider { Minimum = -1, Maximum = 1, Value = 0, SmallChange = .05, LargeChange = .2, Height = 19, ToolTip = master ? "The master is stereo" : "Pan / stereo balance. Centre preserves the original channel levels.", IsEnabled = !master, Margin = new Thickness(0, 1, 0, 2) }; body.Children.Add(strip.Pan);
+            strip.Pan.ValueChanged += delegate { if (!master && !updatingMixer) SetMixerPan(index, Math.Round(strip.Pan.Value, 2)); };
+            strip.Pan.PreviewMouseLeftButtonUp += delegate { FinishMixerGesture(); }; strip.Pan.LostKeyboardFocus += delegate { FinishMixerGesture(); };
+            var switches = new StackPanel { Orientation = Orientation.Horizontal, HorizontalAlignment = HorizontalAlignment.Center };
+            strip.Mute = new ToggleButton { Content = master ? "Mute" : "M", MinWidth = master ? 66 : 35, Height = 23, FontSize = 11, Margin = new Thickness(0, 0, 3, 0), ToolTip = master ? "Mute the master mix in playback and export" : "Mute this track" }; switches.Children.Add(strip.Mute);
+            strip.Mute.Click += delegate { if (!updatingMixer) SetMixerMute(index, strip.Mute.IsChecked == true); };
+            strip.Solo = new ToggleButton { Content = "S", Width = 35, Height = 23, FontSize = 11, ToolTip = "Solo this track", Visibility = master ? Visibility.Collapsed : Visibility.Visible }; switches.Children.Add(strip.Solo);
+            strip.Solo.Click += delegate { if (!master && !updatingMixer) SetMixerSolo(index, strip.Solo.IsChecked == true); }; body.Children.Add(switches);
+            strip.Peak = WorkspaceUi.Button("−∞ dBFS", delegate { ClearMixerPeak(strip); }); strip.Peak.FontSize = 10; strip.Peak.FontFamily = new FontFamily("Consolas"); strip.Peak.MinHeight = 22; strip.Peak.Height = 22; strip.Peak.Padding = new Thickness(1); strip.Peak.Margin = new Thickness(0, 2, 0, 0);
+            strip.Peak.ToolTip = "Peak hold in dBFS. Red means a level at or above 0 dBFS; click to clear. Float originals retain their headroom."; body.Children.Add(strip.Peak);
+            strip.Frame = new Border { Child = body, Width = 100, Padding = new Thickness(5), Margin = new Thickness(0, 0, 4, 0), Background = WorkspaceUi.Color(master ? "#E4ECEA" : "#F3F5F5"), BorderBrush = WorkspaceUi.Color("#D6E1DF"), BorderThickness = new Thickness(1), CornerRadius = new CornerRadius(3) };
+            return strip;
+        }
+        private void FinishMixerGesture() { mixerUndoKey = null; }
+        private bool ChangeMixer(Action change, string key, bool coalesce)
+        {
+            if (IsBusy) return false;
+            if (!coalesce || mixerUndoKey != key || DateTime.UtcNow > mixerUndoUntil) { undo.Push(session.Copy()); redo.Clear(); }
+            change(); dirty = true; mixerUndoKey = coalesce ? key : null; mixerUndoUntil = DateTime.UtcNow.AddMilliseconds(500);
+            if (mix != null) mix.UpdateMixer(session);
+            RefreshMixerControls(); RefreshHeaderMixerControls(); RefreshRegionHighlights();
+            undoButton.IsEnabled = true; redoButton.IsEnabled = false; title.Text = session.Name + " *";
+            return true;
+        }
+        private void SetMixerGain(int index, double value)
+        {
+            value = Math.Round(Math.Max(-60, Math.Min(index < 0 ? 12 : 24, value)), 1, MidpointRounding.AwayFromZero);
+            if ((index < 0 ? session.MasterGainDb : session.Tracks[index].GainDb) == value) return;
+            ChangeMixer(delegate { if (index < 0) session.MasterGainDb = value; else session.Tracks[index].GainDb = value; }, "gain:" + index, true);
+        }
+        private void SetMixerPan(int index, double value)
+        {
+            value = Math.Max(-1, Math.Min(1, value)); if (session.Tracks[index].Pan == value) return;
+            ChangeMixer(delegate { session.Tracks[index].Pan = value; }, "pan:" + index, true);
+        }
+        private void SetMixerMute(int index, bool value)
+        { if ((index < 0 ? session.MasterMuted : session.Tracks[index].Mute) != value) ChangeMixer(delegate { if (index < 0) session.MasterMuted = value; else session.Tracks[index].Mute = value; }, "mute:" + index, false); }
+        private void SetMixerSolo(int index, bool value)
+        { if (session.Tracks[index].Solo != value) ChangeMixer(delegate { session.Tracks[index].Solo = value; }, "solo:" + index, false); }
+        private void ResetMixer()
+        {
+            ChangeMixer(delegate { foreach (var state in session.Tracks) { state.GainDb = state.Pan = 0; state.Mute = state.Solo = false; } session.MasterGainDb = 0; session.MasterMuted = false; }, "reset", false);
+            ResetMixerMeters();
+        }
+        private void RefreshHeaderMixerControls()
+        {
+            bool previous = updating; updating = true;
+            try {
+                for (int i = 0; i < 16; i++) {
+                    if (headerMutes[i] == null) continue; var state = session.Tracks[i];
+                    headerMutes[i].IsChecked = state.Mute; headerSolos[i].IsChecked = state.Solo;
+                    var levels = new[] { -60.0, -24, -18, -12, -6, 0, 3, 6, 12, 18, 24, state.GainDb }.Distinct().OrderBy(v => v).ToArray();
+                    string selected = state.GainDb.ToString("0.#", CultureInfo.InvariantCulture) + " dB";
+                    if (!Equals(headerLevels[i].SelectedItem, selected)) { headerLevels[i].ItemsSource = levels.Select(v => v.ToString("0.#", CultureInfo.InvariantCulture) + " dB").ToArray(); headerLevels[i].SelectedItem = selected; }
+                }
+            }
+            finally { updating = previous; }
+        }
+        private void RefreshMixerControls()
+        {
+            if (masterStrip == null || !MixerVisible) return; updatingMixer = true;
+            try {
+                var filePeaks = new double[16]; var hasAudio = new bool[16];
+                foreach (var region in session.Regions) { Clip clip; if (assets.TryGetValue(region.Source, out clip)) { hasAudio[region.Track] = true; filePeaks[region.Track] = Math.Max(filePeaks[region.Track], clip.Peak); } }
+                for (int i = 0; i < 17; i++) {
+                    bool master = i == 16; var strip = master ? masterStrip : mixerStrips[i]; var state = master ? null : session.Tracks[i];
+                    strip.Gain.Value = master ? session.MasterGainDb : state.GainDb;
+                    if (!strip.GainText.IsKeyboardFocusWithin) strip.GainText.Text = strip.Gain.Value.ToString("0.0", CultureInfo.InvariantCulture);
+                    strip.Mute.IsChecked = master ? session.MasterMuted : state.Mute;
+                    if (!master) {
+                        strip.Pan.Value = state.Pan; strip.Solo.IsChecked = state.Solo;
+                        strip.NameText.Text = (i + 1).ToString("00") + (RecordingTrack(i) ? " IN " : " ") + state.Name; strip.Name.ToolTip = "Select track " + (i + 1) + ": " + state.Name;
+                        strip.Source.Text = filePeaks[i] > 0 ? "File " + (20 * Math.Log10(filePeaks[i])).ToString("0.0", CultureInfo.InvariantCulture) + " dBFS" : hasAudio[i] ? "File −∞ dBFS" : "File peak —";
+                        strip.Pan.ToolTip = state.Pan == 0 ? "Pan / balance: centre" : "Pan / balance: " + (state.Pan < 0 ? "L " : "R ") + (Math.Abs(state.Pan) * 100).ToString("0", CultureInfo.InvariantCulture) + "%";
+                        strip.Source.ToolTip = "Maximum peak in the original source file(s), before mixer gain. " + strip.Source.Text;
+                        strip.Frame.BorderBrush = WorkspaceUi.Color(RecordingTrack(i) ? "#B52C36" : i == track ? "#006D68" : "#D6E1DF");
+                    }
+                    strip.Gain.IsEnabled = strip.GainText.IsEnabled = strip.Mute.IsEnabled = !IsBusy;
+                    strip.Pan.IsEnabled = strip.Solo.IsEnabled = !master && !IsBusy;
+                    strip.Name.IsEnabled = master || !IsBusy;
+                }
+                mixerContext.Text = recording ? "Recording inputs" : "Meters"; mixerMeterMode.Visibility = recording ? Visibility.Collapsed : Visibility.Visible;
+                if (MixerVisible && lastMixerSelection != track) { mixerTrackScroll.ScrollToHorizontalOffset(Math.Max(0, track * 104 - 104)); lastMixerSelection = track; }
+            }
+            finally { updatingMixer = false; }
+        }
+        private static void ClearMixerPeak(MixerStrip strip) { strip.Over = false; strip.Hold = 0; strip.HoldUntil = DateTime.MinValue; }
+        private void ResetMixerMeters()
+        {
+            foreach (var strip in mixerStrips) if (strip != null) { ClearMixerPeak(strip); strip.Left = strip.Right = 0; strip.Meter.SetLevels(0, 0); }
+            if (masterStrip != null) { ClearMixerPeak(masterStrip); masterStrip.Left = masterStrip.Right = 0; masterStrip.Meter.SetLevels(0, 0); }
+            if (mix != null) mix.DrainMeters();
+        }
+        private void TickMixerMeters()
+        {
+            if (!MixerVisible || !mixerPane.IsExpanded) return;
+            var levels = mix == null ? new TimelineMeterLevels() : mix.DrainMeters(); bool source = mixerMeterMode.SelectedIndex == 1;
+            for (int i = 0; i < 16; i++) {
+                float left = source ? levels.SourceLeft[i] : levels.OutputLeft[i], right = source ? levels.SourceRight[i] : levels.OutputRight[i];
+                if (recording && DateTime.UtcNow < inputMeterUntil) { left = recordingMixerLeft[i]; right = recordingMixerRight[i]; }
+                UpdateMixerMeter(mixerStrips[i], left, right);
+            }
+            UpdateMixerMeter(masterStrip, levels.MasterLeft, levels.MasterRight);
+        }
+        private static void UpdateMixerMeter(MixerStrip strip, float left, float right)
+        {
+            strip.Left = Math.Max(left, strip.Left * .78f); strip.Right = Math.Max(right, strip.Right * .78f); strip.Meter.SetLevels(strip.Left, strip.Right);
+            float peak = Math.Max(left, right); strip.Over |= peak >= 1;
+            if (strip.Over) strip.Hold = Math.Max(strip.Hold, peak);
+            else if (peak >= strip.Hold || DateTime.UtcNow >= strip.HoldUntil) { strip.Hold = peak; strip.HoldUntil = DateTime.UtcNow.AddSeconds(1.5); }
+            strip.Peak.Content = strip.Hold > .000001 ? (20 * Math.Log10(strip.Hold)).ToString("0.0", CultureInfo.InvariantCulture) + " dBFS" : "−∞ dBFS";
+            strip.Peak.Foreground = WorkspaceUi.Color(strip.Over ? "#B52C36" : "#526771"); strip.Peak.FontWeight = strip.Over ? FontWeights.Bold : FontWeights.Normal;
+        }
+        public void UpdateRecordingInputMeters(float[] inputs)
+        {
+            Array.Clear(recordingMixerPeaks, 0, recordingMixerPeaks.Length);
+            Array.Clear(recordingMixerLeft, 0, recordingMixerLeft.Length); Array.Clear(recordingMixerRight, 0, recordingMixerRight.Length);
+            if (recordingPlan == null) return;
+            int first = recordingPlan.Mode > 0 ? recordingPlan.Mode - 1 : 0;
+            for (int i = 0; i < recordingPlan.InputChannels && first + i < inputs.Length; i++) {
+                int target = recordingPlan.FirstTrack + (recordingPlan.Mode == -1 ? i : 0);
+                recordingMixerPeaks[target] = Math.Max(recordingMixerPeaks[target], inputs[first + i]);
+                if (recordingPlan.Mode == 0) { if (i == 0) recordingMixerLeft[target] = inputs[first + i]; else recordingMixerRight[target] = inputs[first + i]; }
+                else recordingMixerLeft[target] = recordingMixerRight[target] = inputs[first + i];
+            }
+            inputMeterUntil = DateTime.UtcNow.AddMilliseconds(350);
+        }
+        internal DockablePane MixerPaneForTest { get { return mixerPane; } }
+        internal void MixerGainForTest(int index, double value) { FinishMixerGesture(); SetMixerGain(index, value); FinishMixerGesture(); }
+        internal void MixerPanForTest(int index, double value) { FinishMixerGesture(); SetMixerPan(index, value); FinishMixerGesture(); }
+        internal void MixerMuteForTest(int index, bool value) { SetMixerMute(index, value); }
+        internal void MixerSoloForTest(int index, bool value) { SetMixerSolo(index, value); }
+        internal void MixerMeterForTest(TimelineMeterLevels levels) { for (int i = 0; i < 16; i++) UpdateMixerMeter(mixerStrips[i], levels.OutputLeft[i], levels.OutputRight[i]); UpdateMixerMeter(masterStrip, levels.MasterLeft, levels.MasterRight); }
+        internal string MixerSourceForTest(int index) { return mixerStrips[index].Source.Text; }
+        internal string MixerPeakForTest(int index) { return (index < 0 ? masterStrip : mixerStrips[index]).Peak.Content.ToString(); }
+        internal float RecordingMixerPeakForTest(int index) { return recordingMixerPeaks[index]; }
+        internal float RecordingMixerLeftForTest(int index) { return recordingMixerLeft[index]; }
+        internal float RecordingMixerRightForTest(int index) { return recordingMixerRight[index]; }
+        internal Slider MixerFaderForTest(int index) { return (index < 0 ? masterStrip : mixerStrips[index]).Gain; }
+        internal ScrollViewer MixerScrollForTest { get { return mixerTrackScroll; } }
+        internal bool MasterControlsVisibleForTest { get { return masterStrip.Peak.TransformToAncestor(this).Transform(new Point(0, masterStrip.Peak.ActualHeight)).Y <= ActualHeight; } }
+        internal void ResetMixerForTest() { ResetMixer(); }
+    }
+}

package/source/EditorMixerTests.cs

@@ -0,0 +1,159 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Controls.Primitives;
+using System.Windows.Media;
+using System.Windows.Media.Imaging;
+using System.Windows.Threading;
+using System.Xml;
+
+namespace DrumBuddy
+{
+    public static class EditorMixerTests
+    {
+        private static readonly List<string> log = new List<string>();
+        private static void Check(bool value, string message) { if (!value) throw new Exception(message); log.Add("PASS  " + message); }
+        private static bool Near(float actual, double expected) { return Math.Abs(actual - expected) < .00001; }
+        private static Clip Source(string root, string name, float left, float right, bool stereo)
+        {
+            string file = Path.Combine(root, name + ".wav"); int channels = stereo ? 2 : 1; var samples = new float[Audio.Rate * 8 * channels];
+            for (int f = 0; f < Audio.Rate * 8; f++) { samples[f * channels] = left; if (stereo) samples[f * channels + 1] = right; }
+            using (var writer = new FloatWaveWriter(file, channels, Audio.Rate)) writer.Write(samples, samples.Length, 1);
+            return Audio.Load(file, Path.Combine(root, "cache"), CancellationToken.None, null);
+        }
+        private static EditorSession State(params Clip[] clips)
+        {
+            var state = new EditorSession();
+            for (int i = 0; i < clips.Length; i++) { state.Tracks[i].Name = Path.GetFileNameWithoutExtension(clips[i].Name); state.Regions.Add(new TimelineRegion { Source = clips[i].Source, Name = state.Tracks[i].Name, Track = i, Length = Audio.Rate * 8L }); }
+            return state;
+        }
+        private static void RunUi(Func<Task> action)
+        {
+            var previous = SynchronizationContext.Current; var dispatcher = Dispatcher.CurrentDispatcher;
+            SynchronizationContext.SetSynchronizationContext(new DispatcherSynchronizationContext(dispatcher));
+            try { var task = action(); var frame = new DispatcherFrame(); task.ContinueWith(delegate { dispatcher.BeginInvoke((Action)delegate { frame.Continue = false; }); }); if (!task.IsCompleted) Dispatcher.PushFrame(frame); task.GetAwaiter().GetResult(); }
+            finally { SynchronizationContext.SetSynchronizationContext(previous); }
+        }
+        private static void Picture(FrameworkElement view, string path, int width, int height)
+        {
+            view.Measure(new Size(width, height)); view.Arrange(new Rect(0, 0, width, height)); view.UpdateLayout();
+            var bitmap = new RenderTargetBitmap(width, height, 96, 96, PixelFormats.Pbgra32); bitmap.Render(view);
+            var encoder = new PngBitmapEncoder(); encoder.Frames.Add(BitmapFrame.Create(bitmap)); using (var file = File.Create(path)) encoder.Save(file);
+        }
+        public static int Run(string[] args)
+        {
+            string root = Path.GetFullPath(args.Length > 0 ? args[0] : Path.Combine(Path.GetTempPath(), "FluxMixer_" + Guid.NewGuid().ToString("N")));
+            Directory.CreateDirectory(root); log.Clear(); var old = InterfacePreferences.Current; string oldOutput = AudioOutputs.PreferredKey;
+            try {
+                InterfacePreferences.Current = InterfacePreferences.Defaults(); ThemePalette.Apply(true); AudioOutputs.PreferredKey = "default";
+                var quiet = Source(root, "Quiet kick", .01f, .01f, false); var strong = Source(root, "Snare", .2f, .2f, false); var stereo = Source(root, "Stereo overhead", .25f, -.125f, true);
+                var decoded = new Dictionary<string, Clip> { { quiet.Source, quiet }, { strong.Source, strong }, { stereo.Source, stereo } };
+                byte[] original = File.ReadAllBytes(quiet.Source); var state = State(quiet, strong);
+                using (var mix = new TimelineMix(state, decoded)) {
+                    var samples = new float[128]; mix.Read(samples, 0, samples.Length); var meters = mix.DrainMeters();
+                    Check(samples.All(v => Near(v, .21)), "Keep unity track/master gain and centred pan identical to the existing mix");
+                    Check(Near(meters.SourceLeft[0], .01) && Near(meters.OutputLeft[0], .01) && Near(meters.MasterLeft, .21), "Measure actual pre-fader, post-fader and stereo master levels");
+                    var empty = mix.DrainMeters(); Check(empty.SourceLeft.All(v => v == 0) && empty.MasterLeft == 0 && mix.Peak > .2, "Drain UI meter peaks without resetting the export protection peak");
+                    long before = mix.Position; state.Tracks[0].GainDb = 6; state.Tracks[0].Pan = -1; state.Tracks[1].Mute = true; state.MasterGainDb = 3; mix.UpdateMixer(state);
+                    Check(mix.Position == before, "Apply live mixer controls without seeking or reopening source audio");
+                    mix.Read(samples, 0, samples.Length); meters = mix.DrainMeters();
+                    Check(Near(samples[0], .01 * Math.Pow(10, 9 / 20.0)) && samples.Where((v, i) => i % 2 == 1).All(v => v == 0), "Apply live gain, hard-left pan, track mute and master gain on the next audio block");
+                    Check(Near(meters.SourceLeft[1], .2) && meters.OutputLeft[1] == 0, "Keep pre-fader source metering available on a muted track");
+                    state.MasterMuted = true; mix.UpdateMixer(state); mix.Read(samples, 0, samples.Length); meters = mix.DrainMeters();
+                    Check(samples.All(v => v == 0) && meters.MasterLeft == 0 && meters.OutputLeft[0] > 0, "Master mute silences the mix while keeping channel/source diagnostics available");
+                }
+                state = State(quiet, strong); state.Tracks[0].Solo = true;
+                using (var mix = new TimelineMix(state, decoded)) {
+                    var samples = new float[32]; mix.Read(samples, 0, samples.Length); var meters = mix.DrainMeters();
+                    Check(samples.All(v => Near(v, .01)) && Near(meters.SourceLeft[1], .2) && meters.OutputLeft[1] == 0, "Solo isolates the chosen track while source meters still reveal the other signal");
+                }
+                var overlap = State(strong); overlap.Regions.Add(overlap.Regions[0].Copy());
+                using (var mix = new TimelineMix(overlap, decoded)) { mix.Read(new float[32], 0, 32); var meters = mix.DrainMeters(); Check(Near(meters.SourceLeft[0], .4) && Near(meters.OutputLeft[0], .4), "Meter the sum of overlapping clips on a track rather than their individual maximum"); }
+                var panned = State(stereo);
+                using (var mix = new TimelineMix(panned, decoded)) {
+                    var samples = new float[32]; mix.Read(samples, 0, samples.Length);
+                    Check(Near(samples[0], .25) && Near(samples[1], -.125), "Centred stereo balance preserves original left/right channel levels");
+                    panned.Tracks[0].Pan = 1; mix.UpdateMixer(panned); mix.Read(samples, 0, samples.Length);
+                    Check(samples.Where((v, i) => i % 2 == 0).All(v => v == 0) && Near(samples[1], -.125), "Hard-right stereo balance produces an exactly silent left channel");
+                }
+                var boosted = State(quiet); boosted.Tracks[0].GainDb = 24;
+                using (var mix = new TimelineMix(boosted, decoded)) { var samples = new float[8]; mix.Read(samples, 0, samples.Length); Check(Near(samples[0], .01 * Math.Pow(10, 24 / 20.0)), "Boost a quiet recording by up to 24 dB without rewriting its source"); }
+                boosted.MasterGainDb = 6; boosted.Tracks[0].Pan = -.5;
+                var clone = boosted.Copy(); clone.MasterGainDb = -6; clone.Tracks[0].Pan = 1;
+                Check(boosted.MasterGainDb == 6 && boosted.Tracks[0].Pan == -.5, "Keep master/pan settings independent in undo snapshots");
+                string saved = Path.Combine(root, "mixer.dbedit"); boosted.Save(saved); var reopened = EditorSession.Load(saved);
+                Check(reopened.MasterGainDb == 6 && reopened.Tracks[0].GainDb == 24 && reopened.Tracks[0].Pan == -.5, "Save and reopen mixer gain, pan and master settings in a session");
+                var xml = new XmlDocument(); xml.Load(saved); foreach (XmlNode node in xml.SelectNodes("/EditorSession/MasterGainDb|/EditorSession/MasterMuted|/EditorSession/Tracks/EditorTrack/Pan")) node.ParentNode.RemoveChild(node);
+                foreach (XmlNode node in xml.SelectNodes("/EditorSession/Tracks/EditorTrack/GainDb")) node.InnerText = "0";
+                string legacyPath = Path.Combine(root, "legacy.dbedit"); xml.Save(legacyPath); var legacy = EditorSession.Load(legacyPath);
+                Check(legacy.MasterGainDb == 0 && !legacy.MasterMuted && legacy.Tracks.All(t => t.Pan == 0), "Open older sessions with unity master gain and centred pan");
+                var bad = state.Copy(); bad.Tracks[0].Pan = double.NaN; bool rejected = false; try { bad.Validate(); } catch (IOException) { rejected = true; }
+                Check(rejected, "Reject non-finite pan positions before rendering or saving");
+                bad = state.Copy(); bad.MasterGainDb = 13; rejected = false; try { bad.Validate(); } catch (IOException) { rejected = true; }
+                Check(rejected, "Reject unsupported master gain");
+                var exportState = State(quiet); exportState.Tracks[0].GainDb = 6; exportState.MasterGainDb = 6; exportState.Tracks[0].Pan = -1;
+                string rendered = Path.Combine(root, "mixer-export.wav"); TimelineRender.Export(exportState, decoded, rendered, 32, false, 0, Audio.Rate, CancellationToken.None, null);
+                var renderedClip = Audio.Load(rendered, Path.Combine(root, "export-cache"), CancellationToken.None, null);
+                Check(Math.Abs(renderedClip.Peak - .01 * Math.Pow(10, 12 / 20.0)) < .00001, "Render track and master levels into float mix exports");
+                exportState = State(strong); exportState.Tracks[0].GainDb = 24; exportState.MasterGainDb = 12;
+                rendered = Path.Combine(root, "protected-mixer-export.wav"); TimelineRender.Export(exportState, decoded, rendered, 24, true, 0, Audio.Rate, CancellationToken.None, null);
+                Check(Math.Abs(Audio.Load(rendered, Path.Combine(root, "export-cache"), CancellationToken.None, null).PeakDb + 1) < .02, "Keep PCM clipping protection effective after track and master amplification");
+
+                var main = new MainWindow(Path.Combine(root, "preferences.xml"), true); main.OpenEditorForTest(); var editor = main.RecordingEditorForTest;
+                main.EditorFixtureForTest(State(quiet, strong), decoded); editor.ShowMixer(true);
+                Picture((FrameworkElement)main.NativeWindow.Content, Path.Combine(root, "mixer-initial-dark.png"), 1280, 800);
+                Check(editor.MixerVisible && main.NativeWindow.FindName("ViewMixer") != null, "Expose the integrated mixer from the editor and View menu");
+                Check(editor.MasterControlsVisibleForTest && editor.MixerScrollForTest.ComputedHorizontalScrollBarVisibility == Visibility.Visible, "Keep the master controls and track-scroll bar visible at the default mixer size");
+                editor.MixerScrollForTest.ScrollToRightEnd(); ((FrameworkElement)main.NativeWindow.Content).UpdateLayout();
+                Check(editor.MixerScrollForTest.HorizontalOffset > 0 && editor.MasterControlsVisibleForTest, "Reach the remaining tracks while keeping the master strip pinned in view");
+                editor.MixerScrollForTest.ScrollToLeftEnd(); ((FrameworkElement)main.NativeWindow.Content).UpdateLayout();
+                Check(editor.MixerSourceForTest(0).Contains("-40.0"), "Display the quiet recording's actual file peak independently of mixer gain");
+                var fader = editor.MixerFaderForTest(0); fader.ApplyTemplate(); var track = (Track)fader.Template.FindName("PART_Track", fader);
+                Check(track.Orientation == Orientation.Vertical && fader.ActualHeight >= 90 && track.ActualHeight >= 85, "Use a real vertical fader with its full travel in the dark theme");
+                double thumbBefore = track.Thumb.TransformToAncestor(fader).Transform(new Point()).Y;
+                fader.Value = 6; fader.Value = 7; main.NativeWindow.Content.AsFramework().UpdateLayout();
+                Check(editor.SessionForTest.Tracks[0].GainDb == 7 && track.Thumb.TransformToAncestor(fader).Transform(new Point()).Y < thumbBefore, "Moving the visible fader upward changes the real track gain");
+                RunUi(() => editor.ExecuteAction("undo")); Check(editor.SessionForTest.Tracks[0].GainDb == 0, "Coalesce one fader gesture into a single undo operation");
+                RunUi(() => editor.ExecuteAction("redo")); Check(editor.SessionForTest.Tracks[0].GainDb == 7, "Redo a mixer change");
+                editor.MixerPanForTest(0, -.5); editor.MixerGainForTest(-1, 3);
+                Check(editor.SessionForTest.Tracks[0].Pan == -.5 && editor.SessionForTest.MasterGainDb == 3, "Wire visible pan and master controls to the session model");
+                editor.ListenVolumeForTest(0); editor.PlayheadForTest(Audio.Rate);
+                RunUi(() => editor.ExecuteAction("play")); long playingAt = editor.PlayheadFrame;
+                editor.MixerGainForTest(0, 12); editor.MixerMuteForTest(1, true); editor.MixerSoloForTest(0, true);
+                RunUi(async delegate { await Task.Delay(150); });
+                Check(editor.PlayingForTest && editor.PlayheadFrame >= playingAt, "Adjust track gain, mute and solo while native playback continues at muted listening volume");
+                Check(!editor.MixerPeakForTest(-1).Contains("∞"), "Keep mix meters active even when the monitor listening slider is zero");
+                editor.Stop(); editor.ResetMixerForTest();
+                var plan = new RecordingPlan(new InputChoice { Name = "Test microphone" }, 2, 24, 48000, 2, 5, 0, new TempoGridOptions());
+                editor.BeginRecordingCountdown(plan); editor.UpdateRecordingInputMeters(new[] { .1f, .2f }); editor.MixerGainForTest(5, 24);
+                Check(editor.RecordingMixerPeakForTest(5) == .2f && editor.RecordingMixerPeakForTest(0) == 0 && editor.SessionForTest.Tracks[5].GainDb == 0, "Route the selected recording input to its registered mixer strip and lock playback-only faders during capture");
+                editor.SetRecordingState(false); plan = new RecordingPlan(new InputChoice { Name = "Stereo microphone" }, 0, 24, 48000, 2, 5, 0, new TempoGridOptions());
+                editor.BeginRecordingCountdown(plan); editor.UpdateRecordingInputMeters(new[] { .1f, .3f });
+                Check(editor.RecordingMixerLeftForTest(5) == .1f && editor.RecordingMixerRightForTest(5) == .3f, "Keep stereo recording input meters separate on a stereo destination track");
+                editor.SetRecordingState(false); editor.ShowRecordingOptions(false);
+                var display = State(quiet, strong); display.Tracks[0].Name = "Quiet kick"; display.Tracks[1].Name = "Snare";
+                for (int i = 2; i < 16; i++) { display.Tracks[i].Name = "Drum input " + (i + 1); display.Regions.Add(new TimelineRegion { Source = i % 2 == 0 ? quiet.Source : strong.Source, Name = display.Tracks[i].Name, Track = i, Length = Audio.Rate * 8L }); }
+                display.Tracks[0].GainDb = 18; display.Tracks[1].GainDb = 6; main.EditorFixtureForTest(display, decoded); editor.ShowMixer(true);
+                using (var mix = new TimelineMix(display, decoded)) { mix.Read(new float[512], 0, 512); editor.MixerMeterForTest(mix.DrainMeters()); }
+                Picture((FrameworkElement)main.NativeWindow.Content, Path.Combine(root, "mixer-dark.png"), 1280, 800);
+                Check(editor.MixerPeakForTest(-1).Contains("dBFS") && editor.SessionForTest.MasterGainDb == 0, "Display actual stereo master peaks while keeping the separate monitor level out of the saved mix");
+                main.SetThemeForTest(false); Picture((FrameworkElement)main.NativeWindow.Content, Path.Combine(root, "mixer-light.png"), 1280, 800);
+                main.SetThemeForTest(true); Picture((FrameworkElement)main.NativeWindow.Content, Path.Combine(root, "mixer-compact-dark.png"), 850, 560);
+                editor.MixerPaneForTest.SetExpanded(false); Picture((FrameworkElement)main.NativeWindow.Content, Path.Combine(root, "mixer-collapsed-dark.png"), 850, 560);
+                Check(!editor.MixerPaneForTest.IsExpanded && editor.TimelineHeightForTest > 180, "Collapse the mixer to restore timeline space on a compact window");
+                editor.ShowMixer(false); main.EditorFixtureForTest(new EditorSession(), new Dictionary<string, Clip>()); main.NativeWindow.Close();
+                Check(original.SequenceEqual(File.ReadAllBytes(quiet.Source)), "Keep the original quiet recording byte-for-byte unchanged through mixing, playback and exports");
+                File.WriteAllLines(Path.Combine(root, "mixer-test-results.txt"), log, Encoding.UTF8); return 0;
+            }
+            catch (Exception ex) { log.Add("FAIL  " + ex); File.WriteAllLines(Path.Combine(root, "mixer-test-results.txt"), log, Encoding.UTF8); return 1; }
+            finally { InterfacePreferences.Current = old; AudioOutputs.PreferredKey = oldOutput; ThemePalette.Apply(old.Theme == "Dark"); }
+        }
+        private static FrameworkElement AsFramework(this object value) { return (FrameworkElement)value; }
+    }
+}

package/source/EditorPlaybackTests.cs

@@ -7,6 +7,7 @@ using System.Threading.Tasks;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Windows;
+using System.Windows.Input;
 using System.Windows.Threading;
 using NAudio.Wave;
 
@@ -74,6 +75,27 @@ namespace DrumBuddy
                     owner.Content = null; owner.Close();
                     Check(original.SequenceEqual(File.ReadAllBytes(file)), "Preserve the original " + kind + " file through import and playback");
                 }
+                string navigationFile = Path.Combine(root, "bar-navigation.wav");
+                using (var writer = new FloatWaveWriter(navigationFile, 1, Audio.Rate)) writer.Write(new float[Audio.Rate * 12], Audio.Rate * 12, 1);
+                var navigationOwner = new Window(); ThemePalette.Install(navigationOwner);
+                using (var editor = new EditorView(navigationOwner, Path.Combine(root, "navigation-cache"), delegate(string text) { }, delegate { })) {
+                    navigationOwner.Content = editor; editor.ListenVolumeForTest(0);
+                    RunUi(() => editor.AddFiles(new[] { navigationFile })); editor.PlayheadForTest(Audio.Rate * 5L);
+                    RunUi(() => editor.ExecuteAction("play"));
+                    RunUi(() => editor.ExecuteAction(InterfacePreferences.Resolve(Key.Left, ModifierKeys.Control)));
+                    Check(editor.PlayingForTest && Math.Abs(editor.PlayheadFrame - Audio.Rate * 4L) < Audio.Rate / 2, "Ctrl+Left seeks to the preceding bar while playback continues");
+                    RunUi(() => editor.ExecuteAction(InterfacePreferences.Resolve(Key.Right, ModifierKeys.Control)));
+                    Check(editor.PlayingForTest && Math.Abs(editor.PlayheadFrame - Audio.Rate * 6L) < Audio.Rate / 2, "Ctrl+Right seeks to the following bar while playback continues");
+                    editor.Stop(); editor.PlayheadForTest(Audio.Rate * 5L);
+                    RunUi(() => editor.ExecuteAction("play")); RunUi(() => editor.ExecuteAction("play"));
+                    RunUi(() => editor.ExecuteAction("previousBar"));
+                    Check(!editor.PlayingForTest && editor.PlayheadFrame == Audio.Rate * 4L, "A bar jump from paused playback stays silent at the new position");
+                    RunUi(() => editor.ExecuteAction("play"));
+                    Check(editor.PlayingForTest && Math.Abs(editor.PlayheadFrame - Audio.Rate * 4L) < Audio.Rate / 2, "Resume after a paused bar jump starts at the new bar");
+                    RunUi(() => editor.ExecuteAction(InterfacePreferences.Resolve(Key.Enter, ModifierKeys.None)));
+                    Check(!editor.PlayingForTest && editor.PlayheadFrame == 0, "Enter returns to the very beginning with the same transport behavior as Home");
+                }
+                navigationOwner.Content = null; navigationOwner.Close();
                 var picker = new AudioOutputPicker(delegate { }, delegate { });
                 AudioOutputs.PreferredKey = "windows:missing-output-for-test"; picker.RefreshForTest();
                 Check(picker.SelectionForTest == "default" && AudioOutputs.PreferredKey == "default", "Keep the displayed default and actual saved routing selection consistent after a device disappears");

package/source/EditorRecording.cs

@@ -0,0 +1,106 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Media;
+using System.Windows.Shapes;
+
+namespace DrumBuddy
+{
+    public sealed partial class EditorView
+    {
+        private Border recordingBanner;
+        private TextBlock countdownText, recordingHeadline, recordingRouting;
+        private RecordingPlan recordingPlan;
+        private bool captureRunning;
+        private readonly List<Rectangle> recordingOverlays = new List<Rectangle>();
+
+        private void InitializeRecordingFeedback(Panel tools)
+        {
+            var body = new DockPanel();
+            countdownText = WorkspaceUi.Text("", 30); countdownText.FontWeight = FontWeights.Bold;
+            countdownText.Foreground = WorkspaceUi.Color("#B52C36"); countdownText.MinWidth = 72;
+            countdownText.Margin = new Thickness(0, 0, 12, 0); countdownText.VerticalAlignment = VerticalAlignment.Center;
+            DockPanel.SetDock(countdownText, Dock.Left); body.Children.Add(countdownText);
+            var details = new StackPanel { VerticalAlignment = VerticalAlignment.Center }; body.Children.Add(details);
+            recordingHeadline = WorkspaceUi.Text("", 15); recordingHeadline.FontWeight = FontWeights.SemiBold; details.Children.Add(recordingHeadline);
+            recordingRouting = WorkspaceUi.Text("", 12); recordingRouting.Margin = new Thickness(0, 3, 0, 0); details.Children.Add(recordingRouting);
+            recordingBanner = new Border { Child = body, BorderBrush = WorkspaceUi.Color("#B52C36"), BorderThickness = new Thickness(2),
+                Background = WorkspaceUi.Color("#F3F5F5"), Padding = new Thickness(10, 6, 10, 6), Margin = new Thickness(0, 0, 0, 6), Visibility = Visibility.Collapsed };
+            tools.Children.Add(recordingBanner);
+        }
+        public RecordingPlan PlanRecording(InputChoice input, int mode, int bits, int rate, int availableInputs)
+        {
+            if (!CommitTempo()) throw new System.IO.IOException("Enter a valid project tempo before recording.");
+            return new RecordingPlan(input, mode, bits, rate, availableInputs, track, playhead, session.Grid);
+        }
+        public void BeginRecordingCountdown(RecordingPlan plan)
+        {
+            recordingPlan = plan; captureRunning = false; playhead = plan.AnchorFrame;
+            SetRecordingState(true); recordButton.Content = "Cancel count-in";
+            recordingBanner.Visibility = Visibility.Visible; countdownText.Text = "...";
+            recordingHeadline.Text = "Preparing recording input"; recordingRouting.Text = plan.Routing;
+            BuildHeaders(); DrawCanvas(); EnsurePlayheadVisible();
+            double top = RulerHeight + plan.FirstTrack * RowHeight, bottom = top + plan.TrackCount * RowHeight;
+            if (scroll.ViewportHeight > 0) {
+                if (top < scroll.VerticalOffset) scroll.ScrollToVerticalOffset(Math.Max(0, top - RowHeight));
+                else if (bottom > scroll.VerticalOffset + scroll.ViewportHeight) scroll.ScrollToVerticalOffset(Math.Max(0, bottom - scroll.ViewportHeight));
+            }
+        }
+        public void ShowCountdownBeat(int remaining)
+        {
+            countdownText.Text = remaining.ToString();
+            recordingHeadline.Text = "Recording in " + remaining + (remaining == 1 ? " beat" : " beats");
+        }
+        public void BeginRecordingCapture()
+        {
+            captureRunning = true; recordButton.Content = "Stop recording"; countdownText.Text = "REC";
+            recordingHeadline.Text = "Recording | 00:00.00"; BuildHeaders(); DrawCanvas();
+        }
+        public void UpdateRecordingProgress(long capturedFrames, int sampleRate)
+        {
+            if (!recording || recordingPlan == null) return;
+            playhead = recordingPlan.TimelineFrame(capturedFrames, sampleRate);
+            timeline.Width = Math.Max(timeline.Width, X(Math.Min(EditorSession.MaxFrame, playhead + Audio.Rate * 15L)));
+            recordingHeadline.Text = "Recording | " + WorkspaceUi.Clock(capturedFrames / (double)sampleRate);
+            UpdateRecordingOverlays(); UpdatePlayLine(); UpdateTransport();
+            if (DateTime.UtcNow >= manualViewUntil) EnsurePlayheadVisible();
+        }
+        public void ShowRecordingSaving()
+        { recordButton.Content = "Saving..."; recordButton.IsEnabled = false; countdownText.Text = "..."; recordingHeadline.Text = "Saving recording"; }
+        public void ShowRecordingError(string message)
+        {
+            recordingBanner.Visibility = Visibility.Visible; countdownText.Text = "!";
+            recordingHeadline.Text = "Could not record"; recordingRouting.Text = message;
+        }
+        private bool RecordingTrack(int index)
+        { return recording && recordingPlan != null && index >= recordingPlan.FirstTrack && index < recordingPlan.FirstTrack + recordingPlan.TrackCount; }
+        private void DrawRecordingOverlays()
+        {
+            recordingOverlays.Clear(); if (recordingPlan == null || !recording) return;
+            for (int i = 0; i < recordingPlan.TrackCount; i++) {
+                var rectangle = new Rectangle { Fill = WorkspaceUi.Color("#B52C36"), Opacity = .24, Stroke = WorkspaceUi.Color("#B52C36"),
+                    StrokeThickness = 2, Height = RowHeight - 6, IsHitTestVisible = false, Tag = "RecordingPreview" };
+                Canvas.SetTop(rectangle, RulerHeight + (recordingPlan.FirstTrack + i) * RowHeight + 3);
+                timeline.Children.Add(rectangle); recordingOverlays.Add(rectangle);
+            }
+            UpdateRecordingOverlays();
+        }
+        private void UpdateRecordingOverlays()
+        {
+            if (recordingPlan == null) return;
+            double left = Math.Max(scroll.HorizontalOffset, X(recordingPlan.AnchorFrame));
+            double right = Math.Min(scroll.HorizontalOffset + Math.Max(900, scroll.ViewportWidth), X(playhead));
+            foreach (var rectangle in recordingOverlays) {
+                Canvas.SetLeft(rectangle, left); rectangle.Width = Math.Max(2, right - left);
+                rectangle.Visibility = right >= left ? Visibility.Visible : Visibility.Collapsed;
+            }
+        }
+        internal string CountdownForTest { get { return countdownText.Text; } }
+        internal string RecordingHeadlineForTest { get { return recordingHeadline.Text; } }
+        internal string RoutingForTest { get { return recordingRouting.Text; } }
+        internal int[] ArmedTracksForTest { get { return Enumerable.Range(0, 16).Where(RecordingTrack).ToArray(); } }
+        internal int RecordingOverlaysForTest { get { return recordingOverlays.Count; } }
+    }
+}