@pro-gram/flux 0.0.0-stage → 1.5.0

package/source/Main.cs

@@ -0,0 +1,781 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Diagnostics;
+using System.Globalization;
+using System.Reflection;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Markup;
+using System.Windows.Media;
+using System.Windows.Shapes;
+using System.Windows.Threading;
+using System.Xml.Serialization;
+using NAudio.Wave;
+using NAudio.Wave.SampleProviders;
+
+[assembly: AssemblyTitle("Flux")]
+[assembly: AssemblyDescription("PCM/float media player, 16-track audio editor, H5studio recording and R16 control")]
+[assembly: AssemblyVersion("1.5.0.0")]
+
+namespace DrumBuddy
+{
+    public sealed class Preferences
+    {
+        public string ExportFolder, RecordFolder;
+        public int Bits = 24;
+        public string AudioOutputKey;
+        public string AudioInputKey;
+    }
+    public sealed class OutputChoice
+    {
+        public string Name, Driver, EndpointId;
+        public int Device = -1;
+        public bool Compatibility;
+        public string Key { get { return Compatibility ? "compat:" + (EndpointId ?? "default") : Driver != null ? "asio:" + Driver : EndpointId != null ? "windows:" + EndpointId : "default"; } }
+        public override string ToString() { return Name; }
+    }
+    public sealed class ModeChoice
+    {
+        public int Mode;
+        public string Name;
+        public override string ToString() { return Name; }
+    }
+    public sealed class RateChoice
+    {
+        public int Rate;
+        public override string ToString() { return (Rate / 1000.0).ToString("0.#", CultureInfo.InvariantCulture) + " kHz"; }
+    }
+
+    internal static class OutputDevices
+    {
+        [System.Runtime.InteropServices.DllImport("winmm.dll")]
+        internal static extern int waveOutGetNumDevs();
+        [System.Runtime.InteropServices.DllImport("winmm.dll",CharSet=System.Runtime.InteropServices.CharSet.Auto)]
+        private static extern int waveOutGetDevCaps(IntPtr device, out WaveOutCapabilities caps, int size);
+        internal static string Name(int device) {
+            WaveOutCapabilities caps;
+            if (waveOutGetDevCaps((IntPtr)device,out caps,System.Runtime.InteropServices.Marshal.SizeOf(typeof(WaveOutCapabilities))) != 0) return "Audio output " + (device + 1);
+            return caps.ProductName;
+        }
+    }
+
+    public sealed class MainWindow
+    {
+        private HomeView homeView;
+        private long recordingAnchor;
+        private int recordingTrack, configuredInputChannels = 1;
+        private bool configuringConversion;
+        private string appliedGridDefaults;
+        private DockablePane converterPane;
+        private readonly Window window;
+        private readonly ObservableCollection<Clip> clips = new ObservableCollection<Clip>();
+        private readonly string cache = System.IO.Path.Combine(System.IO.Path.GetTempPath(), "DrumBuddy", Guid.NewGuid().ToString("N"));
+        private readonly string settings = System.IO.Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "DrumBuddy", "settings.xml");
+        private Preferences prefs;
+        private CancellationTokenSource cancel;
+        private bool busy, closeWhenIdle, stopping;
+        private Recorder recorder;
+        private readonly ProgressBar[] meters = new ProgressBar[8];
+        private readonly TextBlock[] meterLabels = new TextBlock[8];
+        private readonly DispatcherTimer timer;
+        private ControlMode controlMode;
+        private bool configuringCapture;
+        private string configuredDriver;
+        private DateTime captureStarted;
+        private MediaPlayerView mediaPlayerView;
+        private EditorView editorView;
+        private int workspace;
+
+        private T C<T>(string name) where T : FrameworkElement { return (T)window.FindName(name); }
+        private Clip Selected { get { return C<ListBox>("FileList").SelectedItem as Clip; } }
+        private bool Protect { get { return C<CheckBox>("ProtectCheck").IsChecked == true; } }
+
+        public MainWindow(string preferenceFile = null, bool testMode = false)
+        {
+            if (preferenceFile != null) settings = preferenceFile;
+            using (var stream = Assembly.GetExecutingAssembly().GetManifestResourceStream("Main.xaml")) window = (Window)XamlReader.Load(stream);
+            window.Height = Math.Min(window.Height, SystemParameters.WorkArea.Height - 30);
+            window.Width = Math.Min(window.Width, SystemParameters.WorkArea.Width - 30);
+            C<Image>("BrandLogo").Source = BrandArtwork.Raster();
+            window.Icon = System.Windows.Interop.Imaging.CreateBitmapSourceFromHIcon(System.Drawing.Icon.ExtractAssociatedIcon(Assembly.GetExecutingAssembly().Location).Handle,
+                Int32Rect.Empty, System.Windows.Media.Imaging.BitmapSizeOptions.FromEmptyOptions());
+            try { using (var s = File.OpenRead(settings)) prefs = (Preferences)new XmlSerializer(typeof(Preferences)).Deserialize(s); }
+            catch { prefs = new Preferences(); }
+            if (!testMode) InterfacePreferences.Load(prefs.AudioOutputKey, prefs.AudioInputKey);
+            ThemePalette.Install(window);
+            prefs.AudioInputKey = InterfacePreferences.Current.AudioInputKey;
+            AudioOutputs.PreferredKey = InterfacePreferences.Current.AudioOutputKey;
+            string music = Environment.GetFolderPath(Environment.SpecialFolder.MyMusic);
+            if (string.IsNullOrEmpty(music)) music = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
+            if (string.IsNullOrEmpty(prefs.ExportFolder)) prefs.ExportFolder = System.IO.Path.Combine(music, "Flux", "Exports");
+            if (string.IsNullOrEmpty(prefs.RecordFolder)) prefs.RecordFolder = System.IO.Path.Combine(music, "Flux", "Recordings");
+            C<TextBlock>("ExportFolderText").Text = prefs.ExportFolder;
+            C<TextBlock>("ExportFolderText").ToolTip = prefs.ExportFolder;
+            C<TextBlock>("RecordFolderText").Text = "Recordings: " + prefs.RecordFolder;
+            C<TextBlock>("RecordFolderText").ToolTip = prefs.RecordFolder;
+            C<RadioButton>(prefs.Bits == 16 ? "Bits16" : "Bits24").IsChecked = true;
+            C<ListBox>("FileList").ItemsSource = clips;
+            C<ListBox>("FileList").SelectionChanged += delegate { ShowClip(); };
+            C<Button>("AddButton").Click += async delegate {
+                var dialog = new Microsoft.Win32.OpenFileDialog { Title = "Choose songs or videos", Multiselect = true,
+                    Filter = "Audio and video|*.mp3;*.mp4;*.wav;*.m4a;*.aac;*.flac;*.ogg;*.wma;*.mov;*.mkv;*.aiff;*.aif;*.opus;*.webm|All files|*.*" };
+                if (dialog.ShowDialog(window) == true) await AddFiles(dialog.FileNames);
+            };
+            C<Button>("RemoveButton").Click += delegate {
+                Clip clip = Selected; if (clip == null) return; clips.Remove(clip); Audio.TryDelete(clip.Cache);
+                if (clips.Count > 0) C<ListBox>("FileList").SelectedIndex = 0;
+                ShowClip();
+            };
+            C<Button>("ClearButton").Click += delegate { foreach (var clip in clips) Audio.TryDelete(clip.Cache); clips.Clear(); ShowClip(); };
+            C<Button>("RecordTab").Click += delegate { if (WorkspacesBusy) { Status("Finish or cancel the current task first."); return; } StopWorkspaces(); RefreshDevices(); SwitchPage(true); };
+            C<Button>("MediaPlayerTab").Click += delegate { OpenWorkspace(false); };
+            C<Button>("EditorTab").Click += delegate { OpenWorkspace(true); };
+            C<Button>("ControlTab").Click += delegate {
+                if (busy || recorder != null || WorkspacesBusy) { Status("Finish saving the current task before opening Full Control."); return; }
+                StopWorkspaces();
+                if (controlMode == null) controlMode = new ControlMode(prefs.RecordFolder,prefs.ExportFolder);
+                controlMode.Open(window,delegate { OpenHome(); window.Show(); window.Activate(); });
+            };
+            AudioOutputs.OutputChanged += SyncOutputChoice;
+            C<Button>("ExportButton").Click += async delegate { await ExportFiles(); };
+            C<Button>("CancelButton").Click += delegate { if (cancel != null) cancel.Cancel(); };
+            C<Button>("ChangeFolderButton").Click += delegate {
+                string folder = ChooseFolder(prefs.ExportFolder); if (folder == null) return;
+                prefs.ExportFolder = folder; C<TextBlock>("ExportFolderText").Text = folder; C<TextBlock>("ExportFolderText").ToolTip = folder; SavePreferences();
+            };
+            C<Button>("ChangeRecordFolderButton").Click += delegate {
+                string folder = ChooseFolder(prefs.RecordFolder); if (folder == null) return;
+                prefs.RecordFolder = folder; C<TextBlock>("RecordFolderText").Text = "Recordings: " + folder; C<TextBlock>("RecordFolderText").ToolTip = folder; SavePreferences();
+            };
+            C<Button>("OpenExportsButton").Click += delegate { OpenFolder(prefs.ExportFolder); };
+            C<Button>("OpenRecordingsButton").Click += delegate { OpenFolder(prefs.RecordFolder); };
+            C<Button>("RefreshDevicesButton").Click += delegate { RefreshDevices(); };
+            C<ComboBox>("InputDevice").SelectionChanged += delegate {
+                if (configuringCapture) return; ConfigureRecordingDevice();
+                var input = C<ComboBox>("InputDevice").SelectedItem as InputChoice;
+                if (input != null) { prefs.AudioInputKey = InterfacePreferences.Current.AudioInputKey = input.Key; try { InterfacePreferences.Save(InterfacePreferences.Current.Copy()); } catch (Exception ex) { Status(ex.Message); } }
+            };
+            C<RadioButton>("RecordFloat").Checked += delegate { ShowRecordingFormat(); };
+            C<RadioButton>("Record16").Checked += delegate { ShowRecordingFormat(); };
+            C<RadioButton>("Record24").Checked += delegate { ShowRecordingFormat(); };
+            C<Button>("StartRecordButton").Click += delegate { StartRecording(); };
+            C<Button>("StopRecordButton").Click += async delegate { await StopRecording(true); };
+            C<Button>("HelpButton").Click += delegate { ShowHelp(); };
+            C<Button>("InstallDriversButton").Click += delegate { DriverSetup.ShowGuide(window); };
+            C<Button>("AudioDevicesButton").Click += delegate { ShowAudioDevices(); };
+            C<Button>("HomeTab").Click += delegate { OpenHome(); };
+            C<Button>("ThemeToggle").Click += delegate { var themeSettings = InterfacePreferences.Current.Copy(); themeSettings.Theme = themeSettings.Theme == "Dark" ? "Light" : "Dark"; try { InterfacePreferences.Save(themeSettings); } catch (Exception ex) { Status(ex.Message); } };
+            InterfacePreferences.Changed += ApplyInterfaceSettings;
+            BindMenus(); ApplyInterfaceSettings(); InitializeConversion(); InitializeConverterLayout();
+            window.PreviewDragOver += delegate(object sender, DragEventArgs e) {
+                e.Effects = !busy && !WorkspacesBusy && recorder == null && e.Data.GetDataPresent(DataFormats.FileDrop) ? DragDropEffects.Copy : DragDropEffects.None;
+                e.Handled = true;
+            };
+            window.Drop += async delegate(object sender, DragEventArgs e) {
+                if (!busy && !WorkspacesBusy && recorder == null && e.Data.GetDataPresent(DataFormats.FileDrop)) {
+                    string[] files = (string[])e.Data.GetData(DataFormats.FileDrop);
+                    if (workspace == 2) await mediaPlayerView.AddFiles(files);
+                    else if (workspace == 3) await editorView.AddFiles(files);
+                    else { SwitchPage(false); await AddFiles(files); }
+                }
+                e.Handled = true;
+            };
+            window.Closing += async delegate(object sender, System.ComponentModel.CancelEventArgs e) {
+                if (recorder != null) {
+                    e.Cancel = true;
+                    if (stopping) return;
+                    if (MessageBox.Show(window, "Stop and save this recording before closing?", "Save your recording", MessageBoxButton.YesNo, MessageBoxImage.Question) != MessageBoxResult.Yes) return;
+                    await StopRecording(false); window.Close(); return;
+                }
+                if (busy) {
+                    e.Cancel = true;
+                    if (MessageBox.Show(window, "Cancel the current task and close? Files already saved will be kept.", "Work in progress", MessageBoxButton.YesNo, MessageBoxImage.Question) == MessageBoxResult.Yes) {
+                        closeWhenIdle = true; if (cancel != null) cancel.Cancel();
+                    }
+                    return;
+                }
+                if (WorkspacesBusy) {
+                    e.Cancel = true;
+                    if (MessageBox.Show(window, "Cancel the running media/editor task and close? Completed files are kept.", "Work in progress", MessageBoxButton.YesNo, MessageBoxImage.Question) == MessageBoxResult.Yes) {
+                        closeWhenIdle = true; if (mediaPlayerView != null) mediaPlayerView.CancelWork(); if (editorView != null) editorView.CancelWork();
+                    }
+                    return;
+                }
+                if (editorView != null && !editorView.ConfirmClose()) e.Cancel = true;
+            };
+            window.PreviewKeyDown += HandleInterfaceKey;
+            window.Closed += delegate {
+                AudioOutputs.OutputChanged -= SyncOutputChoice;
+                InterfacePreferences.Changed -= ApplyInterfaceSettings;
+                timer.Stop(); SavePreferences();
+                if (controlMode != null) controlMode.Dispose();
+                if (mediaPlayerView != null) mediaPlayerView.Dispose();
+                if (editorView != null) editorView.Dispose();
+                try { if (Directory.Exists(cache)) Directory.Delete(cache, true); } catch { }
+            };
+            C<ComboBox>("InputMode").Items.Add(new ModeChoice { Mode = -1, Name = "All available inputs - separate WAV files" });
+            C<ComboBox>("InputMode").Items.Add(new ModeChoice { Mode = 0, Name = "Inputs 1 + 2 — one stereo WAV" });
+            for (int i = 1; i <= 8; i++) C<ComboBox>("InputMode").Items.Add(new ModeChoice { Mode = i, Name = "Input " + i + " — one mono WAV" });
+            C<ComboBox>("InputMode").SelectedIndex = 0;
+            C<ComboBox>("RecordRate").ItemsSource = new[] { new RateChoice { Rate = 44100 }, new RateChoice { Rate = 48000 }, new RateChoice { Rate = 96000 } };
+            C<ComboBox>("RecordRate").SelectedIndex = 0;
+            for (int i = 0; i < 8; i++) {
+                var panel = new StackPanel { Margin = new Thickness(4,0,4,0) };
+                panel.Children.Add(new TextBlock { Text = "IN " + (i + 1), FontSize = 11, HorizontalAlignment = HorizontalAlignment.Center });
+                meters[i] = new ProgressBar { Minimum = 0, Maximum = 1, Height = 10, Margin = new Thickness(0,5,0,4), Foreground = Brush("#007A6B") };
+                panel.Children.Add(meters[i]);
+                meterLabels[i] = new TextBlock { Text = "—", FontSize = 11, Foreground = Brush("#526771"), HorizontalAlignment = HorizontalAlignment.Center };
+                panel.Children.Add(meterLabels[i]); C<System.Windows.Controls.Primitives.UniformGrid>("MeterPanel").Children.Add(panel);
+            }
+            timer = new DispatcherTimer { Interval = TimeSpan.FromMilliseconds(100) };
+            timer.Tick += async delegate { await Tick(); };
+            timer.Start();
+            window.Loaded += async delegate {
+                RefreshDevices(false); ShowClip();
+                if (InterfacePreferences.Current.Startup == "Home") OpenHome(); else OpenWorkspace(true);
+                string[] paths = Environment.GetCommandLineArgs().Skip(1).Where(File.Exists).ToArray();
+                if (paths.Length > 0) { OpenWorkspace(true); await editorView.AddFiles(paths); }
+            };
+        }
+
+        public void Show() { window.Show(); }
+        public Window NativeWindow { get { return window; } }
+        internal void OpenEditorForTest() { OpenWorkspace(true); }
+        internal void OpenHomeForTest() { OpenHome(); }
+        internal void EditorFixtureForTest(EditorSession session, IDictionary<string, Clip> clips) { editorView.SetForTest(session, clips); editorView.ShowSelectionForTest(Audio.Rate, Audio.Rate * 4L); }
+        internal void RecordingPanelForTest()
+        {
+            var inputs = AudioInputs.Choices(); configuringCapture = true; C<ComboBox>("InputDevice").ItemsSource = inputs; C<ComboBox>("InputDevice").SelectedItem = inputs.FirstOrDefault(c => c.Driver == null); configuringCapture = false;
+            ConfigureRecordingDevice(); editorView.ShowRecordingOptions(true);
+        }
+        internal void SetThemeForTest(bool dark) { ThemePalette.Apply(dark); ThemePalette.Install(window); C<Button>("ThemeToggle").Content = dark ? "Light theme" : "Dark theme"; }
+        internal void OpenConverterForTest() { SwitchPage(false); }
+        internal DockablePane ConverterPaneForTest { get { return converterPane; } }
+        internal DockablePane RecordingPaneForTest { get { return editorView.RecordingPaneForTest; } }
+        internal MediaPlayerView OpenPlayerForTest() { OpenWorkspace(false); return mediaPlayerView; }
+        internal void ConverterClipForTest(Clip clip) { clips.Add(clip); C<ListBox>("FileList").SelectedItem = clip; ShowClip(); }
+        internal void ApplySettingsForTest(InterfaceSettings value) { InterfacePreferences.Current = value.Copy(); ThemePalette.Apply(value.Theme == "Dark"); ApplyInterfaceSettings(); }
+        internal TempoGridOptions GridForTest { get { return editorView.GridOptions; } }
+        internal void SetGridForTest(TempoGridOptions value, double zoom) { editorView.ApplyGridOptions(value); editorView.ZoomForTest(zoom); }
+        internal bool IntegratedRecorderForTest { get { return editorView != null && C<StackPanel>("RecordPage").Parent != null && C<ComboBox>("InputDevice") != null; } }
+        private static Brush Brush(string hex) { return ThemePalette.Brush(hex); }
+        private void Status(string text) { C<TextBlock>("StatusText").Text = text; C<Border>("StatusHost").Visibility = string.IsNullOrWhiteSpace(text) ? Visibility.Collapsed : Visibility.Visible; }
+        private void SwitchPage(bool record)
+        {
+            if (record) { OpenWorkspace(true); if (editorView != null) editorView.ShowRecordingOptions(true); return; }
+            if (WorkspacesBusy) { Status("Finish or cancel the running media/editor task first."); return; }
+            Status("");
+            StopWorkspaces(); workspace = record ? 1 : 0;
+            C<ScrollViewer>("MainScroll").Visibility = Visibility.Collapsed; C<Grid>("ConverterHost").Visibility = Visibility.Visible;
+            C<Grid>("MediaPlayerHost").Visibility = Visibility.Collapsed; C<Grid>("EditorHost").Visibility = Visibility.Collapsed;
+            C<Grid>("HomeHost").Visibility = Visibility.Collapsed;
+            C<Button>("HomeTab").Style = (Style)window.Resources[typeof(Button)];
+            C<Button>("MediaPlayerTab").Style = (Style)window.Resources[typeof(Button)]; C<Button>("EditorTab").Style = (Style)window.Resources[typeof(Button)];
+            C<Border>("ExportCard").Visibility = record ? Visibility.Collapsed : Visibility.Visible;
+            C<Grid>("ConvertPage").Visibility = record ? Visibility.Collapsed : Visibility.Visible;
+            C<StackPanel>("RecordPage").Visibility = record ? Visibility.Visible : Visibility.Collapsed;
+            C<Button>("RecordTab").Style = (Style)window.Resources[record ? (object)"Primary" : typeof(Button)];
+        }
+        private bool WorkspacesBusy { get { return (mediaPlayerView != null && mediaPlayerView.IsBusy) || (editorView != null && editorView.IsBusy); } }
+        private void StopWorkspaces() { if (mediaPlayerView != null) mediaPlayerView.Stop(); if (editorView != null) editorView.Stop(); }
+        private void OpenWorkspace(bool editor)
+        {
+            if (busy || recorder != null || WorkspacesBusy) { Status("Finish or cancel the current task before changing workspaces."); return; }
+            Status("");
+            StopWorkspaces();
+            if (editor && editorView == null) {
+                editorView = new EditorView(window, System.IO.Path.Combine(cache, "editor"), Status, delegate { if (mediaPlayerView != null) mediaPlayerView.Stop(); });
+                C<Grid>("EditorHost").Children.Add(editorView);
+                var panel = C<StackPanel>("RecordPage"); var parent = panel.Parent as Panel; if (parent != null) parent.Children.Remove(panel);
+                panel.Visibility = Visibility.Visible; editorView.AttachRecordingPanel(panel); editorView.RecordRequested = async delegate { if (recorder == null) StartRecording(); else await StopRecording(true); };
+                editorView.StopRequested = async delegate { if (recorder != null) await StopRecording(true); };
+                editorView.RecordingOptionsRequested = delegate { var input = C<ComboBox>("InputDevice").SelectedItem as InputChoice; if (input != null && configuredDriver != input.Key && recorder == null) ConfigureRecordingDevice(); };
+                editorView.GridSettingsRequested = delegate { OpenSettings("timeline"); };
+            }
+            if (!editor && mediaPlayerView == null) {
+                mediaPlayerView = new MediaPlayerView(window, System.IO.Path.Combine(cache, "player"), Status, delegate { if (editorView != null) editorView.Stop(); });
+                C<Grid>("MediaPlayerHost").Children.Add(mediaPlayerView);
+            }
+            workspace = editor ? 3 : 2;
+            C<Grid>("HomeHost").Visibility = Visibility.Collapsed; C<StackPanel>("RecordPage").Visibility = editor ? Visibility.Visible : Visibility.Collapsed;
+            C<Border>("ExportCard").Visibility = Visibility.Collapsed; C<Grid>("ConverterHost").Visibility = Visibility.Collapsed; C<ScrollViewer>("MainScroll").Visibility = Visibility.Collapsed;
+            C<Grid>("MediaPlayerHost").Visibility = editor ? Visibility.Collapsed : Visibility.Visible; C<Grid>("EditorHost").Visibility = editor ? Visibility.Visible : Visibility.Collapsed;
+            foreach (string name in new[] { "HomeTab", "RecordTab", "MediaPlayerTab", "EditorTab" }) C<Button>(name).Style = (Style)window.Resources[name == (editor ? "EditorTab" : "MediaPlayerTab") ? (object)"Primary" : typeof(Button)];
+        }
+        private void SetBusy(bool value, string message)
+        {
+            busy = value; Status(message);
+            foreach (string name in new[] { "AddButton", "RemoveButton", "ClearButton", "RecordTab", "MediaPlayerTab", "EditorTab", "ChangeFolderButton", "ChangeRecordFolderButton", "Bits16", "Bits24", "FileList", "InputDevice", "InputMode", "Record16", "Record24", "RecordFloat", "RecordRate", "RefreshDevicesButton", "ConvertProfile", "ConvertFormat", "ConvertRate" })
+                C<Control>(name).IsEnabled = !value;
+            C<ProgressBar>("WorkProgress").Visibility = value ? Visibility.Visible : Visibility.Collapsed;
+            C<Button>("CancelButton").Visibility = value ? Visibility.Visible : Visibility.Collapsed;
+            C<ProgressBar>("WorkProgress").Value = 0;
+            ShowClip();
+            C<Button>("StartRecordButton").IsEnabled = !value && recorder == null && C<ComboBox>("InputDevice").SelectedItem != null;
+            UpdateConversionControls();
+            if (!value && closeWhenIdle) window.Dispatcher.BeginInvoke((Action)delegate { window.Close(); });
+        }
+        private void Progress(double value) { window.Dispatcher.BeginInvoke((Action)delegate { C<ProgressBar>("WorkProgress").Value = value * 100; }); }
+
+        private async Task AddFiles(IEnumerable<string> paths)
+        {
+            if (busy || recorder != null) return;
+            string[] files = paths.Where(File.Exists).Select(System.IO.Path.GetFullPath)
+                .Distinct(StringComparer.OrdinalIgnoreCase).Where(p => !clips.Any(c => string.Equals(c.Source,p,StringComparison.OrdinalIgnoreCase))).ToArray();
+            if (files.Length == 0) { Status("No new audio files were added."); return; }
+            cancel = new CancellationTokenSource();
+            SetBusy(true, "Reading audio…");
+            int failures = 0, added = 0;
+            try {
+                for (int i = 0; i < files.Length; i++) {
+                    cancel.Token.ThrowIfCancellationRequested();
+                    var placeholder = new Clip { Source = files[i], Name = System.IO.Path.GetFileName(files[i]), Status = "Reading audio…" };
+                    clips.Add(placeholder); if (Selected == null) C<ListBox>("FileList").SelectedItem = placeholder;
+                    Status("Reading " + (i + 1) + " of " + files.Length + ": " + placeholder.Name);
+                    try {
+                        var loaded = await Task.Run(() => Audio.Load(placeholder.Source, cache, cancel.Token, Progress));
+                        int index = clips.IndexOf(placeholder);
+                        bool selected = Selected == placeholder;
+                        clips[index] = loaded;
+                        if (selected) C<ListBox>("FileList").SelectedItem = loaded;
+                        added++;
+                    }
+                    catch (OperationCanceledException) { clips.Remove(placeholder); throw; }
+                    catch (Exception ex) { placeholder.Status = ex.Message; failures++; C<ListBox>("FileList").Items.Refresh(); }
+                }
+                SetBusy(false, failures > 0 ? added + " ready · " + failures + " could not be read. Select a file to see why." : added + " file" + (added == 1 ? " is" : "s are") + " ready. Choose the output type, then convert.");
+            }
+            catch (OperationCanceledException) { SetBusy(false, "Stopped reading files. Your ready files are still here."); }
+            finally { cancel.Dispose(); cancel = null; }
+            if (Selected == null && clips.Count > 0) C<ListBox>("FileList").SelectedIndex = 0;
+            ShowClip();
+        }
+
+        private void ShowClip()
+        {
+            Clip clip = Selected; bool ready = clip != null && clip.Ready;
+            C<TextBlock>("QueueTitle").Text = "Files to convert" + (clips.Count > 0 ? " (" + clips.Count + ")" : "");
+
+            C<Button>("ExportButton").IsEnabled = !busy && clips.Any(c => c.Ready);
+            C<Button>("RemoveButton").IsEnabled = !busy && clip != null;
+            C<Button>("ClearButton").IsEnabled = !busy && clips.Count > 0;
+
+        }
+        private async Task ExportFiles()
+        {
+            if (busy || recorder != null) return;
+            Clip[] ready = clips.Where(c => c.Ready).ToArray(); if (ready.Length == 0) return;
+            cancel = new CancellationTokenSource();
+            int bits = C<RadioButton>("Bits16").IsChecked == true ? 16 : 24;
+            bool protect = Protect; prefs.Bits = bits; SavePreferences();
+            int done = 0, failed = 0;
+            SetBusy(true,"Converting audio files…");
+            try {
+                for (int i = 0; i < ready.Length; i++) {
+                    cancel.Token.ThrowIfCancellationRequested();
+                    Clip clip = ready[i]; Status("Saving " + (i + 1) + " of " + ready.Length + ": " + clip.Name);
+                    try {
+                        var options = SelectedConversion(bits, protect);
+                        string path = await Task.Run(() => ConversionFormats.Export(clip,prefs.ExportFolder,options,cancel.Token,Progress));
+                        clip.Status = "Saved as " + System.IO.Path.GetFileName(path); done++;
+                    }
+                    catch (OperationCanceledException) { throw; }
+                    catch (Exception ex) { clip.Status = "Save failed: " + ex.Message; failed++; }
+                    C<ListBox>("FileList").Items.Refresh();
+                }
+                SetBusy(false,done + " audio file" + (done == 1 ? "" : "s") + " converted" + (failed > 0 ? " · " + failed + " failed. Select a file to see why." : ". Click Open folder to find them."));
+            }
+            catch (OperationCanceledException) { SetBusy(false,"Cancelled. " + done + " finished file" + (done == 1 ? " was" : "s were") + " kept."); }
+            finally { cancel.Dispose(); cancel = null; }
+        }
+
+        private void SyncOutputChoice()
+        {
+            if (!window.Dispatcher.CheckAccess()) { window.Dispatcher.BeginInvoke((Action)SyncOutputChoice); return; }
+            StopWorkspaces(); SavePreferences();
+            if (InterfacePreferences.Current.AudioOutputKey != AudioOutputs.PreferredKey) {
+                var settings = InterfacePreferences.Current.Copy(); settings.AudioOutputKey = AudioOutputs.PreferredKey;
+                try { InterfacePreferences.Save(settings); } catch (Exception ex) { Status(ex.Message); }
+            }
+        }
+        private void OpenSettings(string category)
+        {
+            if (category == "audio") { StopWorkspaces(); }
+            var initial = InterfacePreferences.Current.Copy(); if (editorView != null) initial.Grid = editorView.GridOptions;
+            var dialog = new SettingsWindow(window, category, recorder != null || busy || WorkspacesBusy, null, initial); dialog.ShowDialog();
+        }
+        private void ApplyInterfaceSettings()
+        {
+            ThemePalette.Install(window); C<Button>("ThemeToggle").Content = ThemePalette.Dark ? "Light theme" : "Dark theme";
+            var settings = InterfacePreferences.Current;
+            string gridSignature = settings.Grid.Signature();
+            if (appliedGridDefaults != gridSignature) { appliedGridDefaults = gridSignature; if (editorView != null) editorView.ApplyGridOptions(settings.Grid); }
+            if (editorView != null) editorView.RefreshGridPreferences();
+            if (window.IsLoaded && recorder == null && !busy && prefs.AudioInputKey != settings.AudioInputKey) {
+                prefs.AudioInputKey = settings.AudioInputKey;
+                configuringCapture = true; C<ComboBox>("InputDevice").SelectedItem = null; configuringCapture = false; RefreshDevices();
+            }
+            AudioOutputs.PreferredKey = settings.AudioOutputKey ?? "default";
+            RefreshMenuGestures(); SavePreferences();
+        }
+        private void OpenHome()
+        {
+            if (busy || recorder != null || WorkspacesBusy) { Status("Finish the current task before opening Home."); return; }
+            Status("");
+            StopWorkspaces();
+            if (homeView == null) { homeView = new HomeView(async delegate(string action) { await ExecuteInterfaceAction(action); }); C<Grid>("HomeHost").Children.Add(homeView); }
+            workspace = 4; C<Grid>("HomeHost").Visibility = Visibility.Visible;
+            C<Grid>("EditorHost").Visibility = C<Grid>("MediaPlayerHost").Visibility = Visibility.Collapsed;
+            C<ScrollViewer>("MainScroll").Visibility = Visibility.Collapsed; C<Border>("ExportCard").Visibility = Visibility.Collapsed; C<Grid>("ConverterHost").Visibility = Visibility.Collapsed;
+            foreach (string name in new[] { "HomeTab", "RecordTab", "MediaPlayerTab", "EditorTab" }) C<Button>(name).Style = (Style)window.Resources[name == "HomeTab" ? (object)"Primary" : typeof(Button)];
+        }
+        private void BindMenus()
+        {
+            string[,] entries = { { "FileNew", "new" }, { "FileOpen", "open" }, { "FileSave", "save" }, { "FileSaveAs", "saveAs" }, { "FileImport", "import" }, { "FileExport", "export" }, { "ViewHome", "home" }, { "ViewEditor", "editor" }, { "ViewConverter", "converter" }, { "ViewPlayer", "player" }, { "ViewControl", "control" }, { "ViewRecording", "recordOptions" }, { "SettingsGeneral", "settings" }, { "SettingsTimeline", "timelineSettings" }, { "SettingsAudio", "audio" }, { "SettingsKeys", "keybinds" } };
+            for (int i = 0; i < entries.GetLength(0); i++) { string action = entries[i, 1]; C<MenuItem>(entries[i, 0]).Click += async delegate { await ExecuteInterfaceAction(action); }; }
+            C<MenuItem>("FileExit").Click += delegate { window.Close(); };
+            C<MenuItem>("InstallAudioDrivers").Click += delegate { DriverSetup.ShowGuide(window); };
+            C<MenuItem>("HelpGuide").Click += delegate { ShowHelp(); };
+            C<MenuItem>("HelpAbout").Click += delegate { OpenSettings("about"); };
+        }
+        private void RefreshMenuGestures()
+        {
+            string[,] entries = { { "FileNew", "new" }, { "FileOpen", "open" }, { "FileSave", "save" }, { "FileSaveAs", "saveAs" }, { "FileImport", "import" }, { "FileExport", "export" }, { "ViewHome", "home" }, { "ViewEditor", "editor" }, { "ViewConverter", "converter" }, { "ViewPlayer", "player" }, { "SettingsGeneral", "settings" } };
+            for (int i = 0; i < entries.GetLength(0); i++) { string gesture = InterfacePreferences.Gesture(entries[i, 1]); C<MenuItem>(entries[i, 0]).InputGestureText = gesture == "Unassigned" ? "" : gesture; }
+        }
+        private async void HandleInterfaceKey(object sender, System.Windows.Input.KeyEventArgs e)
+        {
+            var key = e.Key == System.Windows.Input.Key.System ? e.SystemKey : e.Key;
+            if (key == System.Windows.Input.Key.Escape && workspace == 3 && editorView != null && editorView.HandleKey(e)) { e.Handled = true; return; }
+            string action = InterfacePreferences.Resolve(key, System.Windows.Input.Keyboard.Modifiers);
+            if (action == null) return;
+            bool text = System.Windows.Input.Keyboard.FocusedElement is TextBox || System.Windows.Input.Keyboard.FocusedElement is ComboBox;
+            if (text && !new[] { "save", "saveAs", "open", "new", "settings" }.Contains(action)) return;
+            if (e.IsRepeat) { e.Handled = true; return; }
+            if (workspace != 3 && !(workspace == 2 && new[] { "play", "stop", "start", "end" }.Contains(action)) && !new[] { "home", "editor", "converter", "player", "settings", "timelineSettings", "new", "open", "save", "saveAs", "import", "export" }.Contains(action)) return;
+            e.Handled = true; await ExecuteInterfaceAction(action);
+        }
+        private async Task ExecuteInterfaceAction(string action)
+        {
+            switch (action) {
+                case "home": OpenHome(); return;
+                case "editor": OpenWorkspace(true); return;
+                case "converter": SwitchPage(false); return;
+                case "player": OpenWorkspace(false); return;
+                case "settings": OpenSettings("general"); return;
+                case "timelineSettings": OpenSettings("timeline"); return;
+                case "audio": OpenSettings("audio"); return;
+                case "keybinds": OpenSettings("keybinds"); return;
+                case "control": C<Button>("ControlTab").RaiseEvent(new RoutedEventArgs(Button.ClickEvent)); return;
+                case "recordOptions": if (workspace != 3) OpenWorkspace(true); if (editorView != null) editorView.ShowRecordingOptions(true); return;
+                case "record": if (recorder != null) await StopRecording(true); else StartRecording(); return;
+                case "play": if (recorder != null) { await StopRecording(true); return; } break;
+                case "stop": if (recorder != null) { await StopRecording(true); return; } break;
+            }
+            if (workspace == 2 && await mediaPlayerView.ExecuteAction(action)) return;
+            if (workspace == 0 && (action == "export" || action == "save")) { await ExportFiles(); return; }
+            if (workspace != 3) OpenWorkspace(true);
+            if (workspace == 3 && editorView != null) await editorView.ExecuteAction(action);
+        }
+        private void InitializeConverterLayout()
+        {
+            var page = C<Grid>("ConvertPage"); var pageParent = page.Parent as Panel; if (pageParent != null) pageParent.Children.Remove(page);
+            var options = C<Border>("ExportCard"); var optionsParent = options.Parent as Panel; if (optionsParent != null) optionsParent.Children.Remove(options);
+            converterPane = new DockablePane(page, options, "Convert to", true);
+            C<Grid>("ConverterHost").Children.Add(converterPane);
+        }
+        private void InitializeConversion()
+        {
+            C<ComboBox>("ConvertProfile").ItemsSource = new[] { "General audio", "Zoom R16" }; C<ComboBox>("ConvertProfile").SelectedIndex = 0;
+            C<ComboBox>("ConvertFormat").ItemsSource = new[] { "WAV PCM", "WAV float", "FLAC", "MP3", "AAC", "AIFF" }; C<ComboBox>("ConvertFormat").SelectedIndex = 0;
+            C<ComboBox>("ConvertRate").ItemsSource = new[] { "Keep source rate", "44.1 kHz", "48 kHz", "96 kHz" }; C<ComboBox>("ConvertRate").SelectedIndex = 0;
+            C<ComboBox>("ConvertProfile").SelectionChanged += delegate { UpdateConversionControls(); };
+            C<ComboBox>("ConvertFormat").SelectionChanged += delegate { UpdateConversionControls(); };
+            UpdateConversionControls();
+        }
+        private void UpdateConversionControls()
+        {
+            if (configuringConversion) return; configuringConversion = true;
+            bool r16 = C<ComboBox>("ConvertProfile").SelectedIndex == 1;
+            if (r16) { C<ComboBox>("ConvertFormat").SelectedIndex = 0; C<ComboBox>("ConvertRate").SelectedIndex = 1; }
+            C<ComboBox>("ConvertFormat").IsEnabled = C<ComboBox>("ConvertRate").IsEnabled = !r16 && !busy;
+            int format = C<ComboBox>("ConvertFormat").SelectedIndex;
+            if (format == 3 && C<ComboBox>("ConvertRate").SelectedIndex == 3) C<ComboBox>("ConvertRate").SelectedIndex = 2;
+            C<RadioButton>("Bits16").IsEnabled = C<RadioButton>("Bits24").IsEnabled = !busy && (format == 0 || format == 2 || format == 5);
+            C<CheckBox>("ProtectCheck").IsEnabled = !busy && format != 1;
+            C<Button>("ExportButton").Content = "Convert files";
+            configuringConversion = false;
+        }
+        private ConversionOptions SelectedConversion(int bits, bool protect)
+        {
+            return new ConversionOptions { Format = (string)C<ComboBox>("ConvertFormat").SelectedItem, Bits = bits, Protect = protect && C<ComboBox>("ConvertFormat").SelectedIndex != 1,
+                R16 = C<ComboBox>("ConvertProfile").SelectedIndex == 1, SampleRate = new[] { 0, 44100, 48000, 96000 }[Math.Max(0, C<ComboBox>("ConvertRate").SelectedIndex)] };
+        }
+        private void ShowAudioDevices()
+        {
+            OpenSettings("audio");
+        }
+        private void RefreshDevices(bool configureInput = true)
+        {
+            if (recorder != null || busy) return;
+            var previous = C<ComboBox>("InputDevice").SelectedItem as InputChoice;
+            var inputs = AudioInputs.Choices();
+            string wanted = previous == null ? prefs.AudioInputKey : previous.Key;
+            configuringCapture = true;
+            C<ComboBox>("InputDevice").ItemsSource = inputs;
+            C<ComboBox>("InputDevice").SelectedItem = inputs.FirstOrDefault(d => d.Key == wanted) ?? inputs.FirstOrDefault(d => IsH5studio(d.Driver)) ?? inputs.FirstOrDefault(d => d.Driver != null && IsZoom(d.Driver)) ?? inputs.FirstOrDefault();
+            var chosenInput = C<ComboBox>("InputDevice").SelectedItem as InputChoice; InterfacePreferences.Current.AudioInputKey = chosenInput == null ? null : chosenInput.Key;
+            configuringCapture = false;
+            if (configureInput) ConfigureRecordingDevice();
+        }
+        private static bool IsH5studio(string text) { return CaptureLayout.IsH5studio(text); }
+        private static bool IsZoom(string text) { return text.IndexOf("R16",StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("R24",StringComparison.OrdinalIgnoreCase) >= 0; }
+        private void ShowRecordingFormat()
+        {
+            bool floating = C<RadioButton>("RecordFloat").IsChecked == true;
+            var input = C<ComboBox>("InputDevice").SelectedItem as InputChoice;
+            if (input != null && input.Driver == null) {
+                C<TextBlock>("CaptureFormatText").Text = "Windows microphone input: 16-bit PCM. " + (floating ? "A float WAV keeps those samples; it does not add native float headroom. Use the H5studio ASIO input for native 32-bit float." : "The selected WAV format is used for saving."); return;
+            }
+            C<TextBlock>("CaptureFormatText").Text = floating
+                ? "32-bit float master: peaks above 0 dBFS are preserved when the driver supplies float audio. Convert files makes PCM copies."
+                : "Integer PCM WAV for playback and sharing. Set input levels below 0 dBFS to prevent clipping.";
+        }
+        private void ConfigureRecordingDevice()
+        {
+            if (configuringCapture || recorder != null) return;
+            var input = C<ComboBox>("InputDevice").SelectedItem as InputChoice;
+            string driver = input == null ? null : input.Driver;
+            bool changed = input == null || input.Key != configuredDriver;
+            configuredDriver = input == null ? null : input.Key; configuringCapture = true;
+            C<Button>("StartRecordButton").IsEnabled = false;
+            try {
+                if (input == null) {
+                    C<TextBlock>("RecordingState").Text = "No recording input found";
+                    C<TextBlock>("RecordSetupHint").Text = "Connect a Windows microphone or a Zoom recorder, then Refresh. Audio devices at the top of the app lists recording inputs and playback outputs.";
+                    ShowRecordingFormat(); return;
+                }
+                
+                bool h5 = IsH5studio(driver);
+                C<TextBlock>("RecordSetupHint").Text = h5
+                    ? "H5studio: USB > Audio Interface. Use Stereo mix for a mixed microphone recording, or Multi Track for separate inputs. Audio I/F Only allows 44.1 / 48 / 96 kHz."
+                    : driver != null ? "Select the inputs exposed by your ASIO driver. On an R16 choose USB > AUDIO INTERFACE. Monitor live sound through the recorder's headphones."
+                    : "Record from your selected Windows microphone (Realtek, USB or headset). Input is captured as 16-bit PCM; allow desktop microphone access in Windows Settings. Use headphones to avoid feedback.";
+                var oldMode = C<ComboBox>("InputMode").SelectedItem as ModeChoice;
+                var oldRate = C<ComboBox>("RecordRate").SelectedItem as RateChoice;
+                var modes = new List<ModeChoice>(); var rates = new List<RateChoice>();
+                int count;
+                if (driver != null) using (var probe = new AsioOut(driver)) {
+                    count = Math.Min(8, probe.DriverInputChannelCount);
+                    if (count < 1) throw new IOException("This ASIO device has no recording inputs.");
+                    modes.Add(new ModeChoice { Mode = -1, Name = "All " + count + " inputs - separate mono WAV files" });
+                    if (count >= 2) modes.Add(new ModeChoice { Mode = 0, Name = "Inputs 1 + 2 - one stereo WAV" });
+                    for (int i = 0; i < count; i++) modes.Add(new ModeChoice { Mode = i + 1, Name = "Input " + (i + 1) + " - " + probe.AsioInputChannelName(i) });
+                    foreach (int rate in new[] { 44100, 48000, 96000 })
+                        if (probe.IsSampleRateSupported(rate)) rates.Add(new RateChoice { Rate = rate });
+                    if (rates.Count == 0) throw new IOException("The recorder is not offering 44.1, 48 or 96 kHz. Check its USB audio mode.");
+                }
+                else {
+                    count = AudioInputs.Channels(input);
+                    modes.Add(new ModeChoice { Mode = -1, Name = "All " + count + " microphone channels - separate WAV files" });
+                    if (count >= 2) modes.Add(new ModeChoice { Mode = 0, Name = "Channels 1 + 2 - stereo WAV" });
+                    for (int i = 0; i < count; i++) modes.Add(new ModeChoice { Mode = i + 1, Name = "Microphone channel " + (i + 1) + " - mono WAV" });
+                    foreach (int rate in AudioInputs.Rates(input, count)) rates.Add(new RateChoice { Rate = rate });
+                    if (rates.Count == 0) throw new IOException("Windows is not offering 16-bit PCM microphone capture at 44.1, 48 or 96 kHz. Check microphone access in Windows Settings.");
+                }
+                    for (int i = 0; i < meters.Length; i++) {
+                        var panel = (StackPanel)meters[i].Parent;
+                        panel.Visibility = i < count ? Visibility.Visible : Visibility.Collapsed;
+                    }
+                    configuredInputChannels = count; C<System.Windows.Controls.Primitives.UniformGrid>("MeterPanel").Columns = Math.Min(4, count);
+                C<ComboBox>("InputMode").ItemsSource = null;
+                C<ComboBox>("InputMode").Items.Clear(); C<ComboBox>("InputMode").ItemsSource = modes;
+                C<ComboBox>("InputMode").SelectedItem = !changed && oldMode != null ? modes.FirstOrDefault(m => m.Mode == oldMode.Mode) : null;
+                if (C<ComboBox>("InputMode").SelectedItem == null) C<ComboBox>("InputMode").SelectedItem = h5 ? modes.FirstOrDefault(m => m.Mode == 0) ?? modes[0] : modes[0];
+                C<ComboBox>("RecordRate").ItemsSource = rates;
+                int wantedRate = !changed && oldRate != null ? oldRate.Rate : h5 || driver == null ? 48000 : 44100;
+                C<ComboBox>("RecordRate").SelectedItem = rates.FirstOrDefault(r => r.Rate == wantedRate) ?? rates[0];
+                if (changed) C<RadioButton>(h5 ? "RecordFloat" : driver == null ? "Record16" : "Record24").IsChecked = true;
+                C<TextBlock>("RecordingState").Text = "Ready when you are";
+                C<Button>("StartRecordButton").IsEnabled = true;
+                ShowRecordingFormat();
+            }
+            catch (Exception ex) {
+                C<TextBlock>("RecordingState").Text = "Device not ready";
+                C<TextBlock>("CaptureFormatText").Text = ex.Message + " Connect the recorder in Audio Interface mode, close other audio apps, then Refresh.";
+            }
+            finally { configuringCapture = false; }
+        }
+        private async void StartRecording()
+        {
+            if (busy || recorder != null) return;
+            var input = C<ComboBox>("InputDevice").SelectedItem as InputChoice;
+            if (input == null) { Status("Choose a recording input under Audio devices or Record drums, then click Refresh."); return; }
+            if (configuredDriver != input.Key) ConfigureRecordingDevice();
+            if (!C<Button>("StartRecordButton").IsEnabled) { Status("Choose a ready recording input in Record options."); return; }
+            string driver = input.Name;
+            
+            int mode = ((ModeChoice)C<ComboBox>("InputMode").SelectedItem).Mode;
+            int bits = C<RadioButton>("RecordFloat").IsChecked == true ? 32 : C<RadioButton>("Record16").IsChecked == true ? 16 : 24;
+            var rateChoice = C<ComboBox>("RecordRate").SelectedItem as RateChoice;
+            if (rateChoice == null) { Status("Choose a sample rate before recording."); return; }
+            if (editorView == null) OpenWorkspace(true);
+            if (editorView == null || editorView.IsBusy) { Status("Finish the editor task before recording."); return; }
+            int files = mode == -1 ? configuredInputChannels : 1;
+            StopWorkspaces();
+            recordingTrack = editorView.SelectedTrack; recordingAnchor = editorView.PlayheadFrame;
+            if (recordingTrack + files > 16) { Status("Select an earlier track so all recording channels fit within the 16-track timeline."); return; }
+            string folder = System.IO.Path.Combine(prefs.RecordFolder,"Take_" + DateTime.Now.ToString("yyyyMMdd_HHmmss_fff",CultureInfo.InvariantCulture));
+            recorder = new Recorder();
+            Exception startError = null;
+            try {
+                Status("Connecting to " + driver + "…");
+                recorder.Start(input,mode,bits,folder,rateChoice.Rate); captureStarted = DateTime.UtcNow;
+                editorView.SetRecordingState(true);
+                foreach (string name in new[] { "RecordTab", "StartRecordButton", "InputDevice", "InputMode", "Record16", "Record24", "RecordFloat", "RecordRate", "RefreshDevicesButton", "ChangeRecordFolderButton" }) C<Control>(name).IsEnabled = false;
+                C<Button>("StopRecordButton").IsEnabled = true;
+                C<TextBlock>("RecordingState").Text = "● Recording"; C<TextBlock>("RecordingState").Foreground = Brush("#B52C36");
+                Status("Recording. Click Stop & save when you finish.");
+            }
+            catch (Exception ex) { startError = ex; }
+            if (startError != null) {
+                if (editorView != null) editorView.SetRecordingState(false);
+                Recorder failed = recorder; recorder = null; failed.Stop(); await failed.Finish();
+                // Keep any partial audio from a failed start; never delete a take.
+                Status("Could not start recording: " + startError.Message + " Check Audio Interface mode and close other audio apps.");
+                RefreshDevices();
+            }
+        }
+        private async Task StopRecording(bool addFiles)
+        {
+            if (recorder == null || stopping) return;
+            stopping = true; C<Button>("StopRecordButton").IsEnabled = false;
+            Recorder finished = recorder;
+            Status("Saving your recording…");
+            finished.Stop(); await finished.Finish(); recorder = null;
+            if (editorView != null) editorView.SetRecordingState(false);
+            foreach (string name in new[] { "RecordTab", "StartRecordButton", "InputDevice", "InputMode", "Record16", "Record24", "RecordFloat", "RecordRate", "RefreshDevicesButton", "ChangeRecordFolderButton" }) C<Control>(name).IsEnabled = true;
+            C<TextBlock>("RecordingState").Text = finished.Error == null ? "Take saved" : "Recording stopped - check status";
+            C<TextBlock>("RecordingState").Foreground = Brush(finished.Error == null ? "#006D68" : "#B52C36");
+            stopping = false;
+            if (Interlocked.Read(ref finished.Frames) > 0 && finished.Paths.Count > 0 && editorView != null) {
+                try { await editorView.AddRecordedFiles(finished.Paths, recordingAnchor, recordingTrack); }
+                catch (Exception ex) { Status("Take saved to its folder, but could not be added to the timeline: " + ex.Message); return; }
+            }
+            Status(finished.Error == null ? "Take saved and added to the timeline. Original recording files are preserved." : "Recording stopped: " + finished.Error.Message + " Captured audio was kept.");
+        }
+        private async Task Tick()
+        {
+            if (closeWhenIdle && !busy && !WorkspacesBusy && recorder == null) { closeWhenIdle = false; window.Close(); return; }
+            if (recorder == null || stopping) return;
+            long frames = Interlocked.Read(ref recorder.Frames);
+            C<TextBlock>("RecordTime").Text = WorkspaceUi.Clock(frames / (double)recorder.SampleRate);
+            if (frames == 0 && (DateTime.UtcNow - captureStarted).TotalSeconds > 8 && recorder.Error == null)
+                recorder.Error = new IOException("No audio arrived from the selected input. Check its connection, microphone permissions and selected channels.");
+            if (recorder.SourceFormat != null)
+                C<TextBlock>("CaptureFormatText").Text = "Input: " + (recorder.SourceIsFloat ? "native 32-bit float" : recorder.SourceFormat) + " | WAV: " + recorder.Bits + (recorder.Bits == 32 ? "-bit float" : "-bit PCM") + " | " + recorder.SampleRate + " Hz";
+            bool tooLoud = false;
+            for (int i = 0; i < 8; i++) {
+                float peak = Interlocked.Exchange(ref recorder.Peaks[i],0);
+                double db = peak > 0 ? 20 * Math.Log10(peak) : -60;
+                meters[i].Value = Math.Max(0,Math.Min(1,(db + 60) / 60));
+                meters[i].Foreground = Brush(peak >= .99 ? "#B52C36" : "#007A6B");
+                meterLabels[i].Text = peak > .001 ? db.ToString("0",CultureInfo.InvariantCulture) + " dB" : "—";
+                tooLoud |= peak >= .99;
+            }
+            C<TextBlock>("RecordHint").Text = recorder.Bits == 32 && recorder.SourceIsFloat
+                ? (tooLoud ? "Peaks above 0 dBFS are kept in the float master. Enable Prevent PCM clipping when making a PCM copy." : "Recording the original float samples. Monitor through the recorder's headphones.")
+                : (tooLoud ? "Input is near full scale. Turn down the recorder's input level to prevent clipping." : "Set input levels on the recorder. Adjust a copy in Media Player.");
+            if (recorder.SourceFormat == "Windows 16-bit PCM") C<TextBlock>("RecordHint").Text = tooLoud ? "Input is near full scale. Lower the microphone level in Windows Sound settings." : "Windows microphone recording. The take will be added to the selected timeline track.";
+            if (recorder.Error != null) await StopRecording(true);
+        }
+
+        private string ChooseFolder(string initial)
+        {
+            using (var dialog = new System.Windows.Forms.FolderBrowserDialog { Description = "Choose where to save your WAV files", SelectedPath = initial, ShowNewFolderButton = true })
+                return dialog.ShowDialog() == System.Windows.Forms.DialogResult.OK ? dialog.SelectedPath : null;
+        }
+        private void OpenFolder(string path) { try { Directory.CreateDirectory(path); Process.Start(new ProcessStartInfo(path) { UseShellExecute = true }); } catch (Exception ex) { Status("Could not open this folder: " + ex.Message); } }
+        private void SavePreferences()
+        {
+            try { var input = C<ComboBox>("InputDevice").SelectedItem as InputChoice; prefs.AudioInputKey = input == null ? prefs.AudioInputKey : input.Key; prefs.AudioOutputKey = AudioOutputs.PreferredKey; prefs.Bits = C<RadioButton>("Bits16").IsChecked == true ? 16 : 24; Directory.CreateDirectory(System.IO.Path.GetDirectoryName(settings)); using (var stream = File.Create(settings)) new XmlSerializer(typeof(Preferences)).Serialize(stream,prefs); } catch { }
+        }
+        private void ShowHelp()
+        {
+            MessageBox.Show(window,
+                "AUDIO DEVICES\nUse Audio devices at the top of the app to choose playback output and recording input. Test speakers plays a short quiet tone. If Windows/Realtek playback fails, select that device's Compatibility (16-bit PCM) output. Save diagnostics exports device formats and recent playback errors. Windows microphones capture 16-bit PCM; use H5studio ASIO for native 32-bit float.\n\n" +
+                "HOME AND CONVERTER\nOpen Converter from View or Home. Drop audio or video, choose an output type and click Convert files. WAV PCM, WAV float, AIFF, FLAC, MP3 and AAC copies are supported. Output settings can be resized, collapsed, or displayed on the side or bottom. The source is preserved.\n\n" +
+                "Set safe level brings the loudest peak to −1 dBFS. Prevent clipping caps excessive gain evenly; it preserves the dynamics of your drums.\n\n" +
+                "ZOOM R16\nExports are 44.1 kHz PCM WAV, mono or stereo, with names up to 8 uppercase characters. Use the bit depth of your R16 project. Copy WAVs to that project's AUDIO folder, then assign them to tracks on the R16.\n\n" +
+                "EDITOR + RECORD\nThe Editor opens by default. Record options contains input, channels, WAV format and sample rate. Record or R starts a take at the playhead on the selected track. Stop & save preserves the take and adds it to the timeline. All inputs uses consecutive tracks. Use hardware direct monitoring while recording; software overdub synchronisation is not provided.\n\n" +
+                "H5STUDIO FLOAT\nOn the recorder choose USB > Audio Interface > Connect. Audio I/F Only supports 44.1, 48 and 96 kHz. Stereo mix exposes a mixed stereo signal; Multi Track exposes separate inputs. Choose 32-bit float to keep the original float samples, including peaks above 0 dBFS. The app checks that the H5studio driver is actually sending float samples.\n\n" +
+                "PLAYBACK COMPATIBILITY\nSome players reject float or multichannel WAV files. Open Converter from View, enable Prevent PCM clipping and choose 16-bit or 24-bit WAV PCM. The original float master remains unchanged.\n\n" +
+                "FULL CONTROL\nAn R16 front-panel view with PC multitrack playback, mixer, EQ, recording and Mackie MIDI control. Open Menu reveals files, track settings, saved effects and devices. Escape returns home.\n\n" +
+                "R16 memory is available in CARD READER mode. Open a PRJDATA.ZDT project to read assignments and settings. Save project copy preserves original metadata and audio, with supported edits, in a new folder. Zoom's internal effect DSP and analogue knobs cannot be remotely emulated.\n\n" +
+                "Use the R16 gain knobs to set recording levels. Listen through the R16's direct headphone monitoring.\n\n" +
+                "Install Drivers opens a short guide and links to Zoom's official driver download pages.\n\n" +
+                "MEDIA PLAYER\nOpen audio or video to listen. Gain / Save amplifies or reduces playback and saves adjusted WAV copies; Playback volume changes listening level only. Reset, Set safe level and Prevent clipping are available. Choose speakers/headphones under Audio output. Gain / Save can be resized, collapsed, or displayed on the side or bottom.\n\n" +
+                "EDITOR\nA 16-track audio timeline. Drag the upper ruler and release to place the playhead. The left edge snaps to zero; Home/To start goes to zero and End goes to the timeline end. Hold Alt to bypass snapping. Drag across a track to select time; two thinner blue sticks mark the selection start/end. Drag their lower-ruler handles to adjust the boundaries. Cut/copy/paste, split, undo/redo, Space to play/pause and Ctrl+S to save. Cuts leave a gap. Choose Selected track or All 16 tracks for edits. Save .dbedit sessions and export PCM or float WAV mixes. Original source files are preserved.\n\n" +
+                "THEME AND SETTINGS\nUse the top-right switch for dark or light theme. Settings has categories for General, Audio and Keybinds. Click Edit on a keybind and press the new shortcut immediately. Save writes the changes; leaving with pending changes asks whether to save them. S splits at the playhead; K toggles the scissors pointer tool by default.\n\n" +
+                "Basic tools run locally without an account. This release is for Windows; macOS is planned.\n\nFlux 1.5.0 · FFmpeg + NAudio",
+                "Flux — quick help",MessageBoxButton.OK,MessageBoxImage.Information);
+        }
+    }
+
+    public static class Program
+    {
+        [STAThread]
+        public static int Main(string[] args)
+        {
+            if (args.Length > 0 && args[0] == "--self-test") return SelfTest.Run(args.Skip(1).ToArray());
+            if (args.Length > 0 && args[0] == "--float-self-test") return FloatRecordingTests.Run(args.Skip(1).ToArray());
+            if (args.Length > 0 && args[0] == "--grid-self-test") return TempoGridTests.Run(args.Skip(1).ToArray());
+            if (args.Length > 0 && args[0] == "--workspace-self-test") return WorkspaceTests.Run(args.Skip(1).ToArray());
+            if (args.Length > 0 && args[0] == "--interface-self-test") return InterfaceTests.Run(args.Skip(1).ToArray());
+            if (args.Length > 0 && args[0] == "--conversion-self-test") return ConversionTests.Run(args.Skip(1).ToArray());
+            if (args.Length > 0 && args[0] == "--output-self-test") return PlaybackTests.Run(args.Skip(1).ToArray());
+            if (args.Length > 1 && args[0] == "--audio-diagnostics") { File.WriteAllText(args[1], AudioDiagnostics.Report(null), System.Text.Encoding.UTF8); return 0; }
+            if (args.Length > 0 && args[0] == "--control-self-test") return ControlTests.Run(args.Skip(1).ToArray());
+            var app = new Application { ShutdownMode = ShutdownMode.OnExplicitShutdown };
+            app.DispatcherUnhandledException += delegate(object sender, DispatcherUnhandledExceptionEventArgs e) {
+                try { string folder = System.IO.Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData),"DrumBuddy"); Directory.CreateDirectory(folder); File.AppendAllText(System.IO.Path.Combine(folder,"error.log"),DateTime.Now + " " + e.Exception + Environment.NewLine); } catch { }
+                MessageBox.Show("Flux encountered a problem.\n\n" + e.Exception.Message,"Flux",MessageBoxButton.OK,MessageBoxImage.Error); e.Handled = true;
+            };
+            Window splash = null;
+            try {
+                var started = Stopwatch.StartNew();
+                var logo = BrandArtwork.Raster();
+                splash = new Window {
+                    Width = 300, Height = 320, WindowStyle = WindowStyle.None,
+                    AllowsTransparency = true, Background = Brushes.Transparent,
+                    ResizeMode = ResizeMode.NoResize, ShowInTaskbar = false,
+                    WindowStartupLocation = WindowStartupLocation.CenterScreen,
+                    Content = new Image { Source = logo, Stretch = Stretch.Uniform }
+                };
+                splash.Show();
+                // Paint the transparent logo before constructing the main interface.
+                app.Dispatcher.Invoke((Action)delegate { },DispatcherPriority.Render);
+                var main = new MainWindow();
+                app.MainWindow = main.NativeWindow;
+                app.ShutdownMode = ShutdownMode.OnMainWindowClose;
+                var splashTimer = new DispatcherTimer { Interval = TimeSpan.FromMilliseconds(Math.Max(1,300 - started.ElapsedMilliseconds)) };
+                splashTimer.Tick += delegate {
+                    splashTimer.Stop();
+                    // Remove the splash before Loaded/device discovery runs on the main window.
+                    splash.Close(); main.Show();
+                };
+                splashTimer.Start();
+                return app.Run();
+            }
+            catch (Exception ex) {
+                if (splash != null) splash.Close();
+                MessageBox.Show("Flux could not open. Please reinstall it.\n\n" + ex.Message,"Flux",MessageBoxButton.OK,MessageBoxImage.Error); return 1;
+            }
+        }
+    }
+}