@pro-gram/flux 0.0.0-stage → 1.6.0

package/source/EditorToolInteractions.cs

@@ -0,0 +1,227 @@
+using System;
+using System.Linq;
+using System.Collections.Generic;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Input;
+using System.Windows.Media;
+using System.Windows.Shapes;
+using System.Windows.Threading;
+
+namespace DrumBuddy
+{
+    public sealed partial class EditorView
+    {
+        private ClipDrag clipDrag;
+        private EditorSession clipBefore;
+        private Dictionary<string, TimelineRegion> clipOriginal;
+        private string dragId, pointerTool = "select";
+        private Point dragOrigin;
+        private long dragOriginFrame;
+        private int dragOriginTrack;
+        private bool clipChanged, renderPending, changingTool;
+        private ComboBox toolPicker;
+
+        private void InitializeClipTools(Panel toolbar)
+        {
+            toolPicker = new ComboBox { ItemsSource = new[] { "Select (V)", "Slip (Y)", "Fade (F)" }, SelectedIndex = 0, Width = 112, MinHeight = 30, Margin = new Thickness(0, 0, 6, 6) };
+            toolPicker.SelectionChanged += delegate { if (!changingTool) SetPointerTool(toolPicker.SelectedIndex == 1 ? "slip" : toolPicker.SelectedIndex == 2 ? "fade" : "select"); }; toolbar.Children.Add(toolPicker);
+            var menu = new ContextMenu(); timeline.ContextMenu = menu;
+            string[,] commands = {
+                { "Selection cursor", "selectTool" }, { "Slip source contents", "slipTool" }, { "Fade tool", "fadeTool" },
+                { "Split at playhead", "split" }, { "Duplicate", "duplicate" }, { "Repeat…", "repeatClips" },
+                { "Mute / unmute clips", "muteClips" }, { "Crossfade selected clips", "crossfade" }, { "Clear clip fades", "clearFades" },
+                { "Cut", "cut" }, { "Copy", "copy" }, { "Paste", "paste" }, { "Delete", "delete" }
+            };
+            for (int i = 0; i < commands.GetLength(0); i++) {
+                string action = commands[i, 1]; var item = new MenuItem { Header = commands[i, 0], Tag = action };
+                item.Click += async delegate { await ExecuteAction(action); }; menu.Items.Add(item);
+            }
+            timeline.PreviewMouseRightButtonDown += delegate(object sender, MouseButtonEventArgs e) {
+                SelectContextTarget(e.GetPosition(timeline));
+            };
+            timeline.ContextMenuOpening += delegate(object sender, ContextMenuEventArgs e) {
+                if (IsBusy) { e.Handled = true; return; }
+                foreach (MenuItem item in menu.Items) { string key = InterfacePreferences.Gesture((string)item.Tag); item.InputGestureText = key == "Unassigned" ? "" : key; }
+            };
+        }
+        private void SelectContextTarget(Point point)
+        {
+            if (IsBusy) return; var region = RegionAt(point); long frame = FrameAt(point.X);
+            bool inRange = region != null && !clipSelection && to > from && frame >= from && frame < to && (AllTracks || region.Track == track);
+            if (region != null && !inRange && (!clipSelection || !selectedIds.Contains(region.Id))) { track = region.Track; SelectRegion(region, false); BuildHeaders(); DrawCanvas(); }
+            timeline.Focus();
+        }
+        private void SetPointerTool(string tool)
+        {
+            pointerTool = tool; sliceCursor = false;
+            changingTool = true; toolPicker.SelectedIndex = tool == "slip" ? 1 : tool == "fade" ? 2 : 0; changingTool = false;
+            timeline.Cursor = tool == "select" ? Cursors.Arrow : Cursors.SizeWE; timeline.Focus(); UpdateSelectionText();
+        }
+        private TimelineRegion RegionAt(Point point)
+        {
+            if (point.Y < RulerHeight) return null;
+            int row = Math.Max(0, Math.Min(15, (int)((point.Y - RulerHeight) / RowHeight))); long frame = FrameAt(point.X);
+            var hit = session.Regions.LastOrDefault(r => r.Track == row && r.Start <= frame && r.End > frame);
+            if (hit == null || (pointerTool == "select" && clipSelection && point.Y - RulerHeight - row * RowHeight >= 13)) {
+                var edge = session.Regions.Where(r => r.Track == row && (hit == null || selectedIds.Contains(r.Id))).OrderBy(r => Math.Min(Math.Abs(point.X - X(r.Start)), Math.Abs(point.X - X(r.End)))).FirstOrDefault();
+                if (edge != null && Math.Min(Math.Abs(point.X - X(edge.Start)), Math.Abs(point.X - X(edge.End))) <= 6) return edge;
+            }
+            return hit;
+        }
+        private ClipDrag ClipToolAt(TimelineRegion region, Point point)
+        {
+            if (pointerTool == "slip") return ClipDrag.Slip;
+            if (pointerTool == "fade") return point.X < (X(region.Start) + X(region.End)) / 2 ? ClipDrag.FadeIn : ClipDrag.FadeOut;
+            double y = point.Y - RulerHeight - region.Track * RowHeight;
+            if (RegionSelected(region) && y < 13) {
+                if (Math.Abs(point.X - FadeX(region, true)) <= 7) return ClipDrag.FadeIn;
+                if (Math.Abs(point.X - FadeX(region, false)) <= 7) return ClipDrag.FadeOut;
+            }
+            if (y >= 13 && Math.Abs(point.X - X(region.Start)) <= 6) return ClipDrag.TrimLeft;
+            if (y >= 13 && Math.Abs(point.X - X(region.End)) <= 6) return ClipDrag.TrimRight;
+            return y < 19 ? ClipDrag.Move : ClipDrag.None;
+        }
+        private void UpdateClipCursor(Point point)
+        {
+            if (sliceCursor) { timeline.Cursor = Cursors.Cross; return; }
+            var region = RegionAt(point); var tool = region == null ? ClipDrag.None : ClipToolAt(region, point);
+            timeline.Cursor = tool == ClipDrag.Move ? Cursors.SizeAll : tool == ClipDrag.None ? Cursors.Arrow : Cursors.SizeWE;
+        }
+        private void BeginClipDrag(ClipDrag tool, TimelineRegion region, Point point)
+        {
+            if (tool != ClipDrag.Move || !clipSelection || !selectedIds.Contains(region.Id)) SelectRegion(region, false);
+            clipBefore = session.Copy(); clipOriginal = session.Regions.Where(r => selectedIds.Contains(r.Id)).ToDictionary(r => r.Id, r => r.Copy());
+            clipDrag = tool; dragId = region.Id; dragOrigin = point; dragOriginFrame = FrameAt(point.X); dragOriginTrack = region.Track; clipChanged = false;
+            playhead = PointerFrame(point.X); RefreshGridToolbar(); RefreshClipBounds(); BuildHeaders(); DrawCanvas();
+        }
+        private long SourceFrames(TimelineRegion region)
+        {
+            Clip clip; if (!assets.TryGetValue(region.Source, out clip)) throw new System.IO.IOException("The clip's source is missing. Re-import it before editing.");
+            return (long)Math.Round(clip.Duration * Audio.Rate);
+        }
+        private long ToolFrame(double x)
+        { return TimelineGesture.FrameAt(x, pixelsPerSecond, session.Regions.Where(r => !selectedIds.Contains(r.Id)).SelectMany(r => new[] { r.Start, r.End }), (Keyboard.Modifiers & ModifierKeys.Alt) != 0, session.Grid, InterfacePreferences.Current.SnapToGrid, InterfacePreferences.Current.SnapToEdges); }
+        private void PreviewClipDrag(Point point)
+        {
+            if (clipDrag == ClipDrag.None) return;
+            try {
+                foreach (var region in session.Regions) {
+                    TimelineRegion original; if (!clipOriginal.TryGetValue(region.Id, out original)) continue;
+                    region.Start = original.Start; region.Track = original.Track; region.SourceStart = original.SourceStart; region.Length = original.Length;
+                    region.FadeIn = original.FadeIn; region.FadeOut = original.FadeOut; region.FadeInOffset = original.FadeInOffset; region.FadeOutOffset = original.FadeOutOffset;
+                }
+                var target = session.Regions.First(r => r.Id == dragId);
+                if (clipDrag == ClipDrag.Move) {
+                    long first = clipOriginal.Values.Min(r => r.Start);
+                    double anchor = (dragOriginFrame - first) / (double)Audio.Rate * pixelsPerSecond;
+                    long delta = ToolFrame(point.X - anchor) - first; int row = (int)Math.Floor((point.Y - RulerHeight) / RowHeight);
+                    EditorTools.Move(session, selectedIds, delta, row - dragOriginTrack); track = target.Track;
+                }
+                else if (clipDrag == ClipDrag.TrimLeft || clipDrag == ClipDrag.TrimRight) EditorTools.Trim(target, clipDrag == ClipDrag.TrimLeft, ToolFrame(point.X), SourceFrames(target));
+                else if (clipDrag == ClipDrag.Slip) {
+                    long delta = (long)Math.Round((dragOrigin.X - point.X) / pixelsPerSecond * Audio.Rate);
+                    if (InterfacePreferences.Current.SnapToGrid && (Keyboard.Modifiers & ModifierKeys.Alt) == 0) { double step = TempoGrid.StepSeconds(session.Grid) * Audio.Rate; delta = (long)Math.Round(Math.Round(delta / step) * step); }
+                    EditorTools.Slip(target, delta, SourceFrames(target));
+                }
+                else EditorTools.Fade(target, clipDrag == ClipDrag.FadeIn, clipDrag == ClipDrag.FadeIn ? ToolFrame(point.X) - target.Start : target.End - ToolFrame(point.X));
+                clipChanged = session.Regions.Where(r => clipOriginal.ContainsKey(r.Id)).Any(r => {
+                    var old = clipOriginal[r.Id]; return r.Start != old.Start || r.Track != old.Track || r.SourceStart != old.SourceStart || r.Length != old.Length || r.FadeIn != old.FadeIn || r.FadeOut != old.FadeOut || r.FadeInOffset != old.FadeInOffset || r.FadeOutOffset != old.FadeOutOffset;
+                });
+                RefreshClipBounds(); RequestClipRender();
+            }
+            catch (Exception ex) { CancelClipDrag(); status("Could not edit this clip: " + ex.Message); }
+        }
+        private void RequestClipRender()
+        {
+            if (renderPending) return; renderPending = true;
+            Dispatcher.BeginInvoke(DispatcherPriority.Render, (Action)delegate { renderPending = false; if (!disposed) DrawCanvas(); });
+        }
+        private void FinishClipDrag()
+        {
+            if (clipDrag == ClipDrag.None) return; var action = clipDrag;
+            try { session.Validate(); if (clipChanged) { undo.Push(clipBefore); redo.Clear(); dirty = true; } }
+            catch (Exception ex) { session = clipBefore; clipChanged = false; status("Could not finish the clip edit: " + ex.Message); }
+            clipDrag = ClipDrag.None; clipBefore = null; clipOriginal = null; RefreshClipBounds(); RefreshGridToolbar(); BuildHeaders(); DrawCanvas();
+            if (clipChanged) status(action == ClipDrag.Move ? "Clips moved." : action == ClipDrag.Slip ? "Source contents slipped." : action == ClipDrag.TrimLeft || action == ClipDrag.TrimRight ? "Clip trimmed." : "Clip fade updated.");
+        }
+        private void CancelClipDrag()
+        {
+            if (clipDrag == ClipDrag.None) return; session = clipBefore; clipDrag = ClipDrag.None; clipBefore = null; clipOriginal = null;
+            selectedIds.Clear(); if (previousIds != null) foreach (string id in previousIds) selectedIds.Add(id); clipSelection = previousClipSelection; track = previousTrack;
+            from = previousFrom; to = previousTo; playhead = previousPlayhead;
+            RefreshClipBounds(); UpdateSelectionText(); RefreshGridToolbar(); BuildHeaders(); DrawCanvas();
+        }
+        private double FadeX(TimelineRegion region, bool incoming)
+        {
+            long frames = incoming ? Math.Max(0, region.FadeIn - region.FadeInOffset) : Math.Max(0, region.FadeOut - region.FadeOutOffset);
+            return X(incoming ? region.Start + Math.Min(region.Length, frames) : region.End - Math.Min(region.Length, frames));
+        }
+        private void DrawClipFades(TimelineRegion region, double left, double right, bool selected)
+        {
+            double y = RulerHeight + region.Track * RowHeight + 4;
+            if (region.FadeIn > 0 || region.FadeOut > 0) {
+                var line = new Polyline { Stroke = WorkspaceUi.Color("#7359C7"), StrokeThickness = 1.3, IsHitTestVisible = false };
+                var positions = new[] { Math.Max(left, X(region.Start)), Math.Min(right, X(region.End)), FadeX(region, true), FadeX(region, false) }.Where(x => x >= left && x <= right && x >= X(region.Start) && x <= X(region.End)).Distinct().OrderBy(x => x);
+                foreach (double x in positions) line.Points.Add(new Point(x, y + 4 + (1 - EditorTools.Envelope(region, Math.Min(region.Length - 1, Math.Max(0, FrameAt(x) - region.Start)))) * (RowHeight - 14)));
+                timeline.Children.Add(line);
+            }
+            if (selected) foreach (bool incoming in new[] { true, false }) {
+                double x = FadeX(region, incoming); if (x < left || x > right) continue;
+                var handle = new Polygon { Fill = WorkspaceUi.Color("#7359C7"), IsHitTestVisible = false };
+                handle.Points.Add(new Point(x, y)); handle.Points.Add(new Point(x + (incoming ? 7 : -7), y)); handle.Points.Add(new Point(x, y + 8)); timeline.Children.Add(handle);
+            }
+        }
+        private HashSet<string> EditableClipIds()
+        {
+            if (clipSelection) return new HashSet<string>(selectedIds);
+            if (to <= from) return new HashSet<string>();
+            TimelineEdits.Split(session, track, AllTracks, from); TimelineEdits.Split(session, track, AllTracks, to);
+            return new HashSet<string>(session.Regions.Where(r => (AllTracks || r.Track == track) && r.Start >= from && r.End <= to).Select(r => r.Id));
+        }
+        private void SelectAdded(IEnumerable<string> ids)
+        { selectedIds.Clear(); foreach (string id in ids) selectedIds.Add(id); clipSelection = selectedIds.Count > 0; RefreshClipBounds(); }
+        private void RepeatClips(int count)
+        {
+            Change(delegate {
+                if (clipSelection) { SelectAdded(EditorTools.Repeat(session, selectedIds, count)); return true; }
+                if (to <= from) return false; var copied = TimelineEdits.Copy(session, track, AllTracks, from, to); if (copied.Regions.Count == 0) return false;
+                var before = new HashSet<string>(session.Regions.Select(r => r.Id)); long start = from;
+                for (int n = 1; n <= count; n++) TimelineEdits.Paste(session, copied, track, start + copied.Length * n);
+                SelectAdded(session.Regions.Where(r => !before.Contains(r.Id)).Select(r => r.Id).ToArray()); return true;
+            }, count == 1 ? "Selection duplicated." : "Selection repeated.");
+        }
+        private bool ExecuteClipAction(string action)
+        {
+            switch (action) {
+                case "slipTool": SetPointerTool("slip"); return true;
+                case "fadeTool": SetPointerTool("fade"); return true;
+                case "duplicate": RepeatClips(1); return true;
+                case "repeatClips": var count = AskRepeatCount(); if (count.HasValue) RepeatClips(count.Value); return true;
+                case "muteClips": Change(delegate { var ids = EditableClipIds(); bool changed = EditorTools.ToggleMute(session, ids); if (changed) SelectAdded(ids); return changed; }, "Clip mute updated."); return true;
+                case "crossfade": Change(() => EditorTools.Crossfade(session, selectedIds), "Crossfade applied."); return true;
+                case "clearFades": Change(delegate { var ids = EditableClipIds(); bool changed = false; foreach (var region in session.Regions.Where(r => ids.Contains(r.Id))) { changed |= region.FadeIn > 0 || region.FadeOut > 0; region.FadeIn = region.FadeOut = region.FadeInOffset = region.FadeOutOffset = 0; } if (changed) SelectAdded(ids); return changed; }, "Clip fades cleared."); return true;
+                default: return false;
+            }
+        }
+        private int? AskRepeatCount()
+        {
+            var dialog = new Window { Owner = owner, Title = "Repeat selected audio", Width = 330, Height = 180, ResizeMode = ResizeMode.NoResize, WindowStartupLocation = WindowStartupLocation.CenterOwner, ShowInTaskbar = false, Icon = BrandArtwork.Raster() }; ThemePalette.Install(dialog);
+            var body = new StackPanel { Margin = new Thickness(18) }; dialog.Content = body; body.Children.Add(WorkspaceUi.Text("Additional copies (1–64)", 14));
+            var input = new TextBox { Text = "3", Margin = new Thickness(0, 8, 0, 10), Padding = new Thickness(5) }; body.Children.Add(input);
+            var buttons = new StackPanel { Orientation = Orientation.Horizontal }; body.Children.Add(buttons); int result = 0;
+            var apply = WorkspaceUi.Button("Repeat", delegate { int value; if (int.TryParse(input.Text, out value) && value >= 1 && value <= 64) { result = value; dialog.DialogResult = true; } else input.SelectAll(); }); apply.IsDefault = true; buttons.Children.Add(apply);
+            var close = WorkspaceUi.Button("Cancel", delegate { dialog.DialogResult = false; }); close.IsCancel = true; buttons.Children.Add(close); dialog.Loaded += delegate { input.Focus(); input.SelectAll(); };
+            return dialog.ShowDialog() == true ? (int?)result : null;
+        }
+        internal void ToolDownForTest(string id, string tool, long frame)
+        {
+            var region = session.Regions.Single(r => r.Id == id); previousIds = selectedIds.ToArray(); previousClipSelection = clipSelection; previousTrack = track;
+            previousFrom = from; previousTo = to; previousPlayhead = playhead;
+            BeginClipDrag((ClipDrag)Enum.Parse(typeof(ClipDrag), tool), region, new Point(X(frame), RulerHeight + region.Track * RowHeight + 8));
+        }
+        internal void ToolMoveForTest(long frame, int row) { PreviewClipDrag(new Point(X(frame), RulerHeight + row * RowHeight + 8)); }
+        internal void ToolEndForTest(bool cancel) { if (cancel) CancelClipDrag(); else FinishClipDrag(); }
+        internal void ContextForTest(long frame, int row) { SelectContextTarget(new Point(X(frame), RulerHeight + row * RowHeight + 35)); }
+    }
+}

