@pro-gram/flux 0.0.0-stage → 1.6.0

package/source/InterfaceSettings.cs

@@ -0,0 +1,225 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Collections.Generic;
+using System.Windows;
+using System.Windows.Input;
+using System.Windows.Media;
+using System.Xml.Serialization;
+using System.Windows.Markup;
+using System.Windows.Controls;
+using System.Windows.Controls.Primitives;
+using System.Windows.Data;
+using System.Runtime.InteropServices;
+using System.Windows.Interop;
+
+namespace DrumBuddy
+{
+    public sealed class ShortcutBinding
+    {
+        public string Action, Key;
+        public int Modifiers;
+        public ShortcutBinding Copy() { return new ShortcutBinding { Action = Action, Key = Key, Modifiers = Modifiers }; }
+        public string Gesture {
+            get {
+                if (string.IsNullOrEmpty(Key) || Key == "None") return "Unassigned";
+                string text = ""; var mods = (ModifierKeys)Modifiers;
+                if ((mods & ModifierKeys.Control) != 0) text += "Ctrl+";
+                if ((mods & ModifierKeys.Alt) != 0) text += "Alt+";
+                if ((mods & ModifierKeys.Shift) != 0) text += "Shift+";
+                if ((mods & ModifierKeys.Windows) != 0) text += "Win+";
+                return text + (Key == "Back" ? "Backspace" : Key == "OemComma" ? "," : Key == "OemPlus" ? "=" : Key == "OemMinus" ? "-" : Key.StartsWith("D") && Key.Length == 2 && char.IsDigit(Key[1]) ? Key.Substring(1) : Key);
+            }
+        }
+    }
+    public sealed class InterfaceSettings
+    {
+        public string Theme = "Dark", Startup = "Editor", AudioOutputKey = "default", AudioInputKey;
+        public int PlaybackLatency = 80;
+        public int KeymapRevision;
+        public TempoGridOptions Grid = new TempoGridOptions();
+        public bool SnapToGrid = true, SnapToEdges = true;
+        public List<ShortcutBinding> Keybinds = new List<ShortcutBinding>();
+        public InterfaceSettings Copy()
+        { return new InterfaceSettings { Theme = Theme, Startup = Startup, AudioOutputKey = AudioOutputKey, AudioInputKey = AudioInputKey, PlaybackLatency = PlaybackLatency, KeymapRevision = KeymapRevision, Grid = Grid.Copy(), SnapToGrid = SnapToGrid, SnapToEdges = SnapToEdges, Keybinds = Keybinds.Select(b => b.Copy()).ToList() }; }
+        public string Signature()
+        { return Theme + "|" + Startup + "|" + AudioOutputKey + "|" + AudioInputKey + "|" + PlaybackLatency + "|" + Grid.Signature() + "|" + SnapToGrid + "|" + SnapToEdges + "|" + string.Join(";", Keybinds.OrderBy(b => b.Action).Select(b => b.Action + ":" + b.Key + ":" + b.Modifiers)); }
+    }
+    public static class InterfacePreferences
+    {
+        public static InterfaceSettings Current = Defaults();
+        public static event Action Changed;
+        public static readonly string SettingsFile = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "DrumBuddy", "interface-settings.xml");
+        public static readonly Dictionary<string, string> Actions = new Dictionary<string, string> {
+            { "play", "Play / pause" }, { "stop", "Stop playback" }, { "record", "Start / stop recording" },
+            { "split", "Split at playhead" }, { "scissors", "Toggle slice cursor (legacy)" }, { "selectTool", "Selection cursor" }, { "copy", "Copy selection" },
+            { "slipTool", "Slip source contents tool" }, { "fadeTool", "Fade tool" }, { "duplicate", "Duplicate selected audio" }, { "repeatClips", "Repeat selected audio" }, { "muteClips", "Mute / unmute selected clips" }, { "crossfade", "Crossfade selected clips" }, { "clearFades", "Clear clip fades" },
+            { "cut", "Cut selection" }, { "paste", "Paste at playhead" }, { "delete", "Delete selection" },
+            { "deleteAlternate", "Delete selection (alternate)" },
+            { "undo", "Undo" }, { "redo", "Redo" }, { "save", "Save session" }, { "saveAs", "Save session as" },
+            { "open", "Open session" }, { "new", "New session" }, { "import", "Import audio" }, { "export", "Export mix" },
+            { "start", "Go to start" }, { "end", "Go to end" }, { "home", "Open Home" }, { "editor", "Open Editor" },
+            { "converter", "Open Converter" }, { "player", "Open Media Player" }, { "settings", "Open Settings" }
+            , { "timelineSettings", "Open Timeline settings" }, { "zoomIn", "Editor zoom in" }, { "zoomInPlus", "Editor zoom in (+ key)" }, { "zoomInKeypad", "Editor zoom in (keypad)" }, { "zoomOut", "Editor zoom out" }, { "zoomOutKeypad", "Editor zoom out (keypad)" }, { "zoomFit", "Fit project in Editor" }, { "zoomSelection", "Fit selection in Editor" }
+        };
+        public static InterfaceSettings Defaults()
+        {
+            var settings = new InterfaceSettings { KeymapRevision = 1 };
+            string[] simple = { "play:Space", "stop:Space:Shift", "record:R", "split:S", "scissors:None", "copy:C:Control", "cut:X:Control", "paste:V:Control", "delete:Back", "deleteAlternate:Delete", "undo:Z:Control", "redo:Y:Control", "save:S:Control", "saveAs:S:Control,Shift", "open:O:Control", "new:N:Control", "import:I:Control", "export:E:Control", "start:Home", "end:End", "home:D1:Control", "editor:D2:Control", "converter:D3:Control", "player:D4:Control", "settings:OemComma:Control", "timelineSettings:None" };
+            simple = simple.Concat(new[] { "selectTool:V", "zoomIn:OemPlus:Control", "zoomInPlus:OemPlus:Control,Shift", "zoomInKeypad:Add:Control", "zoomOut:OemMinus:Control", "zoomOutKeypad:Subtract:Control", "zoomFit:D0:Control", "zoomSelection:D0:Control,Shift" }).ToArray();
+            simple = simple.Concat(new[] { "slipTool:Y", "fadeTool:F", "duplicate:D:Control", "repeatClips:L:Control", "muteClips:M", "crossfade:X", "clearFades:None" }).ToArray();
+            foreach (string text in simple) {
+                string[] parts = text.Split(':');
+                settings.Keybinds.Add(new ShortcutBinding { Action = parts[0], Key = parts[1], Modifiers = parts.Length > 2 ? (int)(ModifierKeys)Enum.Parse(typeof(ModifierKeys), parts[2]) : 0 });
+            }
+            return settings;
+        }
+        public static void Load(string legacyOutput, string legacyInput)
+        {
+            var settings = Defaults();
+            try {
+                using (var file = File.OpenRead(SettingsFile)) settings = (InterfaceSettings)new XmlSerializer(typeof(InterfaceSettings)).Deserialize(file);
+                Upgrade(settings);
+                Validate(settings);
+            }
+            catch { settings = Defaults(); settings.AudioOutputKey = legacyOutput ?? "default"; settings.AudioInputKey = legacyInput; }
+            settings.AudioOutputKey = AudioOutputs.NormalizeKey(settings.AudioOutputKey);
+            Current = settings; ThemePalette.Apply(settings.Theme == "Dark"); AudioOutputs.LatencyMilliseconds = settings.PlaybackLatency;
+        }
+        public static void Validate(InterfaceSettings settings)
+        {
+            if (settings.Grid == null) settings.Grid = new TempoGridOptions(); settings.Grid.Validate();
+            if (settings.Theme != "Dark" && settings.Theme != "Light") throw new IOException("Choose Dark or Light theme.");
+            if (settings.Startup != "Editor" && settings.Startup != "Home") throw new IOException("Choose Editor or Home as the startup screen.");
+            if (settings.PlaybackLatency < 40 || settings.PlaybackLatency > 250) throw new IOException("Choose a playback buffer between 40 and 250 milliseconds.");
+            var used = new Dictionary<string, string>();
+            foreach (var binding in settings.Keybinds) {
+                if (!Actions.ContainsKey(binding.Action)) continue;
+                Key key;
+                if (string.IsNullOrEmpty(binding.Key) || binding.Key == "None") continue;
+                if (!Enum.TryParse<Key>(binding.Key, out key) || IsModifier(key) || binding.Modifiers < 0 || binding.Modifiers > 15) throw new IOException("Invalid shortcut for " + Actions[binding.Action] + ".");
+                string signature = binding.Key + ":" + binding.Modifiers;
+                if (used.ContainsKey(signature)) throw new IOException(binding.Gesture + " is assigned to both " + Actions[used[signature]] + " and " + Actions[binding.Action] + ". Change or clear one binding.");
+                used[signature] = binding.Action;
+            }
+        }
+        public static void Upgrade(InterfaceSettings settings)
+        {
+            settings.AudioOutputKey = AudioOutputs.NormalizeKey(settings.AudioOutputKey);
+            if (settings.Grid == null) settings.Grid = new TempoGridOptions();
+            if (settings.Keybinds == null) settings.Keybinds = new List<ShortcutBinding>();
+            if (settings.KeymapRevision < 1) {
+                var oldDelete = settings.Keybinds.FirstOrDefault(b => b.Action == "delete");
+                if (oldDelete != null && oldDelete.Key == "Delete" && oldDelete.Modifiers == 0 && !settings.Keybinds.Any(b => b.Action != "delete" && b.Key == "Back" && b.Modifiers == 0)) oldDelete.Key = "Back";
+                settings.KeymapRevision = 1;
+            }
+            foreach (var binding in Defaults().Keybinds) if (!settings.Keybinds.Any(b => b.Action == binding.Action)) {
+                if (settings.Keybinds.Any(b => b.Key == binding.Key && b.Modifiers == binding.Modifiers)) { binding.Key = "None"; binding.Modifiers = 0; }
+                settings.Keybinds.Add(binding);
+            }
+        }
+        public static void Save(InterfaceSettings settings)
+        {
+            SaveToFile(settings, SettingsFile);
+            Current = settings.Copy(); ThemePalette.Apply(settings.Theme == "Dark"); AudioOutputs.LatencyMilliseconds = settings.PlaybackLatency;
+            var changed = Changed; if (changed != null) changed();
+        }
+        public static void SaveToFile(InterfaceSettings settings, string path)
+        {
+            Validate(settings); Directory.CreateDirectory(Path.GetDirectoryName(Path.GetFullPath(path)));
+            string temporary = path + "." + Guid.NewGuid().ToString("N") + ".tmp";
+            try {
+                using (var file = File.Create(temporary)) new XmlSerializer(typeof(InterfaceSettings)).Serialize(file, settings);
+                if (File.Exists(path)) File.Replace(temporary, path, null); else File.Move(temporary, path);
+            }
+            finally { if (File.Exists(temporary)) File.Delete(temporary); }
+        }
+        public static bool IsModifier(Key key)
+        { return key == Key.LeftCtrl || key == Key.RightCtrl || key == Key.LeftAlt || key == Key.RightAlt || key == Key.LeftShift || key == Key.RightShift || key == Key.LWin || key == Key.RWin || key == Key.None; }
+        public static string Resolve(Key key, ModifierKeys modifiers)
+        {
+            var binding = Current.Keybinds.FirstOrDefault(b => b.Key == key.ToString() && b.Modifiers == (int)modifiers);
+            return binding == null ? null : binding.Action;
+        }
+        public static string Gesture(string action)
+        { var binding = Current.Keybinds.FirstOrDefault(b => b.Action == action); return binding == null ? "Unassigned" : binding.Gesture; }
+    }
+    public static class ThemePalette
+    {
+        [DllImport("dwmapi.dll")] private static extern int DwmSetWindowAttribute(IntPtr window, int attribute, ref int value, int size);
+        private static void Caption(Window window)
+        { try { var handle = new WindowInteropHelper(window).Handle; if (handle != IntPtr.Zero) { int dark = Dark ? 1 : 0; if (DwmSetWindowAttribute(handle, 20, ref dark, 4) != 0) DwmSetWindowAttribute(handle, 19, ref dark, 4); } } catch { } }
+        private static readonly Dictionary<string, SolidColorBrush> brushes = new Dictionary<string, SolidColorBrush>(StringComparer.OrdinalIgnoreCase);
+        private static readonly Dictionary<string, PaletteColor> colorValues = new Dictionary<string, PaletteColor>(StringComparer.OrdinalIgnoreCase);
+        private sealed class PaletteColor : DependencyObject
+        {
+            public static readonly DependencyProperty ValueProperty = DependencyProperty.Register("Value", typeof(Color), typeof(PaletteColor));
+            public Color Value { get { return (Color)GetValue(ValueProperty); } set { SetValue(ValueProperty, value); } }
+        }
+        public static bool Dark = true;
+        private static readonly Dictionary<string, string> dark = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase) {
+            { "#FFFFFF", "#171A22" }, { "#F3F5F5", "#0D0F14" }, { "#182C37", "#E9EDF7" }, { "#526771", "#9AA4BA" },
+            { "#3F625F", "#A0B9D0" }, { "#7EA7A4", "#435577" }, { "#F0F5F4", "#171C29" },
+            { "#006D68", "#4FBCFF" }, { "#007A6B", "#4FBCFF" }, { "#E6ECEC", "#201E31" }, { "#C3CED0", "#32394D" },
+            { "#DFE5E6", "#282D3D" }, { "#DCE5E4", "#282D3D" }, { "#D4DFDF", "#282D3D" }, { "#EAF5F2", "#111C2B" },
+            { "#EAF6F3", "#141C2C" }, { "#F7FAF9", "#10131B" }, { "#FCFDFC", "#151923" }, { "#F4F8F6", "#12151E" },
+            { "#F0F8F5", "#192139" }, { "#E4ECEA", "#202536" }, { "#DCEFEB", "#1C2943" }, { "#EDF3F1", "#171B26" },
+            { "#D6E1DF", "#2C3349" }, { "#E0E8E5", "#242B3C" }, { "#DAE5E0", "#2A2B43" }, { "#B9DDD2", "#334567" },
+            { "#438B77", "#59CCFF" }, { "#5E9D89", "#7D9CFA" }, { "#CBD8D4", "#353951" }, { "#D0772C", "#FFB55E" },
+            { "#DAD5FA", "#3A315D" }, { "#7359C7", "#B497FF" },
+            { "#D17626", "#FFB55E" }, { "#277FA5", "#64CBFF" }, { "#386BA8", "#A28CFF" }, { "#5596C8", "#6BAAFF" },
+            { "#15877C", "#45B8F0" }, { "#16887D", "#45B8F0" }, { "#B52C36", "#EE657D" }, { "#D16A19", "#B3A0FF" }
+        };
+        public static Brush Brush(string value)
+        {
+            value = value == "White" ? "#FFFFFF" : value;
+            SolidColorBrush brush;
+            if (!brushes.TryGetValue(value, out brush)) {
+                var state = new PaletteColor { Value = Color(value) }; colorValues[value] = state;
+                brush = new SolidColorBrush();
+                BindingOperations.SetBinding(brush, SolidColorBrush.ColorProperty, new Binding("Value") { Source = state, Mode = BindingMode.OneWay });
+                brushes[value] = brush;
+            }
+            return brush;
+        }
+        private static Color Color(string value)
+        { string mapped; return (Color)ColorConverter.ConvertFromString(Dark && dark.TryGetValue(value, out mapped) ? mapped : value); }
+        public static void Apply(bool isDark)
+        {
+            Dark = isDark; foreach (var item in colorValues) item.Value.Value = Color(item.Key);
+            if (Application.Current != null) InstallResources(Application.Current.Resources);
+        }
+        public static void InstallResources(ResourceDictionary resources)
+        {
+            string[] colors = { "#FFFFFF", "#F3F5F5", "#182C37", "#526771", "#006D68", "#E6ECEC", "#C3CED0", "#DFE5E6", "#D4DFDF", "#EAF6F3", "#D16A19" };
+            foreach (string color in colors.Concat(dark.Keys).Distinct()) resources["Theme" + color.Substring(1)] = Brush(color);
+            resources["ThemeOnAccent"] = new SolidColorBrush(Dark ? Colors.Black : Colors.White);
+            var accent = new LinearGradientBrush { StartPoint = new Point(0, .5), EndPoint = new Point(1, .5) };
+            accent.GradientStops.Add(new GradientStop((Color)ColorConverter.ConvertFromString(Dark ? "#4FBCFF" : "#006D88"), 0));
+            accent.GradientStops.Add(new GradientStop((Color)ColorConverter.ConvertFromString(Dark ? "#A895FF" : "#6D51AE"), 1));
+            resources["ThemeAccent"] = accent;
+            resources[SystemColors.WindowBrushKey] = Brush("#FFFFFF"); resources[SystemColors.ControlBrushKey] = Brush("#FFFFFF");
+            resources[SystemColors.WindowTextBrushKey] = Brush("#182C37"); resources[SystemColors.ControlTextBrushKey] = Brush("#182C37");
+            resources[SystemColors.MenuBrushKey] = Brush("#F3F5F5"); resources[SystemColors.MenuTextBrushKey] = Brush("#182C37");
+            resources[SystemColors.HighlightBrushKey] = Brush("#006D68"); resources[SystemColors.HighlightTextBrushKey] = resources["ThemeOnAccent"];
+        }
+        public static void Install(Window window)
+        {
+            InstallResources(window.Resources);
+            if (!window.Resources.Contains("FluxShellStyles")) {
+                using (var file = System.Reflection.Assembly.GetExecutingAssembly().GetManifestResourceStream("ShellStyles.xaml")) {
+                    if (file != null) {
+                        var styles = (ResourceDictionary)XamlReader.Load(file);
+                        foreach (var type in new[] { typeof(Button), typeof(ToggleButton), typeof(ComboBox), typeof(ComboBoxItem), typeof(TextBox), typeof(MenuItem), typeof(ScrollBar), typeof(ListBox), typeof(ListBoxItem), typeof(CheckBox), typeof(RadioButton), typeof(Slider), typeof(ProgressBar) }) window.Resources[type] = styles[type];
+                    }
+                    else throw new IOException("The interface theme resource is missing from the app.");
+                }
+                window.Resources["FluxShellStyles"] = true;
+                window.SourceInitialized += delegate { Caption(window); };
+            }
+            window.Background = Brush("#F3F5F5"); window.Foreground = Brush("#182C37");
+            Caption(window);
+        }
+    }
+}

package/source/InterfaceTests.cs

@@ -0,0 +1,172 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Collections.Generic;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Input;
+using System.Windows.Media;
+using System.Windows.Media.Imaging;
+using System.Windows.Threading;
+using System.Xml.Serialization;
+
+namespace DrumBuddy
+{
+    public static class InterfaceTests
+    {
+        private static readonly List<string> log = new List<string>();
+        private static void Check(bool value, string message) { if (!value) throw new Exception(message); log.Add("PASS  " + message); }
+        private static IEnumerable<Button> Buttons(DependencyObject node)
+        {
+            var button = node as Button; if (button != null) yield return button;
+            for (int i = 0; i < VisualTreeHelper.GetChildrenCount(node); i++) foreach (var child in Buttons(VisualTreeHelper.GetChild(node, i))) yield return child;
+        }
+        private static void Picture(FrameworkElement view, string path, int width, int height)
+        {
+            view.Measure(new Size(width, height)); view.Arrange(new Rect(0, 0, width, height)); view.UpdateLayout();
+            var image = new RenderTargetBitmap(width, height, 96, 96, PixelFormats.Pbgra32);
+            var background = new DrawingVisual(); using (var context = background.RenderOpen()) context.DrawRectangle(ThemePalette.Brush("#F3F5F5"), null, new Rect(0, 0, width, height));
+            image.Render(background); image.Render(view); var encoder = new PngBitmapEncoder(); encoder.Frames.Add(BitmapFrame.Create(image)); using (var file = File.Create(path)) encoder.Save(file);
+        }
+        private static void RunOnDispatcher(Func<Task> action)
+        {
+            var previous = SynchronizationContext.Current; var dispatcher = Dispatcher.CurrentDispatcher;
+            SynchronizationContext.SetSynchronizationContext(new DispatcherSynchronizationContext(dispatcher));
+            try {
+                var task = action(); var frame = new DispatcherFrame();
+                task.ContinueWith(delegate { dispatcher.BeginInvoke((Action)delegate { frame.Continue = false; }); });
+                if (!task.IsCompleted) Dispatcher.PushFrame(frame); task.GetAwaiter().GetResult();
+            }
+            finally { SynchronizationContext.SetSynchronizationContext(previous); }
+        }
+        public static int Run(string[] args)
+        {
+            string root = Path.GetFullPath(args.Length > 0 ? args[0] : Path.Combine(Path.GetTempPath(), "FluxInterface_" + Guid.NewGuid().ToString("N")));
+            Directory.CreateDirectory(root); log.Clear(); var old = InterfacePreferences.Current; string oldOutput = AudioOutputs.PreferredKey;
+            try {
+                InterfacePreferences.Current = InterfacePreferences.Defaults(); AudioOutputs.PreferredKey = "default"; ThemePalette.Apply(true);
+                InterfacePreferences.Validate(InterfacePreferences.Current);
+                Check(InterfacePreferences.Current.Startup == "Editor" && InterfacePreferences.Current.Theme == "Dark", "Default to the Editor and dark theme");
+                Check(InterfacePreferences.Resolve(Key.S, ModifierKeys.None) == "split" && InterfacePreferences.Resolve(Key.C, ModifierKeys.Control) == "copy" && InterfacePreferences.Resolve(Key.V, ModifierKeys.Control) == "paste", "Keep S split and normal Ctrl+C / Ctrl+V defaults");
+                var conflict = InterfacePreferences.Defaults(); conflict.Keybinds.First(b => b.Action == "split").Key = "R"; bool rejected = false;
+                try { InterfacePreferences.Validate(conflict); } catch (IOException) { rejected = true; }
+                Check(rejected, "Reject duplicate shortcuts before saving settings");
+                string settingsFile = Path.Combine(root, "interface-settings.xml");
+                var settings = new SettingsWindow(null, "keybinds", false, value => InterfacePreferences.SaveToFile(value, settingsFile));
+                Picture((FrameworkElement)settings.Content, Path.Combine(root, "settings-keybinds-dark.png"), 920, 640);
+                Check(settings.CaptureForTest("split", Key.F9, ModifierKeys.Control), "Edit immediately selects a capture field, waits for keys, and replaces the binding");
+                Check(settings.HasUnsavedChanges, "Mark an edited shortcut as unsaved");
+                Check(settings.LeaveForTest(true) && !settings.HasUnsavedChanges && File.Exists(settingsFile), "Yes saves pending keybind settings before exit");
+                InterfaceSettings saved;
+                using (var file = File.OpenRead(settingsFile)) saved = (InterfaceSettings)new XmlSerializer(typeof(InterfaceSettings)).Deserialize(file);
+                Check(saved.Keybinds.First(b => b.Action == "split").Gesture == "Ctrl+F9", "Persist the captured shortcut to the settings file");
+                var changed = saved.Copy(); changed.Theme = "Light"; settings.SetDraftForTest(changed); byte[] before = File.ReadAllBytes(settingsFile);
+                Check(settings.HasUnsavedChanges && settings.LeaveForTest(false) && before.SequenceEqual(File.ReadAllBytes(settingsFile)), "No exits with pending changes without saving them");
+                settings.SetDraftForTest(saved); Check(settings.CaptureForTest("split", Key.C, ModifierKeys.Control), "Capture a shortcut containing a standard modifier combination");
+                Check(!settings.LeaveForTest(true) && settings.HasUnsavedChanges, "A conflicting shortcut prevents the Save-and-exit path from closing settings");
+                settings.SetDraftForTest(saved); settings.Close();
+                var text = (SolidColorBrush)ThemePalette.Brush("#182C37"); var dark = text.Color; ThemePalette.Apply(false);
+                Check(text.Color != dark && text.Color == (Color)ColorConverter.ConvertFromString("#182C37"), "Switch the same live brush from dark to light without rebuilding controls");
+                ThemePalette.Apply(true);
+                Picture(new Image { Source = BrandArtwork.Load(), Stretch = Stretch.Uniform }, Path.Combine(root, "refined-vector-logo.png"), 840, 640);
+                var main = new MainWindow(Path.Combine(root, "legacy-preferences.xml"), true);
+                Check(main.NativeWindow.Title == "Flux", "Use exactly Flux as the window title");
+                Check(object.ReferenceEquals(main.NativeWindow.Icon, BrandArtwork.Raster()), "Use the current Flux mark directly for the window and taskbar icon");
+                main.OpenEditorForTest(); Check(main.IntegratedRecorderForTest, "Mount recording controls inside the main Editor while retaining named input controls");
+                string demoPath = Path.Combine(root, "Generated demo.wav"); var demo = new float[Audio.Rate * 8];
+                for (int i = 0; i < demo.Length; i++) demo[i] = (float)(.7 * Math.Exp(-(i % (Audio.Rate / 2)) / 3000.0) * Math.Sin(i * .06));
+                using (var writer = new FloatWaveWriter(demoPath, 1, Audio.Rate)) writer.Write(demo, demo.Length, 1);
+                var demoClip = Audio.Load(demoPath, Path.Combine(root, "demo-cache"), CancellationToken.None, null);
+                var demoSession = new EditorSession { Name = "Generated demo" };
+                string[] names = { "Kick", "Snare", "Hi-hat", "Toms", "Overhead L", "Overhead R", "Room", "Guide" };
+                for (int i = 0; i < names.Length; i++) { demoSession.Tracks[i].Name = names[i]; demoSession.Regions.Add(new TimelineRegion { Source = demoClip.Source, Name = names[i], Track = i, Start = (i % 3) * Audio.Rate / 2, Length = (6 - i % 3) * Audio.Rate }); }
+                main.EditorFixtureForTest(demoSession, new Dictionary<string, Clip> { { demoClip.Source, demoClip } });
+                Check(!Buttons(main.RecordingPaneForTest.MainContent).Any(b => new[] { "Cut", "Copy", "Paste" }.Contains(b.Content as string)), "Remove Cut, Copy and Paste buttons from the editor toolbar");
+                Check(!Buttons(main.RecordingPaneForTest.MainContent).Any(b => ((b.Content as string) ?? "").Contains("Split") || ((b.Content as string) ?? "").Contains("Scissors")), "Keep split on the S action and remove redundant scissors/split toolbar buttons");
+                Check(main.NativeWindow.FindName("SettingsTimeline") != null, "Expose Timeline / grid in Settings");
+                var initialGrid = InterfacePreferences.Current.Copy(); initialGrid.Grid = main.GridForTest;
+                string gridSettingsFile = Path.Combine(root, "saved-grid-settings.xml");
+                var gridSettings = new SettingsWindow(null, "timeline", false, value => { InterfacePreferences.SaveToFile(value, gridSettingsFile); main.ApplySettingsForTest(value); }, initialGrid);
+                Picture((FrameworkElement)gridSettings.Content, Path.Combine(root, "settings-timeline-dark.png"), 920, 640);
+                var gridDraft = initialGrid.Copy(); gridDraft.Grid.Tempo = 135; gridDraft.Grid.BeatsPerBar = 7; gridDraft.Grid.BeatUnit = 8; gridDraft.Grid.Division = 32; gridDraft.SnapToEdges = false;
+                gridSettings.SetDraftForTest(gridDraft);
+                Check(gridSettings.HasUnsavedChanges && gridSettings.LeaveForTest(false) && !File.Exists(gridSettingsFile) && main.GridForTest.Tempo == 120, "No exits pending timeline changes without applying them");
+                gridDraft.Grid.Tempo = double.NaN; gridSettings.SetDraftForTest(gridDraft);
+                Check(!gridSettings.LeaveForTest(true) && !File.Exists(gridSettingsFile), "Invalid BPM blocks saving and leaving timeline settings");
+                gridDraft.Grid.Tempo = 135; gridSettings.SetDraftForTest(gridDraft);
+                Check(gridSettings.LeaveForTest(true) && main.GridForTest.Tempo == 135 && main.GridForTest.BeatUnit == 8 && !InterfacePreferences.Current.SnapToEdges, "Save applies project tempo, time signature, division and independent snapping");
+                gridSettings.Close();
+                main.EditorFixtureForTest(demoSession, new Dictionary<string, Clip> { { demoClip.Source, demoClip } });
+                var appearance = InterfacePreferences.Current.Copy(); appearance.Theme = "Light"; main.ApplySettingsForTest(appearance);
+                Check(main.GridForTest.Tempo == 120, "Changing appearance preserves a project's grid when it differs from saved defaults");
+                main.ApplySettingsForTest(InterfacePreferences.Defaults()); main.OpenEditorForTest();
+                main.SetGridForTest(new TempoGridOptions { Division = 32 }, 320); Picture((FrameworkElement)main.NativeWindow.Content, Path.Combine(root, "editor-grid-32-dark.png"), 1280, 800);
+                main.SetGridForTest(new TempoGridOptions { Division = 128, Triplet = true }, 1280); Picture((FrameworkElement)main.NativeWindow.Content, Path.Combine(root, "editor-grid-128-triplet-dark.png"), 1280, 800);
+                main.EditorFixtureForTest(demoSession, new Dictionary<string, Clip> { { demoClip.Source, demoClip } }); main.SetGridForTest(demoSession.Grid, 40); main.OpenEditorForTest();
+                Picture((FrameworkElement)main.NativeWindow.Content, Path.Combine(root, "editor-shell-dark.png"), 1280, 800);
+                Check(main.EditorTimelineHeightForTest >= 550, "Reserve at least 550 vertical pixels for the timeline at 1280 x 800");
+                log.Add("Timeline viewport at 1280 x 800: " + main.EditorTimelineHeightForTest.ToString("0") + " px.");
+                Picture((FrameworkElement)main.NativeWindow.Content, Path.Combine(root, "editor-compact-dark.png"), 850, 560);
+                Check(main.EditorTimelineHeightForTest >= 250, "Keep a usable timeline after packing controls at 850 x 560");
+                log.Add("Timeline viewport at 850 x 560: " + main.EditorTimelineHeightForTest.ToString("0") + " px.");
+                main.RecordingPanelForTest(); Picture((FrameworkElement)main.NativeWindow.Content, Path.Combine(root, "editor-record-dark.png"), 1280, 800);
+                Picture((FrameworkElement)main.NativeWindow.Content, Path.Combine(root, "editor-record-compact-dark.png"), 850, 560);
+                main.RecordingPaneForTest.SetBottom(true); Picture((FrameworkElement)main.NativeWindow.Content, Path.Combine(root, "editor-record-bottom-compact-dark.png"), 850, 560);
+                Check(main.RecordingPaneForTest.MainContent.ActualHeight >= 239, "Keep room for the editor when bottom recording options are constrained by a small window");
+                Picture((FrameworkElement)main.NativeWindow.Content, Path.Combine(root, "editor-record-bottom-dark.png"), 1280, 800);
+                Check(main.RecordingPaneForTest.OnBottom && main.RecordingPaneForTest.MainContent.ActualHeight > 120 && main.RecordingPaneForTest.RowDefinitions[2].ActualHeight >= 200, "Restore a useful recording-panel height after enlarging the window");
+                main.RecordingPaneForTest.SetExpanded(false); Picture((FrameworkElement)main.NativeWindow.Content, Path.Combine(root, "editor-record-collapsed-dark.png"), 1280, 800);
+                Check(!main.RecordingPaneForTest.IsExpanded && main.RecordingPaneForTest.RowDefinitions[2].ActualHeight <= 33, "Collapse recording controls to a small restore strip");
+                main.RecordingPaneForTest.SetExpanded(true); main.RecordingPaneForTest.SetBottom(false);
+                main.OpenHomeForTest(); Picture((FrameworkElement)main.NativeWindow.Content, Path.Combine(root, "home-dark.png"), 1280, 800);
+                main.SetThemeForTest(false); Picture((FrameworkElement)main.NativeWindow.Content, Path.Combine(root, "home-light.png"), 1280, 800);
+                main.OpenEditorForTest(); Picture((FrameworkElement)main.NativeWindow.Content, Path.Combine(root, "editor-shell-light.png"), 1280, 800);
+                main.OpenConverterForTest(); main.ConverterClipForTest(demoClip); Picture((FrameworkElement)main.NativeWindow.Content, Path.Combine(root, "converter-light.png"), 1280, 800);
+                main.SetThemeForTest(true); Picture((FrameworkElement)main.NativeWindow.Content, Path.Combine(root, "converter-dark.png"), 1280, 800);
+                Check(main.NativeWindow.FindName("ConvertTab") == null && main.NativeWindow.FindName("ViewConverter") != null && main.NativeWindow.FindName("GainSlider") == null, "Open Converter from View without a navigation tab or gain amplifier");
+                Check(((ComboBox)main.NativeWindow.FindName("ConvertFormat")).Items.Contains("AIFF"), "Offer AIFF as a conversion destination");
+                main.ConverterPaneForTest.SetBottom(false); Picture((FrameworkElement)main.NativeWindow.Content, Path.Combine(root, "converter-side-dark.png"), 1280, 800);
+                double widePane = main.ConverterPaneForTest.ColumnDefinitions[2].ActualWidth, oldMain = main.ConverterPaneForTest.MainContent.ActualWidth;
+                main.ConverterPaneForTest.ColumnDefinitions[2].Width = new GridLength(245); Picture((FrameworkElement)main.NativeWindow.Content, Path.Combine(root, "converter-side-narrow-dark.png"), 1280, 800);
+                Check(main.ConverterPaneForTest.ColumnDefinitions[2].ActualWidth < widePane && main.ConverterPaneForTest.MainContent.ActualWidth > oldMain, "Shrink the conversion options pane and give the recovered width to the file area");
+                main.ConverterPaneForTest.SetExpanded(false); Picture((FrameworkElement)main.NativeWindow.Content, Path.Combine(root, "converter-collapsed-dark.png"), 850, 560);
+                Check(main.ConverterPaneForTest.MainContent.ActualWidth > 700, "Collapse converter options while keeping a visible restore control");
+                var player = main.OpenPlayerForTest(); var playerClip = Audio.Load(demoPath, Path.Combine(root, "player-gain-cache"), CancellationToken.None, null); byte[] playerOriginal = File.ReadAllBytes(demoPath); player.SetForTest(playerClip);
+                player.GainForTest(-6, false); Check(Math.Abs(player.PlaybackGainForTest - .8 * Math.Pow(10, -6 / 20.0)) < .0001, "Apply a media-player gain reduction to its playback sample multiplier");
+                string reduced = player.SaveCopyForTest(Path.Combine(root, "gain-copies"), "Reduced copy"); var reducedClip = Audio.Load(reduced, Path.Combine(root, "gain-copy-cache"), CancellationToken.None, null);
+                Check(Math.Abs(reducedClip.Peak / playerClip.Peak - Math.Pow(10, -6 / 20.0)) < .002, "Save the actual -6 dB adjustment in a new PCM audio copy");
+                player.GainForTest(6, false); Check(player.PlaybackGainForTest > 1.59, "Amplify media-player playback with positive gain when protection is disabled");
+                player.GainForTest(6, true); string safeCopy = player.SaveCopyForTest(Path.Combine(root, "gain-copies"), "Safe copy");
+                Check(Audio.Load(safeCopy, Path.Combine(root, "safe-copy-cache"), CancellationToken.None, null).Peak < .9 && playerOriginal.SequenceEqual(File.ReadAllBytes(demoPath)), "Cap amplified copy peaks with protection and preserve the original audio bytes");
+                Picture((FrameworkElement)main.NativeWindow.Content, Path.Combine(root, "media-player-gain-dark.png"), 1280, 800);
+                player.GainPaneForTest.SetBottom(true); Picture((FrameworkElement)main.NativeWindow.Content, Path.Combine(root, "media-player-gain-bottom-dark.png"), 1280, 800);
+                Check(player.GainPaneForTest.OnBottom && player.GainPaneForTest.MainContent.ActualHeight > 100, "Dock media-player gain and its compact Save copy action below playback");
+                player.GainPaneForTest.SetExpanded(false); Picture((FrameworkElement)main.NativeWindow.Content, Path.Combine(root, "media-player-gain-collapsed-dark.png"), 850, 560);
+                Check(!player.GainPaneForTest.IsExpanded, "Collapse the media-player gain panel and retain a restore control");
+                Check(main.NativeWindow.FindName("ThemeToggle") != null && main.NativeWindow.FindName("FileSave") != null && main.NativeWindow.FindName("SettingsKeys") != null, "Expose top-right theme switching and File/View/Install/Settings/Help menus");
+                main.NativeWindow.Close();
+                ThemePalette.Apply(true);
+                var owner = new Window(); ThemePalette.Install(owner);
+                string source = Path.Combine(root, "recorded-input.wav"); var samples = new float[4800]; for (int i = 0; i < samples.Length; i++) samples[i] = (float)(1.5 * Math.Sin(i * .08));
+                using (var writer = new FloatWaveWriter(source, 1, 48000)) writer.Write(samples, samples.Length, 1);
+                byte[] original = File.ReadAllBytes(source);
+                using (var editor = new EditorView(owner, Path.Combine(root, "record-cache"), delegate(string message) { }, delegate { })) {
+                    owner.Content = editor;
+                    RunOnDispatcher(() => editor.AddRecordedFiles(new[] { source }, Audio.Rate * 2L, 5));
+                    var session = editor.SessionForTest;
+                    Check(session.Regions.Count == 1 && session.Regions[0].Track == 5 && session.Regions[0].Start == Audio.Rate * 2L, "Insert a saved recording at its original playhead position on the selected editor track");
+                    Check(original.SequenceEqual(File.ReadAllBytes(source)), "Keep the original float take unchanged while adding it to the timeline");
+                    RunOnDispatcher(async delegate { await editor.ExecuteAction("undo"); }); Check(editor.SessionForTest.Regions.Count == 0, "Undo adding a recording without deleting its source file");
+                }
+                owner.Content = null; owner.Close();
+                log.Add("Offscreen UI and generated-buffer checks. Physical key focus, real recording timing and the affected Realtek PC still require hands-on acceptance.");
+                File.WriteAllLines(Path.Combine(root, "interface-test-results.txt"), log, Encoding.UTF8); return 0;
+            }
+            catch (Exception ex) { log.Add("FAIL  " + ex); File.WriteAllLines(Path.Combine(root, "interface-test-results.txt"), log, Encoding.UTF8); return 1; }
+            finally { InterfacePreferences.Current = old; AudioOutputs.PreferredKey = oldOutput; ThemePalette.Apply(old.Theme == "Dark"); }
+        }
+    }
+}

package/source/LICENSE.txt

@@ -0,0 +1,23 @@
+MIT License
+
+Copyright (c) 2026 Drum Buddy contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+Third-party programs, libraries and the Zoom driver retain their own licenses.

package/source/Logo Prompt.txt

@@ -0,0 +1,16 @@
+Generation mode: OpenAI built-in image generation, transparent background.
+
+Final logo brief:
+Original mascot logo and Windows app icon for Drum Buddy. A friendly vintage
+drummer with long, thick, curly black hair flowing out from under a black
+marching-band hat to his shoulders. Natural, easygoing, youthful 1970s face
+with a relaxed smile. Red vest, cream white puff-sleeve shirt, brass accents,
+two wooden drumsticks and a red-and-cream marching snare drum. Nostalgic
+early-20th-century snack-box illustration influence with a 1970s musician's
+hair and face. Crisp black/navy outlines, limited red, black, cream and brass
+palette, compact centered composition. Transparent background, no lettering,
+extra figures, frame, or watermark.
+
+The final artwork was generated as an edit of the first mascot, changing the
+face and hairstyle while preserving his clothes, hat, hands, sticks, drum,
+composition, and transparent background.