XFE Git
XFE Studio Git
Git 首页 全局搜索
XFE 主站 文档 NuGet

XFEToolBox

【WPF】XFE工具箱

公开
关注 0 Fork 0 Star 0
UTF-8
using System.Diagnostics;
using System.Runtime.InteropServices;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Controls.Primitives;
using System.Windows.Interop;
using System.Windows.Media;
using System.Windows.Threading;
using XFEToolBox.Tools.VideoStudio;
using XFEToolBox.WpfCore.Controls;
using XFEToolBox.WpfCore.Windowing;

namespace VideoStudio.Validation;
internal static partial class Program
{
    private static async Task InterfaceTests(string[] paths)
    {
        var trace = new BindingTrace(); PresentationTraceSources.DataBindingSource.Listeners.Add(trace); PresentationTraceSources.DataBindingSource.Switch.Level = SourceLevels.Error;
        var page = new MainPage(); var vm = (MainPageViewModel)page.DataContext; vm.FfmpegPath = ffmpeg; vm.FfprobePath = ffprobe;
        var window = new Window { Content = page, Width = 1380, Height = 840, Left = -30000, Top = -30000, ShowInTaskbar = false, ShowActivated = false, WindowStyle = WindowStyle.None };
        window.Show(); await Dispatcher.Yield(DispatcherPriority.ApplicationIdle);
        var initialTimeline = (TimelineSurface)page.FindName("Timeline");
        var initialScroll = (ScrollViewer)page.FindName("TimelineScroll");
        Check(vm.Tracks.All(t => initialTimeline.YAt(t) + TimelineSurface.RowHeight <= initialScroll.ViewportHeight), "all four default lanes are visible without vertical scrolling at normal window size");
        var horizontalBar = Descendants<ScrollBar>(initialScroll).Single(b => b.Orientation == Orientation.Horizontal);
        Check(horizontalBar.IsVisible && horizontalBar.ActualHeight >= 14, "bottom horizontal scrollbar remains visible with a usable drag height even in fit mode");
        vm.ZoomInCommand.Execute(null); vm.ZoomInCommand.Execute(null);
        await Dispatcher.Yield(DispatcherPriority.ApplicationIdle);
        var scrollThumb = Descendants<Thumb>(horizontalBar).Single(); double playheadBeforeScroll = vm.SequencePosition;
        scrollThumb.RaiseEvent(new DragStartedEventArgs(0, 0) { RoutedEvent = Thumb.DragStartedEvent });
        scrollThumb.RaiseEvent(new DragDeltaEventArgs(85, 0) { RoutedEvent = Thumb.DragDeltaEvent });
        scrollThumb.RaiseEvent(new DragCompletedEventArgs(85, 0, false) { RoutedEvent = Thumb.DragCompletedEvent });
        await Dispatcher.Yield(DispatcherPriority.ApplicationIdle);
        Check(initialScroll.HorizontalOffset > 0 && Near(initialTimeline.HorizontalOffset, initialScroll.HorizontalOffset) && vm.SequencePosition == playheadBeforeScroll, "dragging the real scrollbar thumb pans timeline without changing playhead or edits");
        vm.FitTimelineCommand.Execute(null); await Dispatcher.Yield(DispatcherPriority.ApplicationIdle);
        Check(horizontalBar.IsVisible && initialScroll.HorizontalOffset < 1 && initialScroll.ScrollableWidth < 3, "fit resets horizontal pan but does not remove the bottom scrollbar");
        await vm.LoadSourceAsync(paths[0]); await vm.ImportAssetsAsync(paths.Skip(1));
        vm.AddVideoTrackCommand.Execute(null); vm.InsertAsset(vm.Assets[1], 1);
        vm.AddAudioTrackCommand.Execute(null); vm.InsertAsset(vm.Assets[2], 0);
        vm.SelectedTrack = vm.Tracks.First(t => t.Kind == MediaKind.Video && t.Index == 2); vm.InsertAsset(vm.Assets[3], 4);
        var menu = (Menu)page.FindName("EditorMenu");
        Check(menu.Items.OfType<MenuItem>().Select(m => m.Header?.ToString()).SequenceEqual(new[] { "文件", "编辑", "轨道", "播放", "视图", "设置" }), "top menu bar exposes File/Edit/Track/Playback/View/Settings");
        foreach (MenuItem top in menu.Items)
        {
            top.IsSubmenuOpen = true; await Dispatcher.Yield(DispatcherPriority.ApplicationIdle);
            Check(top.Items.OfType<MenuItem>().All(m => m.Command is not null), "all " + top.Header + " menu items bind to real commands");
            top.IsSubmenuOpen = false;
        }
        var settingsMenu = (MenuItem)page.FindName("SettingsMenu");
        var automaticMode = settingsMenu.Items.OfType<MenuItem>().Single(m => m.Command == vm.UseAutomaticExportCommand);
        var cpuMode = settingsMenu.Items.OfType<MenuItem>().Single(m => m.Command == vm.UseCpuExportCommand);
        cpuMode.Command.Execute(null); await Dispatcher.Yield(DispatcherPriority.ApplicationIdle);
        Check(vm.IsCpuExport && cpuMode.IsChecked && !automaticMode.IsChecked, "Settings menu selects CPU encoding with mutually exclusive checks");
        cpuMode.SetCurrentValue(MenuItem.IsCheckedProperty, false); cpuMode.Command.Execute(null); await Dispatcher.Yield(DispatcherPriority.ApplicationIdle);
        Check(cpuMode.IsChecked && vm.IsCpuExport, "clicking active encoding mode retains its radio-style check");
        automaticMode.Command.Execute(null); await Dispatcher.Yield(DispatcherPriority.ApplicationIdle);
        Check(vm.IsAutomaticExport && automaticMode.IsChecked && !cpuMode.IsChecked, "Settings menu switches back to automatic GPU encoding");
        var importButton = (Button)page.FindName("ImportMediaButton"); var assetPane = (FrameworkElement)page.FindName("AssetPane");
        Check(Descendants<Button>(assetPane).Contains(importButton) && importButton.Command == vm.BrowseVideoCommand, "import button is inside Project Media, connected to the import command");
        var clipToolbar = (WrapPanel)page.FindName("ClipEditingToolbar"); var monitorControls = (StackPanel)page.FindName("MonitorControls");
        Check(Descendants<WrapPanel>(monitorControls).Contains(clipToolbar) && clipToolbar.Children.OfType<Button>().Select(b => b.Command).SequenceEqual(new[] { vm.UndoCommand, vm.RedoCommand, vm.SelectionToolCommand, vm.RazorToolCommand, vm.SplitClipCommand, vm.RemoveClipCommand, vm.ToggleClipLinkCommand }), "monitor toolbar contains seven real edit commands including link/unlink");
        Check(!Descendants<Button>(page).Any(b => b.Command == vm.ToggleExportModeCommand || b.Command == vm.ExportCommand), "GPU and export no longer occupy the removed global toolbar");
        vm.SelectedClip = vm.Clips.First(c => c.Kind == MediaKind.Audio); await Dispatcher.Yield(DispatcherPriority.ApplicationIdle);
        Check(((StackPanel)page.FindName("AudioProperties")).IsVisible && !((StackPanel)page.FindName("VisualProperties")).IsVisible, "audio selection displays audio inspector only");
        var trackPicker = (ComboBox)page.FindName("PropertyTrack");
        Check(trackPicker.Items.Cast<TimelineTrack>().All(t => t.Kind == MediaKind.Audio) && (string?)trackPicker.SelectedValue == vm.SelectedClip.TrackId, "property track picker lists only audio tracks and preserves selection");
        trackPicker.IsDropDownOpen = true; await Dispatcher.Yield(DispatcherPriority.ApplicationIdle); trackPicker.IsDropDownOpen = false;
        vm.VolumeText = "40"; vm.ApplyClipPropertiesCommand.Execute(null); Check(vm.SelectedClip.AudioVolume == 40, "WPF inspector can apply clip properties without read-only binding failures");
        vm.SelectedClip = vm.Clips.First(c => c.Kind == MediaKind.Video); await Dispatcher.Yield(DispatcherPriority.ApplicationIdle);
        Check(!((StackPanel)page.FindName("AudioProperties")).IsVisible && ((StackPanel)page.FindName("VisualProperties")).IsVisible, "video selection switches to visual inspector");
        Check(trackPicker.Items.Cast<TimelineTrack>().All(t => t.Kind == MediaKind.Video) && (string?)trackPicker.SelectedValue == vm.SelectedClip.TrackId, "visual inspector tracks update without losing selected track");
        Check(Descendants<TextBlock>(trackPicker).Any(t => t.Text == "V1") && !Descendants<TextBlock>(trackPicker).Any(t => t.Text.Contains("XFEToolBox.Tools")), "track picker displays V1 name, not CLR type name");
        var timeline = (TimelineSurface)page.FindName("Timeline"); var video = vm.SelectedClip!;
        ((Button)page.FindName("ToggleClipLinkButton")).Command.Execute(null);
        Check(video.LinkGroupId == "", "real toolbar unlink button allows subsequent independent video trim");
        double y = timeline.YAt(vm.TrackFor(video)!) + 30, scale = timeline.XAt(1);
        var tail = new Point(timeline.XAt(video.TimelineEnd) - 4, y);
        Check(timeline.EdgeAt(tail) is { Edge: ClipEdge.End } hit && hit.Clip == video, "right handle hit testing identifies selected video track");
        timeline.BeginDrag(tail); var trimmed = new Point(tail.X - .4 * scale, tail.Y); for (int i = 0; i < 10; i++) timeline.MoveDrag(trimmed); timeline.FinishDrag(trimmed);
        Check(Near(video.EndSeconds, 3.6) && vm.Clips.First(c => c.AssetId == video.AssetId && c.Kind == MediaKind.Audio).EndSeconds == 4, "actual pointer gesture trims video independently of original audio"); vm.UndoCommand.Execute(null);
        await Dispatcher.Yield(DispatcherPriority.ApplicationIdle); video = vm.Clips.First(c => c.Id == video.Id); scale = timeline.XAt(1); y = timeline.YAt(vm.TrackFor(video)!) + 30;
        var head = new Point(timeline.XAt(video.TimelineStart) + 3, y); timeline.BeginDrag(head); timeline.MoveDrag(new Point(head.X + .5 * scale, y)); timeline.CancelDrag();
        Check(!vm.IsTrimming && video.StartSeconds == 0 && video.TimelineStart == 0, "pointer capture cancellation restores head trim");
        var body = new Point(timeline.XAt(1), y); var targetTrack = vm.Tracks.First(t => t.Kind == MediaKind.Video && t.Index == 2);
        timeline.BeginDrag(body); var end = new Point(body.X + 2 * scale, timeline.YAt(targetTrack) + 30); timeline.MoveDrag(end); timeline.FinishDrag(end);
        Check(video.TrackId == targetTrack.Id && Near(video.TimelineStart, 2), "body drag moves clip across compatible tracks"); vm.UndoCommand.Execute(null);
        vm.SeekSequence(1.5); await Task.Delay(1500); await Dispatcher.Yield(DispatcherPriority.ApplicationIdle);
        Check(page.Playback.ReadySourceCount > 0 && ((TextBlock)page.FindName("PreviewHint")).Visibility == Visibility.Collapsed, "WPF opens native source decoders without a rendered preview file");
        var player = page.Playback; player.IsMuted = true;
        vm.SeekSequence(0); vm.TogglePlaybackCommand.Execute(null);
        var playback = Stopwatch.StartNew(); while (playback.Elapsed < TimeSpan.FromSeconds(25) && vm.SequencePosition < .3) await Task.Delay(100);
        Check(vm.IsPlaying && vm.SequencePosition >= .3 && player.OpenSources.All(p => vm.Assets.Any(a => a.FilePath == p.LocalPath)), "actual WPF source playback advances playhead using only original media paths");
        vm.TogglePlaybackCommand.Execute(null); Check(!vm.IsPlaying, "transport command pauses actual playback"); vm.SeekSequence(1.5); await Task.Delay(600);
        Save(page, "multi-track-editor.png");
        vm.SelectedClip = vm.Clips.First(c => c.Kind == MediaKind.Audio); await Dispatcher.Yield(DispatcherPriority.ApplicationIdle); Save(page, "audio-inspector.png");
        window.Width = 1040; window.Height = 760; await Dispatcher.Yield(DispatcherPriority.ApplicationIdle); Save(page, "minimum-editor.png");
        Check(clipToolbar.IsVisible && clipToolbar.Children.OfType<Button>().All(b => b.TranslatePoint(new Point(0, b.ActualHeight), monitorControls).Y <= monitorControls.ActualHeight + 1), "editing toolbar wraps within monitor controls at minimum window width");
        Check(((FrameworkElement)page.FindName("EditPage")).ActualHeight > 500 && timeline.ActualHeight >= 4 * TimelineSurface.RowHeight, "minimum-width layout retains editor and scrollable independent tracks");
        Check(((ScrollViewer)page.FindName("TimelineScroll")).ScrollableWidth < 3, "fit timeline follows resized viewport instead of retaining stale width");
        var addVideo = (Button)page.FindName("AddTimelineVideoTrack"); var addAudio = (Button)page.FindName("AddTimelineAudioTrack");
        Check(addVideo.IsVisible && addAudio.IsVisible && addVideo.Command == vm.AddVideoTrackCommand && addAudio.Command == vm.AddAudioTrackCommand, "timeline-local add-video and add-audio buttons remain visible and connected at minimum width");
        for (int i = 0; i < 4; i++) addAudio.Command.Execute(null);
        await Dispatcher.Yield(DispatcherPriority.ApplicationIdle);
        double selectedTop = timeline.YAt(vm.SelectedTrack!), selectedBottom = selectedTop + TimelineSurface.RowHeight;
        Check(selectedTop >= initialScroll.VerticalOffset - 1 && selectedBottom <= initialScroll.VerticalOffset + initialScroll.ViewportHeight + 1, "new off-screen audio track automatically scrolls fully into view");
        var headers = (ScrollViewer)page.FindName("TrackHeaderScroll");
        Check(Near(headers.VerticalOffset, initialScroll.VerticalOffset, 1), "track labels and clip rows remain vertically aligned at lower lanes");
        addVideo.Command.Execute(null); await Dispatcher.Yield(DispatcherPriority.ApplicationIdle);
        Check(initialScroll.VerticalOffset < 1 && timeline.TrackAt(TimelineSurface.RulerHeight + 20) == vm.SelectedTrack, "new video track is placed on top and scrolled into view");
        Save(page, "expanded-multi-track-workspace.png");
        vm.ShowSubtitlesCommand.Execute(null); vm.Subtitles.Add(new SubtitleCue { Index = 1, StartSeconds = 0, EndSeconds = 1, Text = "字幕回归检查" }); await Dispatcher.Yield(DispatcherPriority.ApplicationIdle); Save(page, "subtitles.png");
        vm.ShowEnvironmentCommand.Execute(null); await Dispatcher.Yield(DispatcherPriority.ApplicationIdle); Save(page, "sequence-settings.png");
        Check(trace.Errors.Count == 0, "zero WPF binding errors: " + string.Join(" | ", trace.Errors));
        vm.IsBusy = true; window.Close(); Check(window.IsVisible, "closing during active task requests cancellation and waits for cleanup"); vm.IsBusy = false; vm.HasUnsavedChanges = false; window.Close();
        PresentationTraceSources.DataBindingSource.Listeners.Remove(trace);
    }
    private static IEnumerable<T> Descendants<T>(DependencyObject root) where T : DependencyObject
    {
        for (int i = 0; i < VisualTreeHelper.GetChildrenCount(root); i++) { var child = VisualTreeHelper.GetChild(root, i); if (child is T value) yield return value; foreach (var nested in Descendants<T>(child)) yield return nested; }
    }
    [StructLayout(LayoutKind.Sequential)] private struct NativeRect { public int Left, Top, Right, Bottom; }
    [StructLayout(LayoutKind.Sequential)] private struct MonitorData { public int Size; public NativeRect Bounds, Work; public uint Flags; }
    [DllImport("user32.dll")] private static extern bool GetWindowRect(nint hWnd, out NativeRect rect);
    [DllImport("user32.dll")] private static extern nint MonitorFromWindow(nint hWnd, uint flags);
    [DllImport("user32.dll")] private static extern bool GetMonitorInfo(nint monitor, ref MonitorData info);
    private static async Task ChromeTests()
    {
        var content = new Border { CornerRadius = new CornerRadius(16), Background = Brushes.White };
        var surface = new RoundedClipBorder { Margin = new Thickness(5), CornerRadius = new CornerRadius(19), Background = Brushes.Purple, Child = content };
        var grip = new WindowResizeGrip(); var grid = new Grid(); grid.Children.Add(surface); grid.Children.Add(grip);
        var window = new Window { Content = grid, Width = 800, Height = 600, Left = 100, Top = 100, ShowActivated = false, ShowInTaskbar = false, Opacity = 0, AllowsTransparency = true, WindowStyle = WindowStyle.None, ResizeMode = ResizeMode.CanResize };
        ToolWindowFrameBehavior.Attach(window, surface, content); WindowWorkAreaHelper.Attach(window); window.Show(); await Dispatcher.Yield(DispatcherPriority.ApplicationIdle);
        Check(surface.Margin == new Thickness(5) && surface.CornerRadius.TopLeft == 19 && grip.IsVisible, "normal tool chrome retains rounded border and resize grip");
        window.WindowState = WindowState.Maximized; await Dispatcher.Yield(DispatcherPriority.ApplicationIdle);
        Check(surface.Margin == new Thickness(0) && surface.CornerRadius == new CornerRadius(0) && content.CornerRadius == new CornerRadius(0), "maximized chrome removes all outer margins and both corner radii");
        Check(grip.Visibility == Visibility.Collapsed && !grip.IsHitTestVisible, "maximized resize grip is hidden and cannot intercept pointer input");
        nint hwnd = new WindowInteropHelper(window).Handle; GetWindowRect(hwnd, out var bounds); var monitor = new MonitorData { Size = Marshal.SizeOf<MonitorData>() }; GetMonitorInfo(MonitorFromWindow(hwnd, 2), ref monitor);
        Check(bounds.Left == monitor.Work.Left && bounds.Top == monitor.Work.Top && bounds.Right == monitor.Work.Right && bounds.Bottom == monitor.Work.Bottom, "actual maximized Win32 bounds exactly fill monitor work area without covering taskbar");
        window.WindowState = WindowState.Normal; await Dispatcher.Yield(DispatcherPriority.ApplicationIdle);
        Check(surface.Margin == new Thickness(5) && surface.CornerRadius.TopLeft == 19 && content.CornerRadius.TopLeft == 16 && grip.IsVisible, "restore reinstates original chrome and grip");
        window.ResizeMode = ResizeMode.NoResize; await Dispatcher.Yield(DispatcherPriority.ApplicationIdle); Check(grip.Visibility == Visibility.Collapsed, "non-resizable tool also hides resize grip"); window.Close();
    }
}