package/source/EditorTools.cs

@@ -0,0 +1,78 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Collections.Generic;
+
+namespace DrumBuddy
+{
+    internal enum ClipDrag { None, Move, TrimLeft, TrimRight, Slip, FadeIn, FadeOut }
+    public static class EditorTools
+    {
+        public static double Envelope(TimelineRegion region, long offset)
+        {
+            double value = 1;
+            if (region.FadeIn > 0) value = Math.Min(value, Math.Max(0, offset + region.FadeInOffset) / (double)region.FadeIn);
+            if (region.FadeOut > 0) value = Math.Min(value, Math.Max(0, region.Length - 1 - offset + region.FadeOutOffset) / (double)region.FadeOut);
+            return Math.Max(0, Math.Min(1, value));
+        }
+        public static void ClampFades(TimelineRegion region)
+        { region.FadeIn = Math.Max(0, Math.Min(region.Length, region.FadeIn)); region.FadeOut = Math.Max(0, Math.Min(region.Length, region.FadeOut)); region.FadeInOffset = region.FadeOutOffset = 0; }
+        public static bool Move(EditorSession session, ISet<string> ids, long delta, int tracks)
+        {
+            var selected = session.Regions.Where(r => ids.Contains(r.Id)).ToArray(); if (selected.Length == 0) return false;
+            delta = Math.Max(-selected.Min(r => r.Start), Math.Min(EditorSession.MaxFrame - selected.Max(r => r.End), delta));
+            tracks = Math.Max(-selected.Min(r => r.Track), Math.Min(15 - selected.Max(r => r.Track), tracks));
+            if (delta == 0 && tracks == 0) return false;
+            foreach (var region in selected) { region.Start += delta; region.Track += tracks; } return true;
+        }
+        public static bool Trim(TimelineRegion region, bool left, long boundary, long sourceFrames)
+        {
+            if (sourceFrames < region.SourceStart + region.Length) throw new IOException("Re-import the source before extending this clip.");
+            long before = region.Length;
+            if (left) {
+                long start = Math.Max(Math.Max(0, region.Start - region.SourceStart), Math.Min(region.End - 1, boundary));
+                long delta = start - region.Start; region.Start = start; region.SourceStart += delta; region.Length -= delta;
+            }
+            else {
+                long end = Math.Max(region.Start + 1, Math.Min(Math.Min(EditorSession.MaxFrame, region.Start + sourceFrames - region.SourceStart), boundary)); region.Length = end - region.Start;
+            }
+            ClampFades(region); return before != region.Length;
+        }
+        public static bool Slip(TimelineRegion region, long delta, long sourceFrames)
+        {
+            long before = region.SourceStart; region.SourceStart = Math.Max(0, Math.Min(sourceFrames - region.Length, region.SourceStart + delta));
+            return before != region.SourceStart;
+        }
+        public static bool Fade(TimelineRegion region, bool fadeIn, long length)
+        {
+            length = Math.Max(0, Math.Min(region.Length, length)); long before = fadeIn ? region.FadeIn : region.FadeOut;
+            if (fadeIn) { region.FadeIn = length; region.FadeInOffset = 0; } else { region.FadeOut = length; region.FadeOutOffset = 0; } return before != length;
+        }
+        public static List<string> Repeat(EditorSession session, ISet<string> ids, int copies)
+        {
+            var source = session.Regions.Where(r => ids.Contains(r.Id)).ToArray();
+            if (source.Length == 0) throw new IOException("Select clips to duplicate or repeat.");
+            if (copies < 1 || copies > 64 || session.Regions.Count + copies * source.Length > 20000) throw new IOException("Choose 1 to 64 additional copies within the session's region limit.");
+            long length = source.Max(r => r.End) - source.Min(r => r.Start);
+            if (length > (EditorSession.MaxFrame - source.Max(r => r.End)) / copies) throw new IOException("The repeats would exceed the 24-hour timeline.");
+            var added = new List<string>();
+            for (int n = 1; n <= copies; n++) foreach (var item in source) {
+                var copy = item.Copy(); copy.Id = Guid.NewGuid().ToString("N"); copy.Start += length * n; session.Regions.Add(copy); added.Add(copy.Id);
+            }
+            return added;
+        }
+        public static bool ToggleMute(EditorSession session, ISet<string> ids)
+        {
+            var selected = session.Regions.Where(r => ids.Contains(r.Id)).ToArray(); if (selected.Length == 0) return false;
+            bool mute = selected.Any(r => !r.Muted); foreach (var region in selected) region.Muted = mute; return true;
+        }
+        public static bool Crossfade(EditorSession session, ISet<string> ids)
+        {
+            var selected = session.Regions.Where(r => ids.Contains(r.Id)).OrderBy(r => r.Start).ToArray();
+            if (selected.Length != 2 || selected[0].Track != selected[1].Track || selected[0].Start >= selected[1].Start || selected[0].End <= selected[1].Start || selected[0].End > selected[1].End)
+                throw new IOException("Select two overlapping clips on one track, with the second extending beyond the first, to crossfade.");
+            long overlap = selected[0].End - selected[1].Start;
+            selected[0].FadeOut = overlap; selected[0].FadeOutOffset = 0; selected[1].FadeIn = overlap; selected[1].FadeInOffset = 1; return true;
+        }
+    }
+}

package/source/EditorToolsTests.cs

@@ -0,0 +1,93 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Collections.Generic;
+using System.Windows;
+using System.Windows.Media;
+using System.Windows.Media.Imaging;
+
+namespace DrumBuddy
+{
+    public static class EditorToolsTests
+    {
+        private static readonly List<string> log = new List<string>();
+        private static void Check(bool value, string text) { if (!value) throw new Exception(text); log.Add("PASS  " + text); }
+        private static long Frame(double seconds) { return (long)Math.Round(seconds * Audio.Rate); }
+        private static float[] Render(EditorSession session, IDictionary<string, Clip> assets)
+        {
+            using (var mix = new TimelineMix(session, assets)) { var output = new float[checked((int)session.End * 2)]; int n = 0, read; while ((read = mix.Read(output, n, output.Length - n)) > 0) n += read; return output; }
+        }
+        private static void Picture(FrameworkElement view, string file)
+        {
+            view.Measure(new Size(1100, 650)); view.Arrange(new Rect(0, 0, 1100, 650)); view.UpdateLayout();
+            var bitmap = new RenderTargetBitmap(1100, 650, 96, 96, PixelFormats.Pbgra32); bitmap.Render(view);
+            var encoder = new PngBitmapEncoder(); encoder.Frames.Add(BitmapFrame.Create(bitmap)); using (var output = File.Create(file)) encoder.Save(output);
+        }
+        public static int Run(string[] args)
+        {
+            string root = Path.GetFullPath(args[0]); Directory.CreateDirectory(root); log.Clear(); var preferences = InterfacePreferences.Current;
+            try {
+                InterfacePreferences.Current = InterfacePreferences.Defaults(); InterfacePreferences.Current.SnapToGrid = InterfacePreferences.Current.SnapToEdges = false;
+                string file = Path.Combine(root, "Original float.wav"); var samples = Enumerable.Repeat(1.5f, Audio.Rate * 4).ToArray();
+                using (var writer = new FloatWaveWriter(file, 1, Audio.Rate)) writer.Write(samples, samples.Length, 1);
+                byte[] original = File.ReadAllBytes(file);
+                var clip = new Clip { Source = file, Cache = file, Name = "Original float.wav", Channels = 1, Duration = 4, Peak = 1.5, Waveform = Enumerable.Repeat(1.5f, 900).ToArray(), Ready = true };
+                var assets = new Dictionary<string, Clip> { { file, clip } };
+                var fade = new EditorSession(); fade.Regions.Add(new TimelineRegion { Id = "fade", Source = file, Length = 100, FadeIn = 20, FadeOut = 20 });
+                var rendered = Render(fade, assets);
+                Check(rendered[0] == 0 && rendered[40] == 1.5f && rendered[198] == 0, "Apply clip fade-in/out to actual float samples while retaining headroom");
+                var split = fade.Copy(); TimelineEdits.Split(split, 0, false, 10); split.Validate(); Check(rendered.SequenceEqual(Render(split, assets)), "Splitting inside a fade preserves the exact audible envelope");
+                var copied = TimelineEdits.Copy(fade, 0, false, 5, 85); var pasted = new EditorSession(); TimelineEdits.Paste(pasted, copied, 0, 0);
+                Check(Render(pasted, assets).SequenceEqual(rendered.Skip(10).Take(160)), "Copy/paste part of a faded clip preserves its original sample levels");
+                var muted = fade.Copy(); EditorTools.ToggleMute(muted, new HashSet<string> { "fade" }); Check(Render(muted, assets).All(v => v == 0), "Clip mute silences playback and mix output without changing source audio");
+                var cross = new EditorSession(); cross.Regions.Add(new TimelineRegion { Id = "a", Source = file, Length = 100 }); cross.Regions.Add(new TimelineRegion { Id = "b", Source = file, Start = 80, Length = 100 });
+                EditorTools.Crossfade(cross, new HashSet<string> { "a", "b" });
+                Check(Render(cross, assets).Skip(160).Take(40).All(v => Math.Abs(v - 1.5f) < 1e-6), "Crossfade overlapping clips with complementary levels across the overlap");
+                string exported = Path.Combine(root, "Faded mix.wav"); TimelineRender.Export(fade, assets, exported, 32, false, 0, 0, CancellationToken.None, null);
+                using (var wave = new NAudio.Wave.WaveFileReader(exported)) { var bytes = new byte[checked((int)wave.Length)]; wave.Read(bytes, 0, bytes.Length); var actual = new float[bytes.Length / 4]; Buffer.BlockCopy(bytes, 0, actual, 0, bytes.Length); Check(actual.SequenceEqual(rendered), "Save the same clip fades heard in playback into a float mix export"); }
+                string project = Path.Combine(root, "Fades.dbedit"); split.Regions[0].Muted = true; split.Save(project); var loaded = EditorSession.Load(project);
+                Check(loaded.Regions[0].Muted && loaded.Regions[1].FadeInOffset == 10, "Persist clip mute, fades and split-envelope offsets in project files");
+                var state = new EditorSession { Name = "Clip tools" };
+                state.Regions.Add(new TimelineRegion { Id = "first", Name = "Move / trim / slip", Source = file, Start = Frame(1), SourceStart = Frame(1), Length = Frame(2) });
+                state.Regions.Add(new TimelineRegion { Id = "second", Name = "Group item", Source = file, Track = 1, Start = Frame(2), Length = Frame(1) });
+                var owner = new Window(); ThemePalette.Apply(true); ThemePalette.Install(owner);
+                using (var editor = new EditorView(owner, Path.Combine(root, "cache"), delegate { }, delegate { })) {
+                    owner.Content = editor; editor.SetForTest(state, assets); editor.ZoomForTest(250); Picture(editor, Path.Combine(root, "clip-tools-start.png"));
+                    editor.PointerDownForTest(Frame(1.25), 0, false); editor.PointerUpForTest(Frame(1.25)); editor.PointerDownForTest(Frame(2.25), 1, true);
+                    editor.ToolDownForTest("first", "Move", Frame(1.5)); editor.ToolMoveForTest(Frame(3.5), 2); editor.ToolEndForTest(false);
+                    var moved = editor.SessionForTest;
+                    Check(moved.Regions.Single(r => r.Id == "first").Start == Frame(3) && moved.Regions.Single(r => r.Id == "second").Start == Frame(4) && moved.Regions.Single(r => r.Id == "first").Track == 2 && moved.Regions.Single(r => r.Id == "second").Track == 3, "Move a selected clip group in time and across tracks without losing relative placement");
+                    editor.ExecuteAction("undo").GetAwaiter().GetResult(); Check(editor.SessionForTest.Regions.Single(r => r.Id == "first").Start == Frame(1), "Undo a complete clip drag as one edit");
+                    editor.SetForTest(state, assets); editor.ToolDownForTest("first", "Move", Frame(1.5)); editor.ToolMoveForTest(Frame(2.5), 2); editor.ToolEndForTest(true);
+                    Check(!editor.Dirty && editor.SessionForTest.Regions.Single(r => r.Id == "first").Track == 0 && editor.SessionForTest.Regions.Single(r => r.Id == "first").Start == Frame(1), "Cancel a clip drag without changing the session or dirty state");
+                    editor.ToolDownForTest("first", "TrimLeft", Frame(1)); editor.ToolMoveForTest(Frame(1.5), 0); editor.ToolEndForTest(false);
+                    var trimmed = editor.SessionForTest.Regions.Single(r => r.Id == "first"); Check(trimmed.Start == Frame(1.5) && trimmed.SourceStart == Frame(1.5) && trimmed.Length == Frame(1.5), "Trim the left edge while advancing the exact source offset");
+                    editor.SetForTest(state, assets); editor.ToolDownForTest("first", "TrimRight", Frame(3)); editor.ToolMoveForTest(Frame(8), 0); editor.ToolEndForTest(false);
+                    Check(editor.SessionForTest.Regions.Single(r => r.Id == "first").End == Frame(4), "Clamp edge extension to available source audio");
+                    editor.SetForTest(state, assets); editor.ToolDownForTest("first", "Slip", Frame(1.5)); editor.ToolMoveForTest(Frame(1.25), 0); editor.ToolEndForTest(false);
+                    var slipped = editor.SessionForTest.Regions.Single(r => r.Id == "first"); Check(slipped.SourceStart == Frame(1.25) && slipped.Start == Frame(1) && slipped.Length == Frame(2), "Slip source contents while retaining clip start and end");
+                    editor.ToolDownForTest("first", "FadeIn", Frame(1)); editor.ToolMoveForTest(Frame(1.5), 0); editor.ToolEndForTest(false); editor.ToolDownForTest("first", "FadeOut", Frame(3)); editor.ToolMoveForTest(Frame(2.5), 0); editor.ToolEndForTest(false);
+                    Check(editor.SessionForTest.Regions.Single(r => r.Id == "first").FadeIn == Frame(.5) && editor.SessionForTest.Regions.Single(r => r.Id == "first").FadeOut == Frame(.5), "Commit both fade handles as audible, undoable clip properties");
+                    editor.ExecuteAction("zoomSelection").GetAwaiter().GetResult(); Picture(editor, Path.Combine(root, "clip-tools-fades.png"));
+                    editor.SetForTest(state, assets); editor.PointerDownForTest(Frame(1.25), 0, false); editor.PointerUpForTest(Frame(1.25)); editor.ExecuteAction("duplicate").GetAwaiter().GetResult();
+                    Check(editor.SessionForTest.Regions.Any(r => r.Id != "first" && r.Track == 0 && r.Start == Frame(3) && r.SourceStart == Frame(1)), "Duplicate selected audio directly after its original duration");
+                    editor.SetForTest(state, assets); editor.ShowSelectionForTest(Frame(1.25), Frame(1.75)); editor.ContextForTest(Frame(1.5), 0);
+                    Check(editor.SelectedClipsForTest == 0, "Keep a dragged time range active when opening its context menu");
+                    editor.ExecuteAction("clearFades").GetAwaiter().GetResult();
+                    Check(!editor.Dirty && editor.SessionForTest.Regions.Count == 2, "Roll back temporary splits when a range operation makes no audio change");
+                }
+                owner.Content = null; owner.Close();
+                var repeats = state.Copy(); EditorTools.Repeat(repeats, new HashSet<string> { "first", "second" }, 3);
+                Check(repeats.Regions.Count == 8 && repeats.Regions.Any(r => r.Track == 1 && r.Start == Frame(8)), "Repeat selected multitrack clips with their timing and source windows intact");
+                bool rejected = false; int before = repeats.Regions.Count; try { EditorTools.Repeat(repeats, new HashSet<string> { "first" }, 65); } catch (IOException) { rejected = true; }
+                Check(rejected && repeats.Regions.Count == before, "Reject excessive repeats before partially editing the project");
+                Check(original.SequenceEqual(File.ReadAllBytes(file)), "Keep original audio byte-for-byte unchanged across all new clip tools");
+                File.WriteAllLines(Path.Combine(root, "tools-test-results.txt"), log, Encoding.UTF8); return 0;
+            }
+            catch (Exception ex) { log.Add("FAIL  " + ex); File.WriteAllLines(Path.Combine(root, "tools-test-results.txt"), log, Encoding.UTF8); return 1; }
+            finally { InterfacePreferences.Current = preferences; ThemePalette.Apply(preferences.Theme == "Dark"); }
+        }
+    }
+}