@pro-gram/flux 0.0.0-stage → 1.6.0

package/source/EditorView.cs

@@ -0,0 +1,798 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Globalization;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Collections.Generic;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Controls.Primitives;
+using System.Windows.Input;
+using System.Windows.Media;
+using System.Windows.Shapes;
+using System.Windows.Threading;
+using Path = System.IO.Path;
+
+namespace DrumBuddy
+{
+    public sealed partial class EditorView : Grid, IDisposable
+    {
+        private const double RowHeight = 56, RulerHeight = 26;
+        private readonly Window owner;
+        private readonly string cache;
+        private readonly Action<string> status;
+        private readonly Action beforePlay;
+        private readonly Dictionary<string, Clip> assets = new Dictionary<string, Clip>(StringComparer.OrdinalIgnoreCase);
+        private readonly Stack<EditorSession> undo = new Stack<EditorSession>(), redo = new Stack<EditorSession>();
+        private EditorSession session = new EditorSession();
+        private TimelineClipboard clipboard;
+        private TimelineMix mix;
+        private readonly WorkspaceOutput output;
+        private readonly AudioOutputPicker outputPicker;
+        private readonly Canvas timeline;
+        private readonly StackPanel headers;
+        private readonly ScrollViewer scroll, headerScroll;
+        private readonly TextBlock title, positionText, selectionText;
+        private readonly TextBox selectionFrom, selectionTo;
+        private readonly ComboBox scope, exportFormat;
+        private readonly Slider zoomSlider;
+        private readonly TextBlock zoomSpan;
+        private readonly Button fitSelection;
+        private readonly WaveformDetail waveformDetail;
+        private bool updatingZoom;
+        private DateTime manualViewUntil;
+        private readonly CheckBox separate, selectionOnly, protect;
+        private readonly Button play, undoButton, redoButton, cancel;
+        private readonly Slider volume;
+        private readonly DispatcherTimer timer;
+        private readonly Line playLine;
+        private readonly TimelineGesture gesture = new TimelineGesture();
+        private readonly TextBox tempoBox;
+        private readonly ComboBox gridDivision, rulerMode;
+        private readonly CheckBox snapGrid, snapEdges, gridTriplet;
+        private readonly TextBlock meterText;
+        private readonly WrapPanel gridControls;
+        public Action GridSettingsRequested;
+        public TempoGridOptions GridOptions { get { return session.Grid.Copy(); } }
+        private readonly Grid editorBody;
+        private readonly DockablePane recordingPane;
+        private readonly Button recordButton;
+        private bool sliceCursor, clipSelection, selectionMoved;
+        private string pendingRegion;
+        private double selectionPointerX;
+        private readonly HashSet<string> selectedIds = new HashSet<string>();
+        private string[] previousIds;
+        private bool previousClipSelection;
+        private int previousTrack;
+        private long previousFrom, previousTo, previousPlayhead;
+        private sealed class RegionVisual { public TimelineRegion Region; public Rectangle Body, Glow; }
+        private readonly List<RegionVisual> regionVisuals = new List<RegionVisual>();
+        private readonly Button compactOptionsButton;
+        private FrameworkElement exportDetails;
+        private bool compactOptions;
+        private readonly Rectangle selectionOverlay;
+        private readonly Line selectionStartLine, selectionEndLine;
+        private readonly Polygon selectionStartHandle, selectionEndHandle;
+        private bool recording;
+        public Action RecordRequested;
+        public Action StopRequested;
+        public Action RecordingOptionsRequested;
+        public long PlayheadFrame { get { return playhead; } }
+        public int SelectedTrack { get { return track; } }
+        private readonly List<Button> fileButtons = new List<Button>();
+        private CancellationTokenSource operation;
+        private string sessionPath;
+        private int track;
+        private double pixelsPerSecond = 40;
+        private long playhead, from, to;
+        private bool updating, disposed, dirty, tempoEdited;
+        public bool IsBusy { get { return operation != null || recording || clipDrag != ClipDrag.None; } }
+        public bool Dirty { get { return dirty; } }
+        private bool AllTracks { get { return scope.SelectedIndex == 1; } }
+
+        public EditorView(Window owner, string cache, Action<string> status, Action beforePlay)
+        {
+            this.owner = owner; this.cache = cache; this.status = status; this.beforePlay = beforePlay;
+            session.Grid = InterfacePreferences.Current.Grid.Copy();
+            Background = WorkspaceUi.Color("#F3F5F5");
+            output = new WorkspaceOutput(Dispatcher);
+            editorBody = new Grid();
+            editorBody.RowDefinitions.Add(new RowDefinition { Height = GridLength.Auto });
+            editorBody.RowDefinitions.Add(new RowDefinition { Height = GridLength.Auto });
+            editorBody.RowDefinitions.Add(new RowDefinition());
+            editorBody.RowDefinitions.Add(new RowDefinition { Height = GridLength.Auto });
+            var top = new WrapPanel(); editorBody.Children.Add(top);
+            title = WorkspaceUi.Text("Editor · Untitled session", 24); title.FontWeight = FontWeights.SemiBold; title.Margin = new Thickness(0, 0, 20, 10); top.Children.Add(title);
+            cancel = WorkspaceUi.Button("Cancel", delegate { if (operation != null) operation.Cancel(); }); cancel.Visibility = Visibility.Collapsed; top.Children.Add(cancel);
+
+            var tools = new StackPanel(); SetRow(tools, 1); editorBody.Children.Add(tools);
+            var editing = new WrapPanel(); tools.Children.Add(editing);
+            recordButton = WorkspaceUi.Button("Record", delegate { if (RecordRequested != null) RecordRequested(); }); recordButton.Background = WorkspaceUi.Color("#B52C36"); recordButton.Foreground = System.Windows.Media.Brushes.White; editing.Children.Add(recordButton);
+            recordButton.SetResourceReference(Control.ForegroundProperty, "ThemeOnAccent");
+            editing.Children.Add(WorkspaceUi.Button("Record options", delegate { ShowRecordingOptions(!recordingPane.IsPaneVisible); }));
+            undoButton = WorkspaceUi.Button("Undo", delegate { Undo(false); }); editing.Children.Add(undoButton);
+            redoButton = WorkspaceUi.Button("Redo", delegate { Undo(true); }); editing.Children.Add(redoButton);
+            editing.Children.Add(WorkspaceUi.Button("Delete range", delegate { DeleteRange(); }));
+            scope = new ComboBox { ItemsSource = new[] { "Selected track", "All 16 tracks" }, SelectedIndex = 0, Width = 170, MinHeight = 36, FontSize = 14, Padding = new Thickness(6, 3, 6, 3), Margin = new Thickness(0, 0, 8, 8) }; editing.Children.Add(scope);
+            scope.SelectionChanged += delegate { if (!updating) { clipSelection = false; selectedIds.Clear(); } DrawCanvas(); };
+            separate = new CheckBox { Content = "Import files on separate tracks", IsChecked = true, FontSize = 14, Margin = new Thickness(4, 0, 0, 8), VerticalAlignment = VerticalAlignment.Center }; editing.Children.Add(separate);
+            compactOptionsButton = WorkspaceUi.Button("Audio / export options", delegate { compactOptions = !compactOptions; UpdateCompactLayout(); }); editing.Children.Add(compactOptionsButton);
+
+            gridControls = new WrapPanel { Margin = new Thickness(0, 0, 0, 3) }; tools.Children.Add(gridControls);
+            gridControls.Children.Add(WorkspaceUi.Text("BPM  ", 12));
+            tempoBox = new TextBox { Width = 60, MinHeight = 28, Padding = new Thickness(5, 3, 5, 3), Margin = new Thickness(0, 0, 9, 5) }; gridControls.Children.Add(tempoBox);
+            tempoBox.TextChanged += delegate { if (!updating) tempoEdited = true; };
+            tempoBox.LostKeyboardFocus += delegate { if (!updating) CommitTempo(); };
+            tempoBox.KeyDown += delegate(object sender, KeyEventArgs e) { if (e.Key == Key.Enter) { CommitTempo(); e.Handled = true; } else if (e.Key == Key.Escape) { tempoBox.Text = session.Grid.Tempo.ToString("0.###", CultureInfo.InvariantCulture); tempoEdited = false; e.Handled = true; } };
+            meterText = WorkspaceUi.Text("4/4  ", 12); gridControls.Children.Add(meterText);
+            gridControls.Children.Add(WorkspaceUi.Text("Grid  ", 12));
+            gridDivision = new ComboBox { ItemsSource = TempoGrid.Divisions.Select(v => "1/" + v).ToArray(), Width = 82, MinHeight = 28, Margin = new Thickness(0, 0, 9, 5) };
+            gridDivision.SelectionChanged += delegate { if (!updating && gridDivision.SelectedItem != null) { var value = session.Grid.Copy(); value.Division = int.Parse(((string)gridDivision.SelectedItem).Substring(2)); ApplyGridOptions(value); } }; gridControls.Children.Add(gridDivision);
+            gridTriplet = new CheckBox { Content = "Triplet", Margin = new Thickness(0, 0, 10, 5), VerticalAlignment = VerticalAlignment.Center };
+            gridTriplet.Click += delegate { if (!updating) { var value = session.Grid.Copy(); value.Triplet = gridTriplet.IsChecked == true; ApplyGridOptions(value); } }; gridControls.Children.Add(gridTriplet);
+            snapGrid = new CheckBox { Content = "Snap grid", Margin = new Thickness(0, 0, 10, 5), VerticalAlignment = VerticalAlignment.Center };
+            snapEdges = new CheckBox { Content = "Snap edges", Margin = new Thickness(0, 0, 10, 5), VerticalAlignment = VerticalAlignment.Center };
+            snapGrid.Click += delegate { SaveSnapChoices(); }; snapEdges.Click += delegate { SaveSnapChoices(); }; gridControls.Children.Add(snapGrid); gridControls.Children.Add(snapEdges);
+            rulerMode = new ComboBox { ItemsSource = new[] { "Bars / beats", "Seconds" }, Width = 116, MinHeight = 28, Margin = new Thickness(0, 0, 8, 5) };
+            rulerMode.SelectionChanged += delegate { if (!updating && rulerMode.SelectedIndex >= 0) { var value = session.Grid.Copy(); value.MusicalRuler = rulerMode.SelectedIndex == 0; ApplyGridOptions(value); } }; gridControls.Children.Add(rulerMode);
+            gridControls.Children.Add(WorkspaceUi.Button("Grid settings", delegate { if (GridSettingsRequested != null) GridSettingsRequested(); }));
+
+            var range = new WrapPanel { Margin = new Thickness(0, 0, 0, 5) }; tools.Children.Add(range);
+            range.Visibility = Visibility.Collapsed;
+            editing.Children.Add(WorkspaceUi.Button("Range", delegate { range.Visibility = range.Visibility == Visibility.Visible ? Visibility.Collapsed : Visibility.Visible; }));
+            range.Children.Add(WorkspaceUi.Text("Selection, seconds  ", 14));
+            selectionFrom = new TextBox { Text = "0.00000", Width = 100, FontSize = 15, Padding = new Thickness(5), Margin = new Thickness(0, 0, 8, 8) }; range.Children.Add(selectionFrom);
+            range.Children.Add(WorkspaceUi.Text("to  ", 14));
+            selectionTo = new TextBox { Text = "0.00000", Width = 100, FontSize = 15, Padding = new Thickness(5), Margin = new Thickness(0, 0, 8, 8) }; range.Children.Add(selectionTo);
+            range.Children.Add(WorkspaceUi.Button("Set range", delegate { if (ReadSelection()) { clipSelection = false; selectedIds.Clear(); playhead = from; DrawCanvas(); } }));
+            selectionText = WorkspaceUi.Text("Drag the upper ruler to move the playhead. Drag across a track to select time; blue handles adjust the range. Home goes to the start.", 13); selectionText.Foreground = WorkspaceUi.Color("#526771"); selectionText.Margin = new Thickness(0, 0, 0, 8); tools.Children.Add(selectionText);
+
+            tools.Children.Remove(selectionText);
+            var viewControls = new DockPanel { LastChildFill = true, Margin = new Thickness(0, 0, 0, 3) }; tools.Children.Add(viewControls);
+            var zoomTools = new StackPanel { Orientation = Orientation.Horizontal, Name = "EditorZoomControls" }; DockPanel.SetDock(zoomTools, Dock.Right); viewControls.Children.Add(zoomTools);
+            zoomTools.Children.Add(WorkspaceUi.Text("Zoom ", 12));
+            var zoomOut = WorkspaceUi.Button("-", delegate { ZoomStep(.5); }); zoomOut.Name = "EditorZoomOut"; zoomOut.Width = 28; zoomOut.MinHeight = 26; zoomOut.Padding = new Thickness(4, 1, 4, 1); zoomOut.ToolTip = "Zoom out (Ctrl+-)"; zoomTools.Children.Add(zoomOut);
+            zoomSlider = new Slider { Minimum = Math.Log(TimelineZoom.Minimum, 2), Maximum = Math.Log(TimelineZoom.Maximum, 2), Value = Math.Log(pixelsPerSecond, 2), Width = 96, VerticalAlignment = VerticalAlignment.Center, Margin = new Thickness(0, 0, 6, 6), IsMoveToPointEnabled = true, ToolTip = "Timeline zoom" };
+            zoomSlider.ValueChanged += delegate { if (!updatingZoom) SetZoom(Math.Pow(2, zoomSlider.Value), ZoomAnchor()); }; zoomTools.Children.Add(zoomSlider);
+            var zoomIn = WorkspaceUi.Button("+", delegate { ZoomStep(2); }); zoomIn.Name = "EditorZoomIn"; zoomIn.Width = 28; zoomIn.MinHeight = 26; zoomIn.Padding = new Thickness(4, 1, 4, 1); zoomIn.ToolTip = "Zoom in (Ctrl+=)"; zoomTools.Children.Add(zoomIn);
+            zoomSpan = WorkspaceUi.Text("", 12); zoomSpan.Width = 72; zoomSpan.Margin = new Thickness(0, 0, 6, 6); zoomSpan.TextAlignment = TextAlignment.Right; zoomSpan.TextWrapping = TextWrapping.NoWrap; zoomTools.Children.Add(zoomSpan);
+            var fitProject = WorkspaceUi.Button("Fit", delegate { FitZoom(false); }); fitProject.Name = "EditorZoomFit"; fitProject.MinHeight = 26; fitProject.Padding = new Thickness(7, 1, 7, 1); fitProject.ToolTip = "Fit project (Ctrl+0)"; zoomTools.Children.Add(fitProject);
+            fitSelection = WorkspaceUi.Button("Selection", delegate { FitZoom(true); }); fitSelection.Name = "EditorZoomSelection"; fitSelection.MinHeight = 26; fitSelection.Padding = new Thickness(7, 1, 7, 1); fitSelection.ToolTip = "Fit selected time range (Ctrl+Shift+0)"; zoomTools.Children.Add(fitSelection);
+            selectionText.Margin = new Thickness(0, 0, 8, 6); selectionText.TextWrapping = TextWrapping.NoWrap; viewControls.Children.Add(selectionText);
+
+            var body = new Grid { Background = WorkspaceUi.Color("#FFFFFF") }; SetRow(body, 2); editorBody.Children.Add(body);
+            body.ColumnDefinitions.Add(new ColumnDefinition { Width = new GridLength(180) }); body.ColumnDefinitions.Add(new ColumnDefinition());
+            headers = new StackPanel();
+            headerScroll = new ScrollViewer { Content = headers, VerticalScrollBarVisibility = ScrollBarVisibility.Hidden, HorizontalScrollBarVisibility = ScrollBarVisibility.Disabled };
+            body.Children.Add(headerScroll);
+            timeline = new Canvas { Background = WorkspaceUi.Color("#F7FAF9"), ClipToBounds = true, Cursor = Cursors.Arrow, Focusable = true };
+            playLine = new Line { Stroke = WorkspaceUi.Color("#D0772C"), StrokeThickness = 2, IsHitTestVisible = false };
+            selectionOverlay = new Rectangle { Fill = WorkspaceUi.Color("#5596C8"), Opacity = .2, IsHitTestVisible = false };
+            selectionStartLine = new Line { Stroke = WorkspaceUi.Color("#277FA5"), StrokeThickness = 1.15, IsHitTestVisible = false };
+            selectionEndLine = new Line { Stroke = WorkspaceUi.Color("#386BA8"), StrokeThickness = 1.15, IsHitTestVisible = false };
+            selectionStartHandle = new Polygon { Fill = selectionStartLine.Stroke, IsHitTestVisible = false }; selectionEndHandle = new Polygon { Fill = selectionEndLine.Stroke, IsHitTestVisible = false };
+            scroll = new ScrollViewer { Content = timeline, HorizontalScrollBarVisibility = ScrollBarVisibility.Auto, VerticalScrollBarVisibility = ScrollBarVisibility.Auto, CanContentScroll = false };
+            SetColumn(scroll, 1); body.Children.Add(scroll);
+            scroll.ScrollChanged += delegate(object sender, ScrollChangedEventArgs e) { headerScroll.ScrollToVerticalOffset(scroll.VerticalOffset); if (Math.Abs(e.HorizontalChange) > .01 || Math.Abs(e.ViewportWidthChange) > .01) DrawCanvas(); };
+            scroll.PreviewMouseWheel += delegate(object sender, MouseWheelEventArgs e) {
+                if ((Keyboard.Modifiers & ModifierKeys.Control) != 0) {
+                    if (gesture.Mode == TimelineDrag.None) SetZoom(pixelsPerSecond * Math.Pow(2, e.Delta / 480.0), e.GetPosition(scroll).X);
+                    e.Handled = true;
+                }
+                else if ((Keyboard.Modifiers & ModifierKeys.Shift) != 0) { manualViewUntil = DateTime.UtcNow.AddSeconds(2); scroll.ScrollToHorizontalOffset(scroll.HorizontalOffset - e.Delta); e.Handled = true; }
+            };
+            headerScroll.PreviewMouseWheel += delegate(object sender, MouseWheelEventArgs e) { scroll.ScrollToVerticalOffset(scroll.VerticalOffset - e.Delta); e.Handled = true; };
+            timeline.MouseLeftButtonDown += BeginSelection;
+            timeline.MouseMove += delegate(object sender, MouseEventArgs e) {
+                var point = e.GetPosition(timeline);
+                if (clipDrag != ClipDrag.None) { PreviewClipDrag(point); return; }
+                if (gesture.Mode == TimelineDrag.None) { UpdateClipCursor(point); return; }
+                MovePointer(point.X);
+            };
+            timeline.MouseLeftButtonUp += delegate(object sender, MouseButtonEventArgs e) {
+                if (clipDrag != ClipDrag.None) { PreviewClipDrag(e.GetPosition(timeline)); FinishClipDrag(); timeline.ReleaseMouseCapture(); e.Handled = true; return; }
+                if (gesture.Mode == TimelineDrag.None) return;
+                EndPointer(e.GetPosition(timeline).X); timeline.ReleaseMouseCapture(); e.Handled = true;
+            };
+            timeline.LostMouseCapture += delegate { if (clipDrag != ClipDrag.None) CancelClipDrag(); if (gesture.Mode != TimelineDrag.None) { gesture.Finish(); ApplyGesture(); RefreshClipBounds(); DrawCanvas(); } };
+
+            InitializeClipTools(editing);
+            var bottom = new StackPanel { Margin = new Thickness(0, 12, 0, 0) }; SetRow(bottom, 3); editorBody.Children.Add(bottom);
+            var transport = new WrapPanel(); bottom.Children.Add(transport);
+            play = WorkspaceUi.Button("Play", delegate { PlayPause(); }); play.MinWidth = 90; transport.Children.Add(play);
+            transport.Children.Add(WorkspaceUi.Button("Stop", delegate { if (recording && StopRequested != null) StopRequested(); else { Stop(); UpdateTransport(); } }));
+            transport.Children.Add(WorkspaceUi.Button("To start", delegate { Stop(); playhead = 0; DrawCanvas(); EnsurePlayheadVisible(); }));
+            positionText = WorkspaceUi.Text("00:00.00 / 00:00.00", 16); positionText.FontFamily = new FontFamily("Consolas"); positionText.Margin = new Thickness(0, 0, 14, 8); transport.Children.Add(positionText);
+            transport.Children.Add(WorkspaceUi.Text("Listen volume  ", 14));
+            volume = new Slider { Minimum = 0, Maximum = 100, Value = 75, Width = 120, Margin = new Thickness(0, 0, 16, 8), VerticalAlignment = VerticalAlignment.Center };
+            volume.ValueChanged += delegate { output.Volume((float)(volume.Value / 100)); }; transport.Children.Add(volume);
+            outputPicker = new AudioOutputPicker(delegate { Stop(); }, status); bottom.Children.Add(outputPicker);
+            var exports = new WrapPanel(); bottom.Children.Add(exports);
+            exportDetails = exports;
+            var rateLabel = WorkspaceUi.Text("44.1 kHz mix  ", 13); rateLabel.Margin = new Thickness(0, 0, 0, 8); exports.Children.Add(rateLabel);
+            exportFormat = new ComboBox { ItemsSource = new[] { "24-bit PCM WAV", "16-bit PCM WAV", "32-bit float WAV" }, SelectedIndex = 0, MinHeight = 36, Width = 175, FontSize = 14, Padding = new Thickness(6), Margin = new Thickness(0, 0, 12, 0) }; exports.Children.Add(exportFormat);
+            protect = new CheckBox { Content = "Prevent clipping (PCM)", IsChecked = true, FontSize = 14, VerticalAlignment = VerticalAlignment.Center, Margin = new Thickness(0, 0, 15, 0) }; exports.Children.Add(protect);
+            selectionOnly = new CheckBox { Content = "Selection only", FontSize = 14, VerticalAlignment = VerticalAlignment.Center, Margin = new Thickness(0, 0, 15, 0) }; exports.Children.Add(selectionOnly);
+            AddFileButton(exports, "Export mix…", async delegate { await ExportMix(); });
+            ArrangeCompactChrome(top, editing, range, viewControls, zoomTools, bottom, transport, exports);
+            timer = new DispatcherTimer { Interval = TimeSpan.FromMilliseconds(80) };
+            timer.Tick += delegate { if (output.Playing || output.Paused) { playhead = (long)Math.Round(output.Position * Audio.Rate); UpdateTransport(); UpdatePlayLine(); if (output.Playing && DateTime.UtcNow >= manualViewUntil) EnsurePlayheadVisible(); } }; timer.Start();
+            waveformDetail = new WaveformDetail(Dispatcher, delegate { if (!disposed) DrawCanvas(); });
+            UpdateSelectionText(); BuildHeaders(); DrawCanvas();
+            recordingPane = new DockablePane(editorBody, null, "Record options", false, false, 260) { MinimumMainHeight = 300 }; Children.Add(recordingPane);
+            editorBody.SizeChanged += delegate { UpdateCompactLayout(); };
+        }
+
+        private void UpdateCompactLayout()
+        {
+            double width = editorBody.ActualWidth > 0 ? editorBody.ActualWidth : 1280;
+            bool compact = width < 1000 || (editorBody.ActualHeight > 0 && editorBody.ActualHeight < 480);
+            compactOptionsButton.Visibility = Visibility.Visible;
+            outputPicker.Visibility = separate.Visibility = Visibility.Visible;
+            exportDetails.Visibility = compactOptions ? Visibility.Visible : Visibility.Collapsed;
+            gridTriplet.Visibility = rulerMode.Visibility = meterText.Visibility = compact ? Visibility.Collapsed : Visibility.Visible;
+            title.FontSize = 14;
+            zoomSpan.Visibility = width < 700 ? Visibility.Collapsed : Visibility.Visible;
+            zoomSlider.Width = width < 700 ? 64 : 80;
+            selectionText.TextWrapping = TextWrapping.NoWrap;
+            selectionText.TextTrimming = TextTrimming.CharacterEllipsis;
+        }
+
+        private void AddFileButton(Panel panel, string text, Action action)
+        { var button = WorkspaceUi.Button(text, action); panel.Children.Add(button); fileButtons.Add(button); }
+        public bool ApplyGridOptions(TempoGridOptions value)
+        {
+            if (value.Signature() == session.Grid.Signature()) return true;
+            if (IsBusy) return false;
+            value.Validate(); var copy = value.Copy();
+            Change(delegate { session.Grid = copy; return true; }, "Grid: " + copy.Tempo.ToString("0.###", CultureInfo.InvariantCulture) + " BPM, " + copy.BeatsPerBar + "/" + copy.BeatUnit + ", 1/" + copy.Division + (copy.Triplet ? " triplets." : "."));
+            return true;
+        }
+        public void RefreshGridPreferences() { DrawCanvas(); }
+        private bool CommitTempo()
+        {
+            if (updating || !tempoEdited) return true;
+            double value;
+            try {
+                if (!TempoGrid.TryTempo(tempoBox.Text, out value)) throw new IOException("Enter a tempo between 20 and 400 BPM.");
+                var options = session.Grid.Copy(); options.Tempo = value; options.Validate();
+                bool applied = ApplyGridOptions(options); if (applied) tempoEdited = false; return applied;
+            }
+            catch (Exception ex) { tempoBox.Text = session.Grid.Tempo.ToString("0.###", CultureInfo.InvariantCulture); tempoEdited = false; status(ex.Message); return false; }
+        }
+        private void SaveSnapChoices()
+        {
+            if (updating) return;
+            var value = InterfacePreferences.Current.Copy(); value.SnapToGrid = snapGrid.IsChecked == true; value.SnapToEdges = snapEdges.IsChecked == true;
+            try { InterfacePreferences.Save(value); } catch (Exception ex) { status(ex.Message); }
+            RefreshGridToolbar(); DrawCanvas();
+        }
+        private void RefreshGridToolbar()
+        {
+            bool previous = updating; updating = true;
+            try {
+                if (!tempoBox.IsKeyboardFocusWithin) { tempoBox.Text = session.Grid.Tempo.ToString("0.###", CultureInfo.InvariantCulture); tempoEdited = false; }
+                meterText.Text = session.Grid.BeatsPerBar + "/" + session.Grid.BeatUnit + "  ";
+                gridDivision.SelectedItem = "1/" + session.Grid.Division; gridTriplet.IsChecked = session.Grid.Triplet;
+                rulerMode.SelectedIndex = session.Grid.MusicalRuler ? 0 : 1;
+                snapGrid.IsChecked = InterfacePreferences.Current.SnapToGrid; snapEdges.IsChecked = InterfacePreferences.Current.SnapToEdges;
+                gridControls.IsEnabled = !IsBusy;
+            }
+            finally { updating = previous; }
+        }
+        private long FrameAt(double x) { return Math.Max(0, Math.Min(EditorSession.MaxFrame, (long)Math.Round(x / pixelsPerSecond * Audio.Rate))); }
+        private long PointerFrame(double x)
+        { return TimelineGesture.FrameAt(x, pixelsPerSecond, session.Regions.SelectMany(r => new[] { r.Start, r.End }), (Keyboard.Modifiers & ModifierKeys.Alt) != 0, session.Grid, InterfacePreferences.Current.SnapToGrid, InterfacePreferences.Current.SnapToEdges); }
+        private void ApplyGesture() { playhead = gesture.Playhead; from = gesture.From; to = gesture.To; UpdateSelectionText(); UpdateSelectionOverlay(); RefreshRegionHighlights(); UpdatePlayLine(); UpdateTransport(); }
+        private double X(long frame) { return frame / (double)Audio.Rate * pixelsPerSecond; }
+        private double ViewportWidth { get { return scroll != null && scroll.ViewportWidth > 0 ? scroll.ViewportWidth : 900; } }
+        private double ZoomAnchor()
+        {
+            double x = X(playhead) - scroll.HorizontalOffset;
+            return x >= 0 && x <= ViewportWidth ? x : ViewportWidth / 2;
+        }
+        private void ZoomStep(double factor) { SetZoom(pixelsPerSecond * factor, ZoomAnchor()); }
+        private void SetZoom(double value, double pointer)
+        {
+            if (scroll == null || gesture.Mode != TimelineDrag.None || clipDrag != ClipDrag.None || disposed) return;
+            double scale = TimelineZoom.Clamp(value), at = Math.Max(0, Math.Min(ViewportWidth, pointer));
+            double offset = TimelineZoom.Offset(pixelsPerSecond, scale, scroll.HorizontalOffset, at);
+            pixelsPerSecond = scale; manualViewUntil = DateTime.UtcNow.AddSeconds(2);
+            DrawCanvas(); scroll.UpdateLayout(); scroll.ScrollToHorizontalOffset(offset); scroll.UpdateLayout(); DrawCanvas();
+        }
+        private void FitZoom(bool selected)
+        {
+            if (gesture.Mode != TimelineDrag.None) return;
+            if (selected && to <= from) return;
+            long start = selected ? from : 0, end = selected ? to : session.End > 0 ? session.End : Audio.Rate * 15L;
+            SetZoom(TimelineZoom.Fit(end - start, ViewportWidth), 0);
+            scroll.ScrollToHorizontalOffset(Math.Max(0, X(start) - 16)); scroll.UpdateLayout(); DrawCanvas();
+        }
+        private void RefreshZoomControls()
+        {
+            updatingZoom = true; zoomSlider.Value = Math.Log(pixelsPerSecond, 2); updatingZoom = false;
+            double span = ViewportWidth / pixelsPerSecond;
+            zoomSpan.Text = span >= 3600 ? (span / 3600).ToString("0.#", CultureInfo.InvariantCulture) + " h" : span >= 60 ? (span / 60).ToString("0.#", CultureInfo.InvariantCulture) + " min" : span < 1 ? (span * 1000).ToString("0.##", CultureInfo.InvariantCulture) + " ms" : span.ToString("0.##", CultureInfo.InvariantCulture) + " s";
+            fitSelection.IsEnabled = to > from;
+        }
+        private void UpdateSelectionText()
+        {
+            selectionFrom.Text = (from / (double)Audio.Rate).ToString("0.00000", CultureInfo.InvariantCulture);
+            selectionTo.Text = (to / (double)Audio.Rate).ToString("0.00000", CultureInfo.InvariantCulture);
+            selectionText.Text = "Track " + (track + 1) + " | Selection " + (from / (double)Audio.Rate).ToString("0.00000", CultureInfo.InvariantCulture) + " – " + (to / (double)Audio.Rate).ToString("0.00000", CultureInfo.InvariantCulture) + " s";
+            if (fitSelection != null) fitSelection.IsEnabled = to > from;
+            if (clipSelection) selectionText.Text = selectedIds.Count == 1 ? "1 clip selected" : selectedIds.Count + " clips selected";
+            selectionText.Visibility = to > from || clipSelection ? Visibility.Visible : Visibility.Collapsed;
+        }
+        private bool ReadSelection()
+        {
+            double a, b;
+            if (!double.TryParse(selectionFrom.Text, NumberStyles.Float, CultureInfo.InvariantCulture, out a) || !double.TryParse(selectionTo.Text, NumberStyles.Float, CultureInfo.InvariantCulture, out b) ||
+                double.IsNaN(a) || double.IsNaN(b) || double.IsInfinity(a) || double.IsInfinity(b) || a < 0 || b < a || b > 86400) {
+                status("Enter a valid selection start and end in seconds."); return false;
+            }
+            from = (long)Math.Round(a * Audio.Rate); to = (long)Math.Round(b * Audio.Rate); DrawCanvas(); return true;
+        }
+        private void BeginSelection(object sender, MouseButtonEventArgs e)
+        {
+            if (IsBusy) return; Stop(); timeline.Focus();
+            BeginPointer(e.GetPosition(timeline), (Keyboard.Modifiers & ModifierKeys.Shift) != 0, e.ClickCount);
+            if (gesture.Mode != TimelineDrag.None || clipDrag != ClipDrag.None) timeline.CaptureMouse(); e.Handled = true;
+        }
+        private void BeginPointer(Point point, bool additive, int clicks)
+        {
+            previousIds = selectedIds.ToArray(); previousClipSelection = clipSelection; previousTrack = track;
+            previousFrom = from; previousTo = to; previousPlayhead = playhead;
+            long frame = PointerFrame(point.X); pendingRegion = null; selectionMoved = false;
+            if (point.Y < RulerHeight) {
+                var mode = TimelineGesture.RulerHit(point.X, point.Y, X(from), X(to), to > from);
+                if (mode != TimelineDrag.Playhead) { clipSelection = false; selectedIds.Clear(); }
+                gesture.Begin(mode, frame, playhead, from, to); ApplyGesture(); return;
+            }
+            track = Math.Max(0, Math.Min(15, (int)((point.Y - RulerHeight) / RowHeight)));
+            var region = RegionAt(point);
+            if (sliceCursor) { playhead = frame; Change(() => TimelineEdits.Split(session, track, false, frame), "Split at the cursor."); return; }
+            if (region != null && !additive && clicks == 1) { var tool = ClipToolAt(region, point); if (tool != ClipDrag.None) { BeginClipDrag(tool, region, point); return; } }
+            if (additive && region != null) { playhead = frame; SelectRegion(region, true); BuildHeaders(); DrawCanvas(); return; }
+            if (clicks == 2 && region != null) { playhead = region.Start; SelectRegion(region, false); BuildHeaders(); DrawCanvas(); return; }
+            selectionPointerX = point.X; pendingRegion = region == null ? null : region.Id;
+            selectedIds.Clear(); clipSelection = region != null; if (region != null) selectedIds.Add(region.Id);
+            gesture.Begin(TimelineDrag.Selection, frame, playhead, from, to); gesture.Playhead = frame;
+            ApplyGesture(); BuildHeaders(); DrawCanvas();
+        }
+        private void MovePointer(double x)
+        {
+            if (gesture.Mode == TimelineDrag.Selection && Math.Abs(x - selectionPointerX) >= 3) {
+                if (!selectionMoved) { selectionMoved = true; clipSelection = false; selectedIds.Clear(); DrawCanvas(); }
+            }
+            gesture.Move(PointerFrame(x)); ApplyGesture();
+        }
+        private void EndPointer(double x)
+        {
+            var mode = gesture.Mode; MovePointer(x); gesture.End(PointerFrame(x)); ApplyGesture();
+            if (mode == TimelineDrag.Selection && !selectionMoved && pendingRegion != null) {
+                var region = session.Regions.FirstOrDefault(r => r.Id == pendingRegion); if (region != null) SelectRegion(region, false);
+            }
+            else if (mode == TimelineDrag.Selection && to > from) playhead = from;
+            pendingRegion = null; UpdateSelectionText(); BuildHeaders(); DrawCanvas();
+        }
+        private void SelectRegion(TimelineRegion region, bool additive)
+        {
+            if (!additive) selectedIds.Clear();
+            if (!selectedIds.Add(region.Id)) selectedIds.Remove(region.Id);
+            clipSelection = selectedIds.Count > 0;
+            var selected = session.Regions.Where(r => selectedIds.Contains(r.Id)).ToArray();
+            from = selected.Length == 0 ? playhead : selected.Min(r => r.Start);
+            to = selected.Length == 0 ? playhead : selected.Max(r => r.End); UpdateSelectionText();
+        }
+        private bool RegionSelected(TimelineRegion region)
+        { return clipSelection ? selectedIds.Contains(region.Id) : to > from && region.Start < to && region.End > from && (AllTracks || region.Track == track); }
+        private void RefreshRegionHighlights()
+        {
+            foreach (var visual in regionVisuals) {
+                bool selected = RegionSelected(visual.Region), muted = visual.Region.Muted || session.Tracks[visual.Region.Track].Mute;
+                visual.Body.Fill = WorkspaceUi.Color(selected ? "#DAD5FA" : muted ? "#CBD8D4" : "#B9DDD2");
+                visual.Body.Stroke = WorkspaceUi.Color(selected ? "#7359C7" : "#5E9D89");
+                visual.Body.StrokeThickness = selected ? 1.7 : 1; visual.Body.Tag = selected ? "SelectedRegion" : null;
+                visual.Glow.Visibility = selected ? Visibility.Visible : Visibility.Collapsed;
+            }
+        }
+        private void RefreshClipBounds()
+        {
+            if (!clipSelection) return;
+            var picked = session.Regions.Where(r => selectedIds.Contains(r.Id)).ToArray();
+            if (picked.Length == 0) { selectedIds.Clear(); clipSelection = false; from = to = playhead; }
+            else { from = picked.Min(r => r.Start); to = picked.Max(r => r.End); if (!picked.Any(r => r.Track == track)) track = picked[0].Track; }
+            UpdateSelectionText();
+        }
+        private void BuildHeaders()
+        {
+            updating = true; headers.Children.Clear();
+            headers.Children.Add(new Border { Height = RulerHeight, Background = WorkspaceUi.Color("#E4ECEA"), Child = WorkspaceUi.Text("  TRACKS / LEVEL", 12) });
+            for (int i = 0; i < 16; i++) {
+                int index = i; var state = session.Tracks[i];
+                var panel = new StackPanel { Margin = new Thickness(7, 3, 7, 3) };
+                var name = WorkspaceUi.Text((i + 1).ToString("00") + "  " + state.Name, 14); name.TextWrapping = TextWrapping.NoWrap; name.TextTrimming = TextTrimming.CharacterEllipsis; name.FontWeight = FontWeights.SemiBold; panel.Children.Add(name);
+                var strip = new StackPanel { Orientation = Orientation.Horizontal, Margin = new Thickness(0, 3, 0, 0) }; panel.Children.Add(strip);
+                var mute = new ToggleButton { Content = "M", IsChecked = state.Mute, Width = 28, Height = 26, FontSize = 12, Margin = new Thickness(0, 0, 4, 0), ToolTip = "Mute track " + (i + 1) };
+                mute.Click += delegate { if (!updating) Change(delegate { session.Tracks[index].Mute = mute.IsChecked == true; return true; }, "Track mute changed."); }; strip.Children.Add(mute);
+                var solo = new ToggleButton { Content = "S", IsChecked = state.Solo, Width = 28, Height = 26, FontSize = 12, Margin = new Thickness(0, 0, 6, 0), ToolTip = "Solo track " + (i + 1) };
+                solo.Click += delegate { if (!updating) Change(delegate { session.Tracks[index].Solo = solo.IsChecked == true; return true; }, "Track solo changed."); }; strip.Children.Add(solo);
+                var levels = new[] { -60.0, -24, -18, -12, -6, 0, 3, 6, 12, state.GainDb }.Distinct().OrderBy(v => v).ToArray();
+                var level = new ComboBox { ItemsSource = levels.Select(v => v.ToString("0.#", CultureInfo.InvariantCulture) + " dB").ToArray(), SelectedIndex = Array.IndexOf(levels, state.GainDb), Width = 102, MinHeight = 26, Height = 26, FontSize = 12, Padding = new Thickness(3, 0, 3, 0), ToolTip = "Track playback / export level" };
+                level.SelectionChanged += delegate { if (!updating && level.SelectedIndex >= 0) { double value = levels[level.SelectedIndex]; Change(delegate { session.Tracks[index].GainDb = value; return true; }, "Track level changed."); } }; strip.Children.Add(level);
+                var border = new Border { Height = RowHeight, BorderThickness = new Thickness(0, 0, 1, 1), BorderBrush = WorkspaceUi.Color("#D6E1DF"), Background = WorkspaceUi.Color(i == track ? "#DCEFEB" : "#EDF3F1"), Child = panel };
+                border.PreviewMouseLeftButtonDown += delegate { if (!IsBusy && track != index) { track = index; UpdateSelectionText(); } };
+                border.MouseLeftButtonUp += delegate { BuildHeaders(); DrawCanvas(); };
+                headers.Children.Add(border);
+            }
+            updating = false;
+        }
+        private void DrawCanvas()
+        {
+            if (timeline == null || disposed) return;
+            timeline.Children.Clear(); regionVisuals.Clear(); timeline.Height = RulerHeight + RowHeight * 16;
+            timeline.Width = Math.Max(Math.Max(900, scroll.ViewportWidth), X(Math.Max(session.End, Math.Max(to, playhead)) + Audio.Rate * 15L));
+            double left = scroll.HorizontalOffset, right = left + Math.Max(900, scroll.ViewportWidth);
+            waveformDetail.BeginView(left.ToString("R", CultureInfo.InvariantCulture) + "|" + right.ToString("R", CultureInfo.InvariantCulture) + "|" + pixelsPerSecond.ToString("R", CultureInfo.InvariantCulture));
+            for (int i = 0; i < 16; i++) {
+                var row = new Rectangle { Width = Math.Max(900, scroll.ViewportWidth), Height = RowHeight, Fill = WorkspaceUi.Color(i == track ? "#F0F8F5" : i % 2 == 0 ? "#FCFDFC" : "#F4F8F6"), Stroke = WorkspaceUi.Color("#E0E8E5"), StrokeThickness = .5, IsHitTestVisible = false };
+                Canvas.SetLeft(row, left); Canvas.SetTop(row, RulerHeight + i * RowHeight); timeline.Children.Add(row);
+            }
+            foreach (var region in session.Regions.Where(r => X(r.End) >= left && X(r.Start) <= right)) DrawRegion(region, left, right);
+            RefreshGridToolbar();
+            RefreshZoomControls();
+            bool visibleLabel = false;
+            if (session.Grid.MusicalRuler) foreach (var tick in TempoGrid.VisibleTicks(session.Grid, left, right - left, pixelsPerSecond)) {
+                double x = X(tick.Frame);
+                timeline.Children.Add(new Line { X1 = x, X2 = x, Y1 = tick.Kind == 0 ? RulerHeight : 0, Y2 = timeline.Height,
+                    Stroke = WorkspaceUi.Color(tick.Kind == 2 ? "#386BA8" : tick.Kind == 1 ? "#D6E1DF" : "#E0E8E5"), Opacity = tick.Kind == 2 ? .48 : tick.Kind == 1 ? .7 : .45, StrokeThickness = tick.Kind == 2 ? 1 : .5, IsHitTestVisible = false });
+                if (tick.Label != null) { if (x >= left && x < left + ViewportWidth) visibleLabel = true; var label = WorkspaceUi.Text(tick.Label, 11); label.IsHitTestVisible = false; Canvas.SetLeft(label, x + 4); Canvas.SetTop(label, 3); timeline.Children.Add(label); }
+            }
+            if (!session.Grid.MusicalRuler || !visibleLabel) DrawTimeRuler(left, right);
+            timeline.Children.Add(selectionOverlay); timeline.Children.Add(selectionStartLine); timeline.Children.Add(selectionEndLine); timeline.Children.Add(selectionStartHandle); timeline.Children.Add(selectionEndHandle); UpdateSelectionOverlay();
+            playLine.Y1 = 0; playLine.Y2 = timeline.Height; timeline.Children.Add(playLine); UpdatePlayLine(); UpdateTransport();
+            undoButton.IsEnabled = !IsBusy && undo.Count > 0; redoButton.IsEnabled = !IsBusy && redo.Count > 0;
+            title.Text = session.Name + (dirty ? " *" : "");
+        }
+        private void UpdateSelectionOverlay()
+        {
+            if (selectionOverlay == null) return;
+            var visibility = to > from ? Visibility.Visible : Visibility.Collapsed;
+            foreach (var item in new UIElement[] { selectionOverlay, selectionStartLine, selectionEndLine, selectionStartHandle, selectionEndHandle }) item.Visibility = visibility;
+            if (to <= from) return;
+            double left = scroll.HorizontalOffset, right = left + Math.Max(900, scroll.ViewportWidth), a = Math.Max(left, X(from)), b = Math.Min(right, X(to));
+            if (clipSelection) selectionOverlay.Visibility = Visibility.Collapsed;
+            selectionOverlay.Width = Math.Max(0, b - a); selectionOverlay.Height = AllTracks ? RowHeight * 16 : RowHeight;
+            Canvas.SetLeft(selectionOverlay, a); Canvas.SetTop(selectionOverlay, RulerHeight + (AllTracks ? 0 : track * RowHeight));
+            UpdateRangeStick(selectionStartLine, selectionStartHandle, X(from), true); UpdateRangeStick(selectionEndLine, selectionEndHandle, X(to), false);
+        }
+        private void DrawTimeRuler(double left, double right)
+        {
+            double spacing = TimelineZoom.SecondStep(pixelsPerSecond);
+            for (double second = Math.Floor(left / pixelsPerSecond / spacing) * spacing; second * pixelsPerSecond < right; second += spacing) {
+                double x = second * pixelsPerSecond;
+                timeline.Children.Add(new Line { X1 = x, X2 = x, Y1 = 0, Y2 = timeline.Height, Stroke = WorkspaceUi.Color("#DAE5E0"), StrokeThickness = .6, Opacity = .65, IsHitTestVisible = false });
+                string time = spacing >= 1 ? WorkspaceUi.Clock(second) : second.ToString("F" + Math.Max(1, (int)Math.Ceiling(-Math.Log10(spacing))), CultureInfo.InvariantCulture) + " s";
+                var label = WorkspaceUi.Text(time, 11); label.IsHitTestVisible = false; Canvas.SetLeft(label, x + 4); Canvas.SetTop(label, 3); timeline.Children.Add(label);
+            }
+        }
+        private void UpdateRangeStick(Line line, Polygon handle, double x, bool start)
+        {
+            line.X1 = line.X2 = x; line.Y1 = 14; line.Y2 = timeline.Height;
+            handle.Points.Clear(); handle.Points.Add(new Point(x, 14)); handle.Points.Add(new Point(x + (start ? 9 : -9), 14)); handle.Points.Add(new Point(x, 25));
+        }
+        private void DrawRegion(TimelineRegion region, double left, double right)
+        {
+            double x = Math.Max(left, X(region.Start)), end = Math.Min(right, X(region.End)), y = RulerHeight + region.Track * RowHeight + 3;
+            double width = Math.Max(2, end - x); bool muted = region.Muted || session.Tracks[region.Track].Mute, selected = RegionSelected(region);
+            var rectangle = new Rectangle { Width = width, Height = RowHeight - 6, RadiusX = 5, RadiusY = 5, Fill = WorkspaceUi.Color(selected ? "#DAD5FA" : muted ? "#CBD8D4" : "#B9DDD2"), Stroke = WorkspaceUi.Color(selected ? "#7359C7" : "#5E9D89"), StrokeThickness = selected ? 1.7 : 1, Tag = selected ? "SelectedRegion" : null, IsHitTestVisible = false };
+            var glow = new Rectangle { Width = width + 2, Height = RowHeight - 4, RadiusX = 6, RadiusY = 6, Stroke = WorkspaceUi.Color("#7359C7"), StrokeThickness = 4, Opacity = .28, IsHitTestVisible = false, Visibility = selected ? Visibility.Visible : Visibility.Collapsed }; Canvas.SetLeft(glow, x - 1); Canvas.SetTop(glow, y - 1); timeline.Children.Add(glow);
+            Canvas.SetLeft(rectangle, x); Canvas.SetTop(rectangle, y); timeline.Children.Add(rectangle);
+            regionVisuals.Add(new RegionVisual { Region = region, Body = rectangle, Glow = glow });
+            Clip clip;
+            if (assets.TryGetValue(region.Source, out clip) && clip.Waveform != null && width > 2) {
+                long sourceStart = region.SourceStart + (long)Math.Floor((x - X(region.Start)) / pixelsPerSecond * Audio.Rate);
+                long sourceEnd = Math.Min(region.SourceStart + region.Length, region.SourceStart + (long)Math.Ceiling((end - X(region.Start)) / pixelsPerSecond * Audio.Rate));
+                var detail = pixelsPerSecond * clip.Duration / clip.Waveform.Length > 1 ? waveformDetail.Get(clip.Cache, sourceStart, sourceEnd, Math.Max(2, Math.Min(2000, (int)Math.Ceiling(width)))) : null;
+                int points = detail == null ? Math.Max(2, Math.Min(400, (int)(width / 2))) : detail.Low.Length;
+                var wave = new Polygon { Fill = WorkspaceUi.Color("#438B77"), Stroke = detail == null ? null : WorkspaceUi.Color("#438B77"), StrokeThickness = .8, Opacity = .7, IsHitTestVisible = false, Tag = detail == null ? "WaveformOverview" : "WaveformDetail" };
+                double sourceFrames = Math.Max(1, clip.Duration * Audio.Rate), scale = Math.Max(1, clip.Peak);
+                for (int side = 0; side < 2; side++) for (int p = 0; p < points; p++) {
+                    int j = side == 0 ? p : points - p - 1; double px = x + j * width / (points - 1);
+                    double sourceFrame = region.SourceStart + (px - X(region.Start)) / pixelsPerSecond * Audio.Rate;
+                    int bin = Math.Max(0, Math.Min(clip.Waveform.Length - 1, (int)(sourceFrame / sourceFrames * clip.Waveform.Length)));
+                    double value = detail == null ? clip.Waveform[bin] * (side == 0 ? 1 : -1) : side == 0 ? detail.High[j] : detail.Low[j];
+                    value *= EditorTools.Envelope(region, (long)Math.Round(sourceFrame - region.SourceStart));
+                    wave.Points.Add(new Point(px, y + RowHeight * .65 - value / scale * RowHeight * .22));
+                }
+                timeline.Children.Add(wave);
+            }
+            if (width > 45) {
+                var label = WorkspaceUi.Text(region.Name + (region.Muted ? " · muted" : ""), 12); label.MaxWidth = Math.Max(1, width - 10); label.TextWrapping = TextWrapping.NoWrap; label.TextTrimming = TextTrimming.CharacterEllipsis; label.IsHitTestVisible = false;
+                Canvas.SetLeft(label, x + 5); Canvas.SetTop(label, y + 3); timeline.Children.Add(label);
+            }
+            DrawClipFades(region, left, right, selected);
+        }
+        private void UpdatePlayLine() { playLine.X1 = playLine.X2 = X(playhead); }
+        private void UpdateTransport()
+        { positionText.Text = WorkspaceUi.Clock(playhead / (double)Audio.Rate) + " / " + WorkspaceUi.Clock(session.End / (double)Audio.Rate); }
+        private void EnsurePlayheadVisible()
+        { double x = X(playhead); if (x < scroll.HorizontalOffset || x > scroll.HorizontalOffset + scroll.ViewportWidth - 15) scroll.ScrollToHorizontalOffset(Math.Max(0, x - 30)); }
+
+        private void Change(Func<bool> action, string message)
+        {
+            if (IsBusy) return; Stop(); var before = session.Copy();
+            var oldIds = selectedIds.ToArray(); bool oldMode = clipSelection; long oldFrom = from, oldTo = to; int oldTrack = track;
+            Action restore = delegate { session = before; selectedIds.Clear(); foreach (string id in oldIds) selectedIds.Add(id); clipSelection = oldMode; from = oldFrom; to = oldTo; track = oldTrack; UpdateSelectionText(); BuildHeaders(); DrawCanvas(); };
+            try {
+                if (!action()) { restore(); status("No audio section was changed. Select a clip or a time range first."); return; }
+                session.Validate(); undo.Push(before); redo.Clear(); dirty = true; RefreshClipBounds(); BuildHeaders(); DrawCanvas(); status(message);
+            }
+            catch (Exception ex) { restore(); status(ex.Message); }
+        }
+        private void Undo(bool forward)
+        {
+            if (IsBusy) return; var source = forward ? redo : undo; var target = forward ? undo : redo;
+            if (source.Count == 0) return; Stop(); target.Push(session.Copy()); session = source.Pop(); dirty = true; RefreshClipBounds(); BuildHeaders(); DrawCanvas();
+        }
+        private void Split() { Change(() => TimelineEdits.Split(session, track, AllTracks, playhead, clipSelection ? selectedIds : null), "Split at the playhead."); }
+        private void Copy(bool cut)
+        {
+            RefreshClipBounds();
+            if (IsBusy || !ReadSelection() || to <= from) { status("Select a clip or time range to copy or cut."); return; }
+            bool all = clipSelection ? session.Regions.Where(r => selectedIds.Contains(r.Id)).Select(r => r.Track).Distinct().Count() > 1 : AllTracks;
+            clipboard = TimelineEdits.Copy(session, track, all, from, to, clipSelection ? selectedIds : null);
+            if (clipboard.Regions.Count == 0) { status("There is no audio in this selection."); return; }
+            if (cut) Change(() => TimelineEdits.Delete(session, track, AllTracks, from, to, clipSelection ? selectedIds : null), "Selection cut. Paste inserts it at the playhead.");
+            else status("Copied " + clipboard.Regions.Count + " audio section(s). Click the ruler for the paste position.");
+        }
+        private void DeleteRange()
+        { if (ReadSelection() && to > from) Change(() => TimelineEdits.Delete(session, track, AllTracks, from, to, clipSelection ? selectedIds : null), "Selected audio removed; the timeline gap is kept."); }
+        private void Paste()
+        {
+            Change(delegate {
+                var before = new HashSet<string>(session.Regions.Select(r => r.Id));
+                if (!TimelineEdits.Paste(session, clipboard, track, playhead)) return false;
+                selectedIds.Clear(); foreach (var region in session.Regions.Where(r => !before.Contains(r.Id))) selectedIds.Add(region.Id);
+                clipSelection = true; return true;
+            }, "Audio pasted at the playhead.");
+        }
+
+        private async Task ChooseAudio()
+        {
+            if (IsBusy) return;
+            var dialog = new Microsoft.Win32.OpenFileDialog { Title = "Add audio to the timeline", Filter = WorkspaceUi.AudioFilter, Multiselect = true };
+            if (dialog.ShowDialog(owner) == true) await AddFiles(dialog.FileNames);
+        }
+        public async Task AddFiles(IEnumerable<string> paths)
+        {
+            if (IsBusy || disposed) return; var files = paths.Where(File.Exists).Select(Path.GetFullPath).ToArray(); if (files.Length == 0) return;
+            bool separateTracks = separate.IsChecked == true;
+            if (separateTracks && track + files.Length > 16) { status("Choose at most " + (16 - track) + " files for the remaining tracks, or turn off separate tracks."); return; }
+            Stop(); BeginWork();
+            var decoded = new List<Clip>();
+            try {
+                foreach (string path in files) {
+                    Clip clip; status("Reading " + Path.GetFileName(path) + " for the timeline…");
+                    if (!assets.TryGetValue(path, out clip)) { clip = await Task.Run(() => Audio.Load(path, cache, operation.Token, null)); assets[path] = clip; }
+                    decoded.Add(clip);
+                }
+                operation.Token.ThrowIfCancellationRequested(); var before = session.Copy(); long at = playhead;
+                for (int i = 0; i < decoded.Count; i++) {
+                    var clip = decoded[i]; int index = separateTracks ? track + i : track; long frames = (long)Math.Round(clip.Duration * Audio.Rate);
+                    session.Regions.Add(new TimelineRegion { Track = index, Start = at, Length = frames, Source = clip.Source, Name = Path.GetFileNameWithoutExtension(clip.Name) });
+                    if (session.Tracks[index].Name == "Track " + (index + 1)) session.Tracks[index].Name = Path.GetFileNameWithoutExtension(clip.Name);
+                    if (!separateTracks) at += frames;
+                }
+                try { session.Validate(); } catch { session = before; throw; }
+                undo.Push(before); redo.Clear(); dirty = true; status("Audio added. Drag a time range, then cut, copy, split or paste.");
+            }
+            catch (OperationCanceledException) { status("Import cancelled. Your existing timeline is kept."); }
+            catch (Exception ex) { status("Could not add audio: " + ex.Message); }
+            finally { EndWork(); BuildHeaders(); DrawCanvas(); timeline.Focus(); }
+        }
+        private void BeginWork()
+        { operation = new CancellationTokenSource(); foreach (var button in fileButtons) button.IsEnabled = false; play.IsEnabled = false; cancel.Visibility = Visibility.Visible; RefreshGridToolbar(); }
+        private void EndWork()
+        { operation.Dispose(); operation = null; foreach (var button in fileButtons) button.IsEnabled = true; play.IsEnabled = true; cancel.Visibility = Visibility.Collapsed; RefreshGridToolbar(); }
+        private void NewSession()
+        {
+            if (IsBusy || !ConfirmClose()) return; Stop(); session = new EditorSession { Grid = InterfacePreferences.Current.Grid.Copy() }; sessionPath = null; assets.Clear(); undo.Clear(); redo.Clear(); dirty = false; selectedIds.Clear(); clipSelection = false; from = to = playhead = 0; UpdateSelectionText(); BuildHeaders(); DrawCanvas();
+        }
+        public bool SaveSession(bool saveAs)
+        {
+            if (IsBusy) return false;
+            string path = sessionPath;
+            if (saveAs || string.IsNullOrEmpty(path)) {
+                var dialog = new Microsoft.Win32.SaveFileDialog { Title = "Save the editor session", Filter = "Flux editor session|*.dbedit", DefaultExt = ".dbedit", FileName = session.Name == "Untitled session" ? "Practice.dbedit" : session.Name + ".dbedit" };
+                if (dialog.ShowDialog(owner) != true) return false; path = dialog.FileName;
+            }
+            try { session.Name = Path.GetFileNameWithoutExtension(path); session.Save(path); sessionPath = path; dirty = false; DrawCanvas(); status("Session saved. Keep the original source audio in its current location."); return true; }
+            catch (Exception ex) { status("Could not save the session: " + ex.Message); return false; }
+        }
+        private async Task OpenSession()
+        {
+            if (IsBusy || !ConfirmClose()) return;
+            var dialog = new Microsoft.Win32.OpenFileDialog { Title = "Open an editor session", Filter = "Flux editor session|*.dbedit" };
+            if (dialog.ShowDialog(owner) != true) return; Stop(); BeginWork();
+            try {
+                var loaded = EditorSession.Load(dialog.FileName); var decoded = new Dictionary<string, Clip>(StringComparer.OrdinalIgnoreCase);
+                foreach (var r in loaded.Regions) if (!Path.IsPathRooted(r.Source)) r.Source = Path.GetFullPath(Path.Combine(Path.GetDirectoryName(dialog.FileName), r.Source));
+                foreach (string path in loaded.Regions.Select(r => r.Source).Distinct(StringComparer.OrdinalIgnoreCase)) {
+                    status("Opening " + Path.GetFileName(path) + "…");
+                    if (!File.Exists(path)) throw new IOException("Source audio is missing: " + path);
+                    Clip clip; if (!assets.TryGetValue(path, out clip)) clip = await Task.Run(() => Audio.Load(path, cache, operation.Token, null));
+                    decoded.Add(path, clip);
+                }
+                using (var verify = new TimelineMix(loaded, decoded)) { }
+                operation.Token.ThrowIfCancellationRequested(); session = loaded; assets.Clear(); foreach (var pair in decoded) assets.Add(pair.Key, pair.Value);
+                sessionPath = dialog.FileName; undo.Clear(); redo.Clear(); dirty = false; selectedIds.Clear(); clipSelection = false; from = to = playhead = 0; UpdateSelectionText(); status("Editor session opened.");
+            }
+            catch (OperationCanceledException) { status("Opening cancelled. Your current timeline is kept."); }
+            catch (Exception ex) { status("Could not open this session: " + ex.Message); }
+            finally { EndWork(); BuildHeaders(); DrawCanvas(); }
+        }
+        private async Task ExportMix()
+        {
+            if (IsBusy || session.End <= 0) { status("Add audio to the timeline before exporting."); return; }
+            bool selected = selectionOnly.IsChecked == true;
+            if (selected && (!ReadSelection() || to <= from)) { status("Select the time range to export."); return; }
+            var dialog = new Microsoft.Win32.SaveFileDialog { Title = "Export the timeline mix", Filter = "WAV audio|*.wav", DefaultExt = ".wav", FileName = session.Name + " mix.wav" };
+            if (dialog.ShowDialog(owner) != true) return;
+            if (assets.Keys.Any(p => string.Equals(Path.GetFullPath(p), Path.GetFullPath(dialog.FileName), StringComparison.OrdinalIgnoreCase))) { status("Choose a new file name to preserve the original audio."); return; }
+            Stop(); int bits = new[] { 24, 16, 32 }[exportFormat.SelectedIndex]; bool safe = protect.IsChecked == true;
+            var state = session.Copy(); var decoded = new Dictionary<string, Clip>(assets, StringComparer.OrdinalIgnoreCase); long start = selected ? from : 0, end = selected ? to : session.End;
+            BeginWork();
+            try {
+                await Task.Run(() => TimelineRender.Export(state, decoded, dialog.FileName, bits, safe, start, end, operation.Token, delegate(double p) { Dispatcher.BeginInvoke((Action)delegate { status("Exporting mix: " + (p * 100).ToString("0") + "%"); }); }));
+                status("Saved " + Path.GetFileName(dialog.FileName) + " as " + bits + (bits == 32 ? "-bit float" : "-bit PCM") + " WAV. Original audio is kept.");
+            }
+            catch (OperationCanceledException) { status("Export cancelled. Original files and previous exports are kept."); }
+            catch (Exception ex) { status("Could not export the mix: " + ex.Message); }
+            finally { EndWork(); DrawCanvas(); }
+        }
+        private void PlayPause()
+        {
+            if (IsBusy || session.End <= 0) return;
+            if (output.Playing) { output.Pause(); play.Content = "Resume"; return; }
+            if (output.Paused) { output.Resume(); play.Content = "Pause"; return; }
+            try {
+                beforePlay(); if (playhead >= session.End) playhead = 0;
+                mix = new TimelineMix(session, assets); mix.Seek(playhead);
+                output.Open(mix, playhead / (double)Audio.Rate, (float)(volume.Value / 100), delegate(Exception error) { if (error == null) playhead = session.End; Stop(); DrawCanvas(); if (error != null) status("Editor playback stopped: " + error.Message); }, outputPicker.Selected);
+                play.Content = "Pause";
+            }
+            catch (Exception ex) { Stop(); status("Could not play the timeline: " + ex.Message); }
+        }
+        public void Stop()
+        {
+            if (output.Playing || output.Paused) playhead = (long)Math.Round(output.Position * Audio.Rate);
+            output.Stop(); if (mix != null) { mix.Dispose(); mix = null; } play.Content = "Play";
+        }
+        public void AttachRecordingPanel(FrameworkElement panel)
+        {
+            panel.Margin = new Thickness(10); recordingPane.SetContent(panel);
+            panel.SizeChanged += delegate {
+                var stack = panel as Panel; if (stack == null) return;
+                foreach (var flow in stack.Children.OfType<WrapPanel>())
+                    foreach (var group in flow.Children.OfType<FrameworkElement>()) group.Width = Math.Max(150, Math.Min(266, panel.ActualWidth - 10));
+            };
+        }
+        public void ShowRecordingOptions(bool visible)
+        { if (visible && RecordingOptionsRequested != null) RecordingOptionsRequested(); recordingPane.ShowPane(visible); UpdateCompactLayout(); }
+        internal DockablePane RecordingPaneForTest { get { return recordingPane; } }
+        public void SetRecordingState(bool active)
+        {
+            recording = active; recordButton.Content = active ? "Stop recording" : "Record";
+            RefreshGridToolbar();
+            foreach (var button in fileButtons) button.IsEnabled = !active && operation == null;
+            if (active) { Stop(); ShowRecordingOptions(true); }
+        }
+        public async Task AddRecordedFiles(IEnumerable<string> paths, long at, int firstTrack)
+        {
+            if (IsBusy) throw new IOException("Finish the editor operation before adding the take.");
+            var files = paths.Where(File.Exists).ToArray();
+            if (firstTrack < 0 || firstTrack + files.Length > 16) throw new IOException("Choose enough empty track slots before recording.");
+            BeginWork();
+            try {
+                var decoded = new List<Clip>();
+                foreach (var path in files) { var clip = await Task.Run(() => Audio.Load(path, cache, operation.Token, null)); decoded.Add(clip); assets[path] = clip; }
+                var before = session.Copy();
+                for (int i = 0; i < decoded.Count; i++) {
+                    var clip = decoded[i]; int index = firstTrack + i;
+                    session.Regions.Add(new TimelineRegion { Source = clip.Source, Name = "Take " + Path.GetFileNameWithoutExtension(clip.Name), Track = index, Start = at, Length = (long)Math.Round(clip.Duration * Audio.Rate) });
+                    if (session.Tracks[index].Name == "Track " + (index + 1)) session.Tracks[index].Name = Path.GetFileNameWithoutExtension(clip.Name);
+                }
+                try { session.Validate(); } catch { session = before; throw; }
+                undo.Push(before); redo.Clear(); dirty = true; track = firstTrack; playhead = at;
+            }
+            finally { EndWork(); BuildHeaders(); DrawCanvas(); }
+        }
+        public async Task<bool> ExecuteAction(string action)
+        {
+            if (action == "selectTool" && clipDrag != ClipDrag.None) CancelClipDrag();
+            if (IsBusy && action != "stop" && !action.StartsWith("zoom", StringComparison.Ordinal)) return false;
+            if (ExecuteClipAction(action)) return true;
+            switch (action) {
+                case "play": PlayPause(); break;
+                case "stop": Stop(); UpdateTransport(); break;
+                case "split": Split(); break;
+                case "selectTool": SetPointerTool("select"); break;
+                case "scissors": sliceCursor = !sliceCursor; timeline.Cursor = sliceCursor ? Cursors.Cross : Cursors.Arrow; break;
+                case "copy": Copy(false); break;
+                case "cut": Copy(true); break;
+                case "paste": Paste(); break;
+                case "delete": case "deleteAlternate": DeleteRange(); break;
+                case "undo": Undo(false); break;
+                case "redo": Undo(true); break;
+                case "save": if (CommitTempo()) SaveSession(false); break;
+                case "saveAs": if (CommitTempo()) SaveSession(true); break;
+                case "open": await OpenSession(); break;
+                case "new": NewSession(); break;
+                case "import": await ChooseAudio(); break;
+                case "export": await ExportMix(); break;
+                case "start": Stop(); playhead = 0; DrawCanvas(); EnsurePlayheadVisible(); break;
+                case "end": Stop(); playhead = session.End; DrawCanvas(); EnsurePlayheadVisible(); break;
+                case "zoomIn": case "zoomInPlus": case "zoomInKeypad": ZoomStep(2); break;
+                case "zoomOut": case "zoomOutKeypad": ZoomStep(.5); break;
+                case "zoomFit": FitZoom(false); break;
+                case "zoomSelection": FitZoom(true); break;
+                default: return false;
+            }
+            return true;
+        }
+        public bool HandleKey(KeyEventArgs e)
+        {
+            if (e.Key == Key.Escape && clipDrag != ClipDrag.None) { CancelClipDrag(); timeline.ReleaseMouseCapture(); return true; }
+            if (Keyboard.FocusedElement is TextBox || Keyboard.FocusedElement is ComboBox) return false;
+            if (e.Key == Key.Escape && gesture.Mode != TimelineDrag.None) { gesture.Cancel(); selectedIds.Clear(); if (previousIds != null) foreach (string id in previousIds) selectedIds.Add(id); clipSelection = previousClipSelection; track = previousTrack; ApplyGesture(); BuildHeaders(); DrawCanvas(); timeline.ReleaseMouseCapture(); return true; }
+            string action = InterfacePreferences.Resolve(e.Key == Key.System ? e.SystemKey : e.Key, Keyboard.Modifiers);
+            if (action == null || action == "record") return false;
+            var pending = ExecuteAction(action);
+            pending.ContinueWith(task => { if (task.IsFaulted) Dispatcher.BeginInvoke((Action)delegate { status("Editor action failed: " + task.Exception.GetBaseException().Message); }); });
+            return true;
+        }
+        public bool ConfirmClose()
+        {
+            if (IsBusy) { status("Finish the editor task or click Cancel before closing."); return false; }
+            if (!dirty) return true;
+            var choice = MessageBox.Show(owner, "Save the editor session before continuing?", "Unsaved timeline", MessageBoxButton.YesNoCancel, MessageBoxImage.Question);
+            return choice == MessageBoxResult.No || (choice == MessageBoxResult.Yes && SaveSession(false));
+        }
+        internal void SetForTest(EditorSession state, IDictionary<string, Clip> decoded)
+        { session = state.Copy(); assets.Clear(); foreach (var p in decoded) assets.Add(p.Key, p.Value); undo.Clear(); redo.Clear(); dirty = false; selectedIds.Clear(); clipSelection = false; from = to = playhead = 0; UpdateSelectionText(); BuildHeaders(); DrawCanvas(); }
+        internal EditorSession SessionForTest { get { return session.Copy(); } }
+        internal void ListenVolumeForTest(double value) { volume.Value = value; }
+        internal bool PlayingForTest { get { return output.Playing; } }
+        internal void ShowSelectionForTest(long start, long end) { clipSelection = false; selectedIds.Clear(); from = start; to = end; UpdateSelectionText(); DrawCanvas(); }
+        internal void PlayheadForTest(long value) { playhead = value; DrawCanvas(); }
+        internal void ZoomForTest(double value) { SetZoom(value, 0); }
+        internal double ZoomPixelsForTest { get { return pixelsPerSecond; } }
+        internal double OffsetForTest { get { return scroll.HorizontalOffset; } }
+        internal double WidthForTest { get { return ViewportWidth; } }
+        internal int DetailsForTest { get { return timeline.Children.OfType<Polygon>().Count(p => (string)p.Tag == "WaveformDetail"); } }
+        internal void ZoomAtForTest(double value, double pointer) { SetZoom(value, pointer); }
+        internal void OffsetForTestSet(double value) { scroll.ScrollToHorizontalOffset(value); scroll.UpdateLayout(); DrawCanvas(); }
+        internal void PointerDownForTest(long frame, int targetTrack, bool additive) { BeginPointer(new Point(X(frame), RulerHeight + targetTrack * RowHeight + 20), additive, 1); }
+        internal void PointerUpForTest(long frame) { if (gesture.Mode != TimelineDrag.None) EndPointer(X(frame)); }
+        internal void PointerMoveForTest(long frame) { MovePointer(X(frame)); }
+        internal int SelectedClipsForTest { get { return clipSelection ? selectedIds.Count : 0; } }
+        internal int HighlightedForTest { get { return regionVisuals.Count(v => (string)v.Body.Tag == "SelectedRegion"); } }
+        internal bool SelectCursorForTest { get { return timeline.Cursor == Cursors.Arrow; } }
+        internal double TimelineHeightForTest { get { return scroll.ViewportHeight; } }
+        internal bool CheckUndoRedoForTest()
+        {
+            var original = session.Copy();
+            from = Audio.Rate / 4; to = Audio.Rate / 2; track = 0; UpdateSelectionText();
+            Copy(true); var afterCut = session.Copy();
+            Undo(false); bool restored = session.Regions.Count == original.Regions.Count && session.Regions[0].Length == original.Regions[0].Length;
+            Undo(true); bool repeated = session.Regions.Count == afterCut.Regions.Count && session.Regions.All(r => r.Track != 0 || r.End <= from || r.Start >= to);
+            return restored && repeated && dirty;
+        }
+        public void Dispose()
+        { if (disposed) return; disposed = true; waveformDetail.Dispose(); if (operation != null) operation.Cancel(); timer.Stop(); Stop(); output.Dispose(); }
+        public void CancelWork() { if (operation != null) operation.Cancel(); }
+    }
+}