Skip to content

armgit / Filee

Public Imported from GitHub
0

Free, open-source file converter. Convert 263 formats offline by drag & drop — images, PDF, Word, Excel, PowerPoint, HWP/HWPX, video, audio, e-books and archives. No upload, no Office needed.

129 KB
Raw Blame
// Renders real windows headlessly (Skia) to catch XAML / binding errors and to produce screenshots
// in bin/.../screenshots for visual review.

using Avalonia.Controls;
using Avalonia.Controls.Primitives;
using Avalonia.Headless;
using Avalonia.Headless.XUnit;
using Avalonia.Input;
using Avalonia.Threading;
using Avalonia.VisualTree;
using Filee.App.Controls;
using Filee.App.Services;
using Filee.App.ViewModels;
using Filee.App.ViewModels.Pages;
using Filee.App.Views;
using Filee.App.Views.Pages;
using Filee.Core.Localization;
using Filee.Core.Profiles;
using Filee.Core.Settings;
using Microsoft.Extensions.Logging.Abstractions;

namespace Filee.App.Tests;

public class RenderTests
{
    public static TheoryData<string, string> Pages => new()
    {
        { "home", "id" }, { "general", "id" }, { "triggers", "id" }, { "toolbar", "id" },
        { "presets", "id" }, { "theme", "id" }, { "engines", "id" }, { "about", "id" }, { "watch", "id" },
        { "home", "it" }, { "general", "it" }, { "triggers", "it" }, { "toolbar", "it" },
        { "presets", "it" }, { "theme", "it" }, { "engines", "it" }, { "about", "it" }, { "watch", "it" },
        { "home", "de" }, { "general", "de" }, { "triggers", "de" }, { "toolbar", "de" },
        { "presets", "de" }, { "theme", "de" }, { "engines", "de" }, { "about", "de" }, { "watch", "de" },
        { "home", "tr" }, { "general", "tr" }, { "triggers", "tr" }, { "toolbar", "tr" },
        { "presets", "tr" }, { "theme", "tr" }, { "engines", "tr" }, { "about", "tr" }, { "watch", "tr" },
        { "home", "ar" }, { "general", "ar" }, { "triggers", "ar" }, { "toolbar", "ar" },
        { "presets", "ar" }, { "theme", "ar" }, { "engines", "ar" }, { "about", "ar" }, { "watch", "ar" },
        { "home", "th" }, { "general", "th" }, { "triggers", "th" }, { "toolbar", "th" },
        { "presets", "th" }, { "theme", "th" }, { "engines", "th" }, { "about", "th" }, { "watch", "th" },
        { "home", "en" }, { "general", "en" }, { "triggers", "en" }, { "toolbar", "en" },
        { "presets", "en" }, { "theme", "en" }, { "engines", "en" }, { "about", "en" },
        { "general", "ko" }, { "toolbar", "ko" }, { "home", "ko" },
        { "general", "zh-CN" }, { "presets", "zh-CN" }, { "toolbar", "zh-CN" }, { "home", "zh-CN" },
        { "general", "zh-TW" }, { "presets", "zh-TW" }, { "toolbar", "zh-TW" }, { "home", "zh-TW" },
        { "triggers", "zh-TW" }, { "engines", "zh-TW" }, { "watch", "zh-TW" },
        { "general", "pl" }, { "toolbar", "pl" }, { "presets", "pl" }, { "home", "pl" },
        { "home", "es" }, { "general", "es" }, { "toolbar", "es" }, { "presets", "es" }, { "engines", "es" },
        { "home", "fr" }, { "general", "fr" }, { "toolbar", "fr" }, { "presets", "fr" }, { "engines", "fr" },
        { "home", "hi" }, { "general", "hi" }, { "toolbar", "hi" }, { "presets", "hi" }, { "engines", "hi" },
        { "home", "ja" }, { "general", "ja" }, { "triggers", "ja" }, { "toolbar", "ja" },
        { "presets", "ja" }, { "theme", "ja" }, { "engines", "ja" }, { "about", "ja" }, { "watch", "ja" },
        { "home", "ru" }, { "general", "ru" }, { "triggers", "ru" }, { "toolbar", "ru" }, { "presets", "ru" },
        { "theme", "ru" }, { "engines", "ru" }, { "about", "ru" }, { "watch", "ru" },
        { "home", "pt-PT" }, { "general", "pt-PT" }, { "triggers", "pt-PT" }, { "toolbar", "pt-PT" },
        { "presets", "pt-PT" }, { "theme", "pt-PT" }, { "engines", "pt-PT" }, { "about", "pt-PT" }, { "watch", "pt-PT" },
        { "home", "pt-BR" }, { "general", "pt-BR" }, { "triggers", "pt-BR" }, { "toolbar", "pt-BR" },
        { "presets", "pt-BR" }, { "theme", "pt-BR" }, { "engines", "pt-BR" }, { "about", "pt-BR" }, { "watch", "pt-BR" },
        { "home", "ne" }, { "general", "ne" }, { "toolbar", "ne" }, { "presets", "ne" }, { "engines", "ne" },
    };

    [AvaloniaTheory]
    [MemberData(nameof(Pages))]
    public void Main_window_pages_render(string page, string language)
    {
        TestServices.EnsureInitialized(language);
        using var vm = new MainWindowViewModel(AppHost.Services, AppHost.Get<Filee.Core.Localization.ILocalizer>(), AppHost.Get<UpdateService>(), AppHost.Get<UserDataStore>());
        vm.Navigate(page);
        var window = new MainWindow { DataContext = vm, Width = 1080, Height = 820 };
        window.Show();
        Pump();

        Assert.NotNull(window.FindControl<ScrollViewer>("PageScroller"));
        Save(window, $"page-{page}-{language}.png");
        window.Close();
    }

    [AvaloniaFact]
    public void General_page_icon_rows_follow_platform_and_saved_values()
    {
        TestServices.EnsureInitialized("en");
        var directory = Directory.CreateTempSubdirectory("filee-icons-render-").FullName;
        try
        {
            var store = new UserDataStore(directory);
            store.Load();
            store.Settings.ShowInDock = false;
            store.Settings.ShowMenuBarIcon = true;
            store.SaveSettings();
            foreach (var supported in new[] { true, false })
            {
                var platform = new IconPlatform { SupportsDockVisibility = supported };
                using var vm = new GeneralPageViewModel(store, AppHost.Get<ILocalizer>(), platform,
                    NullLogger<GeneralPageViewModel>.Instance);
                var page = new GeneralPage { DataContext = vm };
                var window = new Window { Content = page, Width = 800, Height = 820 };
                try
                {
                    window.Show();
                    Pump();
                    var dock = page.FindControl<ToggleSwitch>("ShowInDockSwitch")!;
                    var menu = page.FindControl<ToggleSwitch>("ShowMenuBarIconSwitch")!;
                    Assert.Equal(supported, dock.IsVisible);
                    Assert.Equal(supported, menu.IsVisible);
                    Assert.False(dock.IsChecked);
                    Assert.True(menu.IsChecked);
                    Assert.Empty(platform.DockCalls);
                    if (supported)
                        Save(window, "page-general-icons-en.png");
                }
                finally
                {
                    window.Close();
                }
            }
        }
        finally
        {
            Directory.Delete(directory, true);
        }
    }

    [AvaloniaTheory]
    [InlineData("en")]
    [InlineData("ja")]
    [InlineData("ko")]
    [InlineData("ru")]
    [InlineData("ar")]
    public void Watch_folders_page_renders_a_rule(string language)
    {
        TestServices.EnsureInitialized(language);
        var store = AppHost.Get<Filee.Core.Settings.UserDataStore>();
        var rule = new Filee.Core.Watching.WatchRule { Folder = @"C:\Scans\Inbox", PresetId = "to-pdf", Enabled = false };
        store.Settings.WatchFolders.Add(rule);
        try
        {
            using var vm = new MainWindowViewModel(AppHost.Services, AppHost.Get<Filee.Core.Localization.ILocalizer>(), AppHost.Get<UpdateService>(), AppHost.Get<UserDataStore>());
            vm.Navigate("watch");
            var window = new MainWindow { DataContext = vm, Width = 1080, Height = 820 };
            window.Show();
            Pump();

            var page = (Filee.App.ViewModels.Pages.WatchFoldersPageViewModel)vm.CurrentPage;
            var item = Assert.Single(page.Rules);
            Assert.Equal("to-pdf", item.Preset?.Value);
            Assert.False(string.IsNullOrWhiteSpace(item.Status));
            Assert.EndsWith(Path.Combine("converted", Path.ChangeExtension(AppHost.Get<Filee.Core.Localization.ILocalizer>()["watch.sample_file"], "pdf")),
                item.PreviewExample); // where a converted file goes and what it is called
            Assert.False(item.ShowOptions); // the optional settings stay folded until used
            Save(window, $"page-watch-{language}.png");
            window.Close();
        }
        finally
        {
            store.Settings.WatchFolders.Remove(rule);
        }
    }

    [AvaloniaTheory]
    [InlineData("en")]
    [InlineData("ja")]
    [InlineData("ko")]
    public void Watch_folder_card_shows_recent_results_and_retries_in_the_folder(string language)
    {
        TestServices.EnsureInitialized(language);
        var store = AppHost.Get<Filee.Core.Settings.UserDataStore>();
        var conversions = AppHost.Get<ConversionService>();
        var folder = Directory.CreateTempSubdirectory("filee-watch-").FullName;
        var broken = Path.Combine(folder, "scan-0412.heic");
        File.WriteAllBytes(broken, [0]);
        var rule = new Filee.Core.Watching.WatchRule { Folder = folder, PresetId = "to-pdf", Enabled = false };
        store.Settings.WatchFolders.Add(rule);
        store.AddHistory(new Filee.Core.History.HistoryEntry
        {
            WatchRuleId = rule.Id,
            FinishedAt = DateTime.Now,
            Sources = [Path.Combine(folder, "a.jpg"), Path.Combine(folder, "b.jpg"), broken],
            Failures = [new() { Source = broken, ErrorKey = "error.conversion_failed", ErrorDetail = "HEIC decoder: unexpected end of file" }],
            Preset = new Filee.Core.Presets.Preset { TargetFormat = "pdf" },
        });
        var retried = new List<(string Rule, IReadOnlyList<string> Files)>();
        var previousRetry = conversions.WatchRetry;
        conversions.WatchRetry = (id, files, _) =>
        {
            retried.Add((id, files));
            return Task.CompletedTask;
        };
        try
        {
            using var vm = new MainWindowViewModel(AppHost.Services, AppHost.Get<Filee.Core.Localization.ILocalizer>(), AppHost.Get<UpdateService>(), AppHost.Get<UserDataStore>());
            vm.Navigate("watch");
            var window = new MainWindow { DataContext = vm, Width = 1080, Height = 1000 };
            window.Show();
            Pump();

            var item = Assert.Single(((Filee.App.ViewModels.Pages.WatchFoldersPageViewModel)vm.CurrentPage).Rules);
            Assert.True(item.HasResults);
            Assert.Equal("scan-0412.heic", Assert.Single(item.ResultFailures).Name);
            Assert.True(item.CanRetryResults);
            item.ToggleResultFailuresCommand.Execute(null);
            Pump();
            Save(window, $"page-watch-results-{language}.png");

            // Retrying goes through the watch folder (which then moves originals when it does that).
            item.RetryResultsCommand.Execute(null);
            var (ruleId, files) = Assert.Single(retried);
            Assert.Equal(rule.Id, ruleId);
            Assert.Equal([broken], files);
            window.Close();
        }
        finally
        {
            conversions.WatchRetry = previousRetry;
            store.Settings.WatchFolders.Remove(rule);
            store.SaveSettings();
            store.ClearHistory();
            try { Directory.Delete(folder, true); } catch (IOException) { }
        }
    }

    [AvaloniaTheory]
    [InlineData("en")]
    [InlineData("ja")]
    [InlineData("ko")]
    [InlineData("ru")]
    [InlineData("ar")]
    [InlineData("pt-PT")]
    [InlineData("pt-BR")]
    public void Watch_folder_options_rename_and_filter_with_a_preview(string language)
    {
        TestServices.EnsureInitialized(language);
        var store = AppHost.Get<Filee.Core.Settings.UserDataStore>();
        var folder = Directory.CreateTempSubdirectory("filee-watch-").FullName;
        File.WriteAllBytes(Path.Combine(folder, "notes.txt"), [0x41]);
        File.WriteAllBytes(Path.Combine(folder, "IMG_0412.jpg"), [0xFF, 0xD8]);
        var rule = new Filee.Core.Watching.WatchRule
        {
            Folder = folder,
            PresetId = "to-pdf",
            Enabled = false,
            Include = ["*.jpg"],
            FileNamePattern = "{name}_scan",
        };
        store.Settings.WatchFolders.Add(rule);
        try
        {
            using var vm = new MainWindowViewModel(AppHost.Services, AppHost.Get<Filee.Core.Localization.ILocalizer>(), AppHost.Get<UpdateService>(), AppHost.Get<UserDataStore>());
            vm.Navigate("watch");
            var window = new MainWindow { DataContext = vm, Width = 1080, Height = 1500 };
            window.Show();
            Pump();

            var item = Assert.Single(((Filee.App.ViewModels.Pages.WatchFoldersPageViewModel)vm.CurrentPage).Rules);
            Assert.True(item.ShowOptions); // options in use are shown

            // Typed patterns become chips: an extension turns into *.ext, a broken expression is not added.
            item.AddIncludeCommand.Execute("heic");
            Assert.Equal(["*.jpg", "*.heic"], rule.Include);
            item.AddIncludeCommand.Execute("/IMG_(/");
            Assert.NotNull(item.IncludeError);
            Assert.Equal("/IMG_(/", item.IncludeText);
            item.IncludeText = "";
            Assert.NotNull(item.IncludeMatches); // IMG_0412.jpg matches, notes.txt doesn't

            // The rename window works on copies: a ready-made replacement becomes a rule, the preview follows.
            var tool = item.CreateRenameTool();
            Assert.Equal("{name}_scan", tool.NamePattern); // the base name is edited here too
            tool.NamePattern = "";
            tool.InsertToken("date"); // an empty name starts from the original one
            Assert.Equal("{name}_{date}", tool.NamePattern);
            tool.NamePattern = "{name}_scan";
            tool.Recipes[0].AddCommand.Execute(null); // change IMG_ to Photo_
            Assert.Empty(rule.Renames); // nothing changes before saving
            Assert.Equal(new Filee.App.ViewModels.RenamePreview("IMG_0412.jpg", "Photo_0412_scan.pdf"), Assert.Single(tool.Previews));
            tool.CustomName = "img_0815.heic";
            Assert.Equal("Photo_0815_scan.pdf", tool.CustomResult);

            // Plain text is never "wrong"; only the advanced kind checks its expression.
            tool.AddStepCommand.Execute(null);
            var extra = tool.Steps[1];
            extra.Find = "(";
            Assert.Null(extra.Error);
            extra.Kind = tool.Kinds.First(k => k.Value == Filee.Core.Presets.RenameKind.Regex);
            Assert.NotNull(extra.Error);
            Assert.False(tool.IsValid);
            extra.Kind = tool.Kinds.First(k => k.Value == Filee.Core.Presets.RenameKind.Suffix);
            Assert.True(extra.ShowReplaceOnly);
            extra.Replace = "_v2";
            Assert.True(tool.IsValid);
            Assert.Equal("Photo_0412_scan_v2.pdf", tool.Previews[0].After);
            extra.RemoveCommand.Execute(null);
            var dialog = new Filee.App.Views.RenameToolWindow { DataContext = tool };
            dialog.Show();
            Pump();
            Save(dialog, $"window-rename-{language}.png");
            dialog.Close();

            item.SetNaming(tool.NamePattern, tool.Result); // saved
            Assert.Equal("IMG_", Assert.Single(rule.Renames).Find);
            // A file already in the folder that the patterns let through, renamed by the name rule and the rule.
            Assert.Equal($"IMG_0412.jpg → {Path.Combine("converted", "Photo_0412_scan.pdf")}", item.PreviewExample);
            Pump();
            Save(window, $"page-watch-options-{language}.png");
            window.Close();
        }
        finally
        {
            store.Settings.WatchFolders.Remove(rule);
            store.SaveSettings(); // editing the rule saved it: the next test's application would load it again
            try { Directory.Delete(folder, true); } catch (IOException) { }
        }
    }

    [AvaloniaTheory]
    [InlineData("en")]
    [InlineData("ja")]
    [InlineData("ko")]
    [InlineData("ru")]
    [InlineData("ar")]
    public void Home_page_lists_failed_files_with_a_retry_button(string language)
    {
        TestServices.EnsureInitialized(language);
        var store = AppHost.Get<Filee.Core.Settings.UserDataStore>();
        var folder = Directory.CreateTempSubdirectory("filee-home-").FullName;
        var scan = Path.Combine(folder, "scan-0412.heic");
        File.WriteAllBytes(scan, [0]);
        var entry = new Filee.Core.History.HistoryEntry
        {
            FinishedAt = DateTime.Now,
            PresetName = "PDF",
            State = Filee.Core.Conversion.JobState.CompletedWithErrors,
            Sources = [Path.Combine(folder, "report.docx"), scan, Path.Combine(folder, "notes.xyz")],
            Failures =
            [
                new() { Source = scan, ErrorKey = "error.conversion_failed", ErrorDetail = "HEIC decoder: unexpected end of file" },
                new() { Source = Path.Combine(folder, "notes.xyz"), ErrorKey = "error.unsupported_source", ErrorDetail = "xyz" },
            ],
            Preset = new Filee.Core.Presets.Preset { TargetFormat = "pdf" },
        };
        store.AddHistory(entry);
        try
        {
            using var vm = new MainWindowViewModel(AppHost.Services, AppHost.Get<Filee.Core.Localization.ILocalizer>(), AppHost.Get<UpdateService>(), AppHost.Get<UserDataStore>());
            vm.Navigate("home");
            var window = new MainWindow { DataContext = vm, Width = 1080, Height = 820 };
            window.Show();
            Pump();

            var item = ((Filee.App.ViewModels.Pages.HomePageViewModel)vm.CurrentPage).History[0];
            Assert.True(item.CanRetry);
            item.ToggleFailuresCommand.Execute(null);
            Pump();
            Save(window, $"page-home-failed-{language}.png");
            window.Close();
        }
        finally
        {
            store.ClearHistory(); // also on disk: the next test's application loads the history again
            try { Directory.Delete(folder, true); } catch (IOException) { }
        }
    }

    [AvaloniaTheory]
    [InlineData("en")]
    [InlineData("es")]
    [InlineData("ko")]
    [InlineData("zh-CN")]
    [InlineData("pl")]
    [InlineData("hi")]
    [InlineData("ru")]
    [InlineData("ar")]
    [InlineData("pt-BR")]
    [InlineData("fr")]
    public void Home_page_search_finds_old_conversions_in_a_long_history(string language)
    {
        TestServices.EnsureInitialized(language);
        var store = AppHost.Get<Filee.Core.Settings.UserDataStore>();
        var loc = AppHost.Get<Filee.Core.Localization.ILocalizer>();
        store.ClearHistory();
        // A full history (newest first), with the report far below what the page lists without a search.
        var entries = Enumerable.Range(0, store.Settings.EffectiveHistoryLimit).Select(i => new Filee.Core.History.HistoryEntry
        {
            FinishedAt = DateTime.Now.AddMinutes(-i),
            PresetName = i == 150 ? "PDF" : "PNG",
            State = Filee.Core.Conversion.JobState.Completed,
            Sources = i == 150 ? [@"C:\Work\Annual report.docx", @"C:\Work\notes.txt"] : [$@"C:\Photos\IMG_{i:0000}.heic"],
        });
        store.History.AddRange(entries);
        try
        {
            using var vm = new MainWindowViewModel(AppHost.Services, loc, AppHost.Get<UpdateService>(), AppHost.Get<UserDataStore>());
            vm.Navigate("home");
            var window = new MainWindow { DataContext = vm, Width = 1080, Height = 820 };
            window.Show();
            Pump();

            var page = (HomePageViewModel)vm.CurrentPage;
            Assert.Equal(HomePageViewModel.Shown, page.History.Count);
            var search = window.GetVisualDescendants().OfType<TextBox>().Single(t => t.Classes.Contains("search"));
            Assert.True(search.IsEffectivelyVisible);
            Assert.Equal(loc["common.search"], search.PlaceholderText);

            page.Search = " REPORT "; // any part of a source file name, ignoring case and spaces around
            Pump();
            var found = Assert.Single(page.History);
            Assert.Equal("PDF", found.Title);
            Assert.False(page.NoMatches);
            Save(window, $"page-home-search-{language}.png");

            page.Search = "PNG"; // the preset: the newest matches, no more than without a search
            Assert.Equal(HomePageViewModel.Shown, page.History.Count);
            Assert.All(page.History, item => Assert.Equal("PNG", item.Title));

            page.Search = "zzz";
            Pump();
            Assert.Empty(page.History);
            Assert.True(page.NoMatches);
            Assert.False(page.IsEmpty);
            Save(window, $"page-home-search-none-{language}.png");

            page.Search = "";
            Assert.Equal(HomePageViewModel.Shown, page.History.Count);
            window.Close();
        }
        finally
        {
            store.ClearHistory(); // also on disk: the next test's application loads the history again
        }
    }

    [AvaloniaFact]
    public void A_new_preset_shows_in_the_list_whatever_was_searched()
    {
        TestServices.EnsureInitialized("en");
        var store = AppHost.Get<Filee.Core.Settings.UserDataStore>();
        using var vm = new MainWindowViewModel(AppHost.Services, AppHost.Get<Filee.Core.Localization.ILocalizer>(), AppHost.Get<UpdateService>(), AppHost.Get<UserDataStore>());
        vm.Navigate("presets");
        var page = (PresetsPageViewModel)vm.CurrentPage;
        page.Search = "zzz";
        Assert.Empty(page.VisiblePresets);

        page.AddCommand.Execute(null);
        try
        {
            Assert.Equal("", page.Search);
            Assert.Contains(page.SelectedPreset!, page.VisiblePresets);
        }
        finally
        {
            store.Presets.Remove(page.SelectedPreset!.Preset);
            store.SaveLibrary();
        }
    }

    [AvaloniaTheory]
    [InlineData("en")]
    [InlineData("ru")]
    public void Add_offers_presets_for_where_a_file_goes_and_the_editor_keeps_their_size_limit(string language)
    {
        TestServices.EnsureInitialized(language);
        var store = AppHost.Get<Filee.Core.Settings.UserDataStore>();
        var loc = AppHost.Get<Filee.Core.Localization.ILocalizer>();
        using var vm = new MainWindowViewModel(AppHost.Services, loc, AppHost.Get<UpdateService>(), AppHost.Get<UserDataStore>());
        vm.Navigate("presets");
        var page = (PresetsPageViewModel)vm.CurrentPage;
        Assert.Equal(["for-email", "for-discord", "for-whatsapp", "for-instagram"], page.PlacePresets.Select(p => p.Preset.Id));
        Assert.All(page.PlacePresets, p => Assert.DoesNotContain("preset.", p.Name)); // translated, not a raw key

        var whatsapp = page.PlacePresets[2].Preset;
        page.AddPlaceCommand.Execute(whatsapp);
        page.AddPlaceCommand.Execute(whatsapp);
        var added = store.Presets.Where(p => p.NameKey == "preset.for_whatsapp").ToList();
        try
        {
            // Two copies, each its own preset; the offer itself stays as it was.
            Assert.Equal(2, added.Count);
            Assert.Equal(2, added.Select(p => p.Id).Distinct().Count());
            Assert.DoesNotContain(added, p => p.Id == "for-whatsapp");
            Assert.Same(added[^1], page.SelectedPreset!.Preset);

            var editor = page.Editor!;
            Assert.True(editor.ShowVideoMaxSize);
            Assert.Equal(16m, editor.VideoMaxSizeMb);
            editor.VideoMaxSizeMb = 25;
            Assert.True(editor.Apply());
            Assert.Equal(25, added[^1].Media.MaxSizeMb);
            Assert.Equal(16, whatsapp.Media.MaxSizeMb);

            // Not where nothing could fit it: VOB and DV have a fixed bitrate.
            editor.Target = editor.Targets.Single(t => t.Value == "vob");
            Assert.False(editor.ShowVideoMaxSize);
            editor.Target = editor.Targets.Single(t => t.Value == "mp4");
            Assert.True(editor.ShowVideoMaxSize);
            Assert.False(new PresetEditorViewModel(Filee.Core.Presets.BuiltInData.CreatePresets().First(p => p.JoinsIntoOneMedia), loc).ShowVideoMaxSize);

            // A cleared box is no limit; a JPG target shows its own box, and a limit left behind by MP4 isn't kept.
            editor.VideoMaxSizeMb = null;
            editor.Target = editor.Targets.Single(t => t.Value == "jpg");
            Assert.False(editor.ShowVideoMaxSize);
            Assert.True(editor.ShowQuality);
            editor.ImageMaxSize = 1.5m;
            Assert.True(editor.Apply());
            Assert.Equal((0.0, 1.5), (added[^1].Media.MaxSizeMb, added[^1].Image.MaxSizeMb));

            var window = new MainWindow { DataContext = vm, Width = 1180, Height = 900 };
            window.Show();
            Pump();
            var add = window.GetVisualDescendants().OfType<Button>().Single(b => b.Name == "AddPresetButton");
            add.Flyout!.ShowAt(add);
            Pump();
            Save(window, $"presets-add-menu-{language}.png");
            window.Close();
        }
        finally
        {
            foreach (var preset in added)
                store.Presets.Remove(preset);
            store.SaveLibrary();
        }
    }

    [AvaloniaFact]
    public void General_page_keeps_the_history_limit_within_its_range()
    {
        TestServices.EnsureInitialized("en");
        var store = AppHost.Get<Filee.Core.Settings.UserDataStore>();
        var before = store.Settings.HistoryLimit;
        try
        {
            using var vm = new MainWindowViewModel(AppHost.Services, AppHost.Get<Filee.Core.Localization.ILocalizer>(), AppHost.Get<UpdateService>(), AppHost.Get<UserDataStore>());
            vm.Navigate("general");
            var window = new MainWindow { DataContext = vm, Width = 1080, Height = 820 };
            window.Show();
            Pump();

            var page = (GeneralPageViewModel)vm.CurrentPage;
            Assert.Equal(200, page.HistoryLimit);
            var limit = window.GetVisualDescendants().OfType<NumericUpDown>().Single();
            Assert.True(limit.IsEffectivelyVisible);

            page.HistoryLimit = 500;
            Assert.Equal(500, store.Settings.HistoryLimit);
            page.HistoryLimit = 5000;
            Assert.Equal(Filee.Core.Settings.AppSettings.MaxHistoryLimit, store.Settings.HistoryLimit);

            page.NoHistory = true; // nothing is recorded: nothing to limit either
            Pump();
            Assert.False(limit.IsEffectivelyVisible);
            page.NoHistory = false;
            window.Close();
        }
        finally
        {
            store.Settings.HistoryLimit = before;
            store.SaveSettings();
        }
    }

    [AvaloniaFact]
    public void Engines_page_shows_versions_descriptions_and_download_speed()
    {
        TestServices.EnsureInitialized("ko");
        var downloads = AppHost.Get<EngineDownloadService>();
        var package = downloads.Packages[0];
        var before = (package.Status, package.Progress, package.ProgressDetail);
        package.Status = EnginePackageStatus.Downloading;
        package.Progress = 42;
        package.ProgressDetail = "176 MB / 422 MB · 8.4 MB/s · 30초 남음";
        try
        {
            using var vm = new MainWindowViewModel(AppHost.Services, AppHost.Get<Filee.Core.Localization.ILocalizer>(), AppHost.Get<UpdateService>(), AppHost.Get<UserDataStore>());
            vm.Navigate("engines");
            var window = new MainWindow { DataContext = vm, Width = 1080, Height = 1400 };
            window.Show();
            Pump();

            var engines = ((Filee.App.ViewModels.Pages.EnginesPageViewModel)vm.CurrentPage).Engines;
            Assert.All(engines.Where(e => e.IsAvailable), e => Assert.False(string.IsNullOrWhiteSpace(e.Version)));
            Assert.All(engines, e => Assert.False(string.IsNullOrWhiteSpace(e.Description)));
            Save(window, "page-engines-downloading-ko.png");
            window.Close();
        }
        finally
        {
            (package.Status, package.Progress, package.ProgressDetail) = before;
        }
    }

    [AvaloniaTheory]
    [InlineData("en")]
    [InlineData("es")]
    [InlineData("ko")]
    [InlineData("hi")]
    [InlineData("ru")]
    [InlineData("ar")]
    public void Reset_to_default_sits_beside_delete_for_a_built_in_profile_only(string language)
    {
        TestServices.EnsureInitialized(language);
        var store = AppHost.Get<UserDataStore>();
        var profiles = store.Profiles.Select(p => p.Clone()).ToList();
        try
        {
            using var vm = new MainWindowViewModel(AppHost.Services, AppHost.Get<Filee.Core.Localization.ILocalizer>(), AppHost.Get<UpdateService>(), AppHost.Get<UserDataStore>());
            vm.Navigate("toolbar");
            var page = (ToolbarPageViewModel)vm.CurrentPage!;
            var window = new MainWindow { DataContext = vm, Width = 1080, Height = 820 };
            window.Show();
            page.SelectedProfile = page.Profiles.Single(p => p.Profile.Id == "images");
            Pump();

            var actions = window.GetVisualDescendants().OfType<StackPanel>().Single(s => s.Name == "ProfileActions");
            var reset = (Button)actions.Children[0];
            var delete = (Button)actions.Children[1];
            Assert.Same(page.ResetProfileCommand, reset.Command);
            Assert.Same(page.DeleteProfileCommand, delete.Command);
            Assert.True(reset.IsVisible && delete.IsVisible);
            // On one row, reset first, both inside the profile card.
            var card = window.GetVisualDescendants().OfType<Border>().Single(b => b.Name == "ProfileCard");
            var resetBox = Avalonia.VisualExtensions.TranslatePoint(reset, default, card)!.Value;
            var deleteBox = Avalonia.VisualExtensions.TranslatePoint(delete, default, card)!.Value;
            Assert.Equal(resetBox.Y, deleteBox.Y);
            Assert.True(resetBox.X + reset.Bounds.Width < deleteBox.X);
            Assert.True(resetBox.X >= 0 && deleteBox.X + delete.Bounds.Width <= card.Bounds.Width);
            actions.BringIntoView();
            Pump();
            Save(window, $"toolbar-reset-profile-{language}.png");

            // A profile the user made has no default: only delete.
            page.AddProfileCommand.Execute(null);
            Pump();
            Assert.False(reset.IsVisible);
            Assert.True(delete.IsVisible);
            window.Close();
        }
        finally
        {
            store.Profiles.Clear();
            store.Profiles.AddRange(profiles);
            store.SaveLibrary();
        }
    }

    [AvaloniaFact]
    public void Dragging_a_preset_opens_a_gap_with_a_preview_slice()
    {
        TestServices.EnsureInitialized("ko");
        using var vm = new MainWindowViewModel(AppHost.Services, AppHost.Get<Filee.Core.Localization.ILocalizer>(), AppHost.Get<UpdateService>(), AppHost.Get<UserDataStore>());
        vm.Navigate("toolbar");
        var window = new MainWindow { DataContext = vm, Width = 1080, Height = 820 };
        window.Show();
        Pump();
        var donut = window.GetVisualDescendants().OfType<DonutMenu>().Single(d => d.IsEditMode);
        var count = donut.Items!.Count;

        // A chip over the third slice: the slices from there on slide clockwise and a preview takes slot 2.
        donut.SetDropPreview(2, "TIFF 300dpi");
        for (var i = 0; i < 120; i++)
            donut.Advance(1 / 60.0);
        donut.InvalidateVisual();
        Pump();
        Assert.Equal(2, donut.SlotAt(DonutPoint(donut, 2, count + 1), count + 1));
        Save(window, "toolbar-drop-preview-ko.png");

        // Moving the first slice to slot 3: it leaves its place, the preview shows it at the new one.
        donut.SetDropPreview(3, donut.Items[0].Label, removed: 0);
        for (var i = 0; i < 120; i++)
            donut.Advance(1 / 60.0);
        donut.InvalidateVisual();
        Pump();
        Save(window, "toolbar-move-preview-ko.png");

        donut.SetDropPreview(-1);
        window.Close();
    }

    /// <summary>
    /// The built-in "Rotate" and "Flip" groups put on a full image donut (as a user would; they are on no donut by
    /// default): their presets' names fit their ring slices, in every language.
    /// </summary>
    [AvaloniaTheory]
    [InlineData("ja")]
    [InlineData("ko")]
    [InlineData("en")]
    [InlineData("zh-CN")]
    [InlineData("ru")]
    [InlineData("ar")]
    public void The_rotate_and_flip_groups_fan_out_names_that_fit(string language)
    {
        TestServices.EnsureInitialized(language);
        var store = AppHost.Get<UserDataStore>();
        var images = store.Profiles.Single(p => p.Id == "images");
        var before = images.PresetIds.ToList();
        try
        {
            images.PresetIds.AddRange(["rotate", "flip"]);
            var vm = AppHost.Get<RadialViewModel>();
            vm.Load([@"C:\photos\a.jpg"], clickMode: true);
            vm.FitToThisDonut();
            var rotate = vm.Items.Count - 2;
            Assert.Equal(3, vm.Items[rotate].Children!.Count);
            Assert.All(vm.Items[rotate].Children!, item => Assert.True(item.IsEnabled, item.Label));
            // Short names on the ring ("Rotate" → "Left"), the full one ("Rotate left") everywhere else.
            var loc = AppHost.Get<Filee.Core.Localization.ILocalizer>();
            var left = store.FindPreset("rotate-left")!;
            Assert.Equal(loc["preset.rotate_left.short"], vm.Items[rotate].Children![0].Label);
            Assert.NotEqual(loc.DisplayName(left), vm.Items[rotate].Children![0].Label);

            var window = new RadialWindow { DataContext = vm };
            window.Show();
            var donut = window.DonutControl;
            donut.SetExternalHit(new DonutHit(DonutHitKind.Segment, rotate));
            donut.ExpandPendingGroup();
            donut.SetExternalHit(new DonutHit(DonutHitKind.SubSegment, rotate, 1));
            vm.ShowHint(rotate, donut.ActiveSubIndex, centerHot: false);
            Pump();
            Save(window, $"donut-rotate-{language}.png");
            window.Close();
        }
        finally
        {
            images.PresetIds.Clear();
            images.PresetIds.AddRange(before);
        }
    }

    /// <summary>
    /// A group of three formats on the image donut: hovering it fans PNG / JPG / WEBP out outside it, and the slice
    /// under the pointer there is what a drop or click converts with.
    /// </summary>
    [AvaloniaTheory]
    [InlineData("ja")]
    [InlineData("ko")]
    [InlineData("en")]
    [InlineData("ru")]
    [InlineData("ar")]
    public void A_group_slice_fans_out_its_presets(string language)
    {
        TestServices.EnsureInitialized(language);
        var store = AppHost.Get<UserDataStore>();
        var images = store.Profiles.Single(p => p.Id == "images");
        var before = images.PresetIds.ToList();
        var group = new Filee.Core.Presets.Preset
        {
            Id = "render-group",
            Name = language == "ko" ? "형식" : "Formats",
            Kind = Filee.Core.Presets.PresetKind.Group,
            SubPresetIds = ["to-png", "to-jpg", "to-webp"],
        };
        try
        {
            store.Presets.Add(group);
            images.PresetIds.Add(group.Id);
            var vm = AppHost.Get<RadialViewModel>();
            vm.Load([@"C:\photos\a.jpg"], clickMode: true);
            vm.FitToThisDonut();
            Assert.True(vm.ReserveSubRing);
            var index = vm.Items.Count - 1;
            Assert.Equal(3, vm.Items[index].Children!.Count);
            Assert.Null(vm.PresetAt(index, -1)); // the group itself converts nothing
            Assert.Equal("to-jpg", vm.PresetAt(index, 1)!.Id);

            var window = new RadialWindow { DataContext = vm };
            window.Show();
            var donut = window.DonutControl;
            donut.SetExternalHit(new DonutHit(DonutHitKind.Segment, index));
            donut.ExpandPendingGroup(); // as after resting on it
            donut.SetExternalHit(new DonutHit(DonutHitKind.SubSegment, index, 1));
            vm.ShowHint(index, donut.ActiveSubIndex, centerHot: false);
            Pump();

            var n = vm.Items.Count;
            var center = new Avalonia.Point(donut.Bounds.Width / 2, donut.Bounds.Height / 2);
            var onRing = donut.SubSliceCenter(index, 1);
            Assert.Equal(new DonutHit(DonutHitKind.SubSegment, index, 1), donut.HitTest(onRing));
            // The gap before the ring keeps the group; a neighbour's slice, outer half or inner, is that neighbour (a click
            // or drop there converts with it; DonutGroupTests checks the ring stays open over its outer half).
            var neighbour = DonutGeometry.MidAngle(index, n) - DonutGeometry.Span(n) * 0.6;
            Assert.Equal(new DonutHit(DonutHitKind.Segment, index),
                donut.HitTest(DonutGeometry.PointAt(center, vm.OuterRadius + 10, DonutGeometry.MidAngle(index, n))));
            Assert.Equal(new DonutHit(DonutHitKind.Segment, index - 1), donut.HitTest(DonutGeometry.PointAt(center, vm.OuterRadius - 8, neighbour)));
            Assert.Equal(new DonutHit(DonutHitKind.Segment, index - 1),
                donut.HitTest(DonutGeometry.PointAt(center, vm.OuterRadius * vm.HoleRatio + 6, neighbour)));
            Assert.Contains("JPG", vm.CenterSubtitle);
            Save(window, $"donut-group-{language}.png");
            window.Close();
        }
        finally
        {
            images.PresetIds.Clear();
            images.PresetIds.AddRange(before);
            store.Presets.Remove(group);
        }
    }

    /// <summary>
    /// The theme's softness rounds the donut's slices (and a group's ring) too, live while it is open; the corners it
    /// cuts away still belong to their slice for clicks and drops.
    /// </summary>
    [AvaloniaTheory]
    [InlineData(false)]
    [InlineData(true)]
    public void Donut_slices_follow_the_softness(bool dark)
    {
        TestServices.EnsureInitialized("en");
        var theme = AppHost.Get<ThemeService>();
        var store = AppHost.Get<UserDataStore>();
        var images = store.Profiles.Single(p => p.Id == "images");
        var before = images.PresetIds.ToList();
        var group = new Filee.Core.Presets.Preset
        {
            Id = "render-soft-group",
            Name = "Formats",
            Kind = Filee.Core.Presets.PresetKind.Group,
            SubPresetIds = ["to-png", "to-jpg", "to-webp"],
        };
        var mode = dark ? ThemeMode.Dark : ThemeMode.Light;
        var suffix = dark ? "dark" : "light";
        try
        {
            store.Presets.Add(group);
            images.PresetIds.Add(group.Id);
            theme.Apply(new ThemeSettings { Mode = mode, CornerRadius = 0 }, "en");
            var vm = AppHost.Get<RadialViewModel>();
            vm.Load([@"C:\photos\a.jpg", @"C:\photos\b.jpg"], clickMode: true);
            vm.FitToThisDonut();
            var window = new RadialWindow { DataContext = vm };
            window.Show();
            var donut = window.DonutControl;
            donut.SetExternalHighlight(1);
            Pump();
            Assert.Equal(0, donut.SliceCornerRadius);
            Save(window, $"donut-softness-0-{suffix}.png");

            // Changing the setting while the donut is open rounds it at once.
            theme.Apply(new ThemeSettings { Mode = mode, CornerRadius = 28 }, "en");
            Pump();
            Assert.Equal(14, donut.SliceCornerRadius);
            Save(window, $"donut-softness-28-{suffix}.png");

            // The sharp corner of slice 2, cut away now, still picks slice 2.
            var n = vm.Items.Count;
            var center = new Avalonia.Point(donut.Bounds.Width / 2, donut.Bounds.Height / 2);
            var inner = vm.OuterRadius * vm.HoleRatio;
            var corner = DonutGeometry.Wedge(center, inner, vm.OuterRadius, DonutGeometry.MidAngle(2, n), DonutGeometry.Span(n), 3).Start;
            var inside = center + (corner - center) * 0.995;
            Assert.Equal(new DonutHit(DonutHitKind.Segment, 2), donut.HitTest(inside));

            var index = n - 1;
            donut.SetExternalHit(new DonutHit(DonutHitKind.Segment, index));
            donut.ExpandPendingGroup();
            donut.SetExternalHit(new DonutHit(DonutHitKind.SubSegment, index, 1));
            vm.ShowHint(index, donut.ActiveSubIndex, centerHot: false);
            Pump();
            Assert.Equal(new DonutHit(DonutHitKind.SubSegment, index, 1), donut.HitTest(donut.SubSliceCenter(index, 1)));
            Save(window, $"donut-softness-28-group-{suffix}.png");
            window.Close();
        }
        finally
        {
            images.PresetIds.Clear();
            images.PresetIds.AddRange(before);
            store.Presets.Remove(group);
            theme.Apply(new ThemeSettings(), "en");
        }
    }

    /// <summary>The geospatial donut opens for Shapefiles with its six slices, rounded by the softness like the others.</summary>
    [AvaloniaFact]
    public void Geospatial_donut_opens_for_shapefiles_with_rounded_slices()
    {
        TestServices.EnsureInitialized("en");
        var theme = AppHost.Get<ThemeService>();
        try
        {
            theme.Apply(new ThemeSettings { Mode = ThemeMode.Light, CornerRadius = 28 }, "en");
            var vm = AppHost.Get<RadialViewModel>();
            vm.Load([@"C:\gis\roads.shp", @"C:\gis\parcels.shp"], clickMode: true);
            vm.FitToThisDonut();
            Assert.Equal(["to-geojson", "to-shp", "to-kml", "to-csv", "to-gpx", "to-kmz"], vm.Presets.Select(p => p.Id));
            Assert.All(vm.Items, item => Assert.True(item.IsEnabled));
            var window = new RadialWindow { DataContext = vm };
            window.Show();
            var donut = window.DonutControl;
            donut.SetExternalHighlight(1);
            Pump();
            Assert.Equal(14, donut.SliceCornerRadius);

            // A corner the rounding cut away still picks its slice.
            var n = vm.Items.Count;
            var center = new Avalonia.Point(donut.Bounds.Width / 2, donut.Bounds.Height / 2);
            var inner = vm.OuterRadius * vm.HoleRatio;
            var corner = DonutGeometry.Wedge(center, inner, vm.OuterRadius, DonutGeometry.MidAngle(4, n), DonutGeometry.Span(n), 3).Start;
            Assert.Equal(new DonutHit(DonutHitKind.Segment, 4), donut.HitTest(center + (corner - center) * 0.995));
            Save(window, "donut-geospatial-soft.png");
            window.Close();
        }
        finally
        {
            theme.Apply(new ThemeSettings(), "en");
        }
    }

    /// <summary>The middle of slot <paramref name="slot"/> of a donut with <paramref name="slots"/> slices.</summary>
    private static Avalonia.Point DonutPoint(DonutMenu donut, int slot, int slots)
    {
        var center = new Avalonia.Point(donut.Bounds.Width / 2, donut.Bounds.Height / 2);
        var radius = donut.OuterRadius * (1 + donut.HoleRatio) / 2;
        return DonutGeometry.PointAt(center, radius, DonutGeometry.MidAngle(slot, slots));
    }

    [AvaloniaTheory]
    [InlineData("ko", "JPG 3개")]
    [InlineData("ru", "3 × JPG")]
    [InlineData("ar", "3 × JPG")]
    public void Donut_toolbar_renders_for_images(string language, string title)
    {
        TestServices.EnsureInitialized(language);
        var files = new[] { @"C:\photos\a.jpg", @"C:\photos\b.jpg", @"C:\photos\c.jpg" };
        var vm = AppHost.Get<RadialViewModel>();
        vm.Load(files, clickMode: true);
        var window = new RadialWindow { DataContext = vm };
        window.Show();
        window.DonutControl.SetExternalHighlight(1);
        Pump();

        Assert.Equal(12, vm.Items.Count); // with "Trace to SVG", "Line art to SVG", "Edit pictures" and "Pixelate / blur"
        Assert.Equal(title, vm.CenterTitle);
        Save(window, $"donut-images-{language}.png");
        window.Close();
    }

    [AvaloniaFact]
    public void LibreOffice_options_window_renders()
    {
        TestServices.EnsureInitialized("ko");
        using var vm = new Filee.App.ViewModels.Pages.EnginesPageViewModel(AppHost.Get<Filee.Core.Settings.UserDataStore>(),
            AppHost.Get<Filee.Core.Conversion.ConverterCatalog>(), AppHost.Get<Filee.Core.Localization.ILocalizer>(), AppHost.Get<EngineDownloadService>());
        var window = new Filee.App.Views.LibreOfficeOptionsWindow { DataContext = vm };
        window.Show();
        Pump();
        Save(window, "window-libreoffice-options-ko.png");
        window.Close();
    }

    [AvaloniaTheory]
    [InlineData("en")]
    [InlineData("ja")]
    [InlineData("ko")]
    [InlineData("ru")]
    [InlineData("ar")]
    [InlineData("pt-PT")]
    [InlineData("pt-BR")]
    public void Sponsor_window_renders(string language)
    {
        TestServices.EnsureInitialized(language);
        var window = Filee.App.Views.SponsorWindow.Create(AppHost.Get<Filee.Core.Localization.ILocalizer>());
        window.Show();
        Pump();
        Save(window, $"window-sponsor-{language}.png");
        window.Close();
    }

    [AvaloniaTheory]
    [InlineData("en")]
    [InlineData("pt-PT")]
    [InlineData("pt-BR")]
    public void Sponsor_window_with_supporters_renders(string language)
    {
        TestServices.EnsureInitialized(language);
        var window = Filee.App.Views.SponsorWindow.Create(AppHost.Get<Filee.Core.Localization.ILocalizer>());
        var view = window.Supporters;
        view.Show(new SupporterList(
            [new Supporter("Acme", "https://acme.example", "acme.png"), new Supporter("Globex", "https://globex.example")],
            [new("Kim"), new("Lee"), new("Park")]), _ => Logo());
        window.Show();
        Pump();
        CheckAcknowledgement(window);
        Save(window, $"window-sponsor-supporters-{language}.png");
        window.Close();

        using var vm = new MainWindowViewModel(AppHost.Services, AppHost.Get<Filee.Core.Localization.ILocalizer>(), AppHost.Get<UpdateService>(), AppHost.Get<UserDataStore>());
        vm.Navigate("about");
        var main = new MainWindow { DataContext = vm, Width = 1080, Height = 820 };
        main.Show();
        Pump();
        var about = main.GetVisualDescendants().OfType<Filee.App.Views.Pages.AboutPage>().Single();
        about.Supporters.Show(new SupporterList(
            [new Supporter("Acme", "https://acme.example", "acme.png"), new Supporter("Globex", "https://globex.example")],
            [new("Kim"), new("Lee"), new("Park")]), _ => Logo());
        Pump();
        CheckAcknowledgement(main);
        Save(main, $"page-about-supporters-{language}.png");
        main.Close();

        static void CheckAcknowledgement(Window target)
        {
            var thanks = AppHost.Get<Filee.Core.Localization.ILocalizer>()["sponsor.thanks"];
            var labels = target.GetVisualDescendants().OfType<TextBlock>()
                .Where(t => t.IsEffectivelyVisible && t.Text == thanks).ToArray();
            Assert.NotEmpty(labels);
            Assert.All(labels, text => Assert.True(text.TextLayout.Width <= text.Bounds.Width + 1 &&
                                                    text.TextLayout.Height <= text.Bounds.Height + 1,
                $"Acknowledgement is clipped: {thanks}"));
        }

        // A stand-in logo: a wide coloured mark like a company's.
        static Avalonia.Media.Imaging.Bitmap Logo()
        {
            var bitmap = new Avalonia.Media.Imaging.RenderTargetBitmap(new Avalonia.PixelSize(120, 32));
            using (var context = bitmap.CreateDrawingContext())
            {
                context.DrawRectangle(new Avalonia.Media.SolidColorBrush(Avalonia.Media.Color.Parse("#3B6FD8")), null, new Avalonia.Rect(0, 4, 24, 24), 6, 6);
                context.DrawRectangle(new Avalonia.Media.SolidColorBrush(Avalonia.Media.Color.Parse("#7A8699")), null, new Avalonia.Rect(32, 10, 84, 12), 3, 3);
            }
            return bitmap;
        }
    }

    [AvaloniaTheory]
    [InlineData("en")]
    [InlineData("ja")]
    [InlineData("ko")]
    [InlineData("ru")]
    [InlineData("ar")]
    [InlineData("pt-PT")]
    [InlineData("pt-BR")]
    public void First_run_engine_setup_renders(string language)
    {
        TestServices.EnsureInitialized(language);
        var vm = new EngineSetupViewModel(AppHost.Get<EngineDownloadService>(), AppHost.Get<Filee.Core.Localization.ILocalizer>());
        var window = new EngineSetupWindow { DataContext = vm };
        window.Show();
        Pump();

        // Everything not installed is offered, nothing is ticked: installing needs a choice first.
        Assert.Contains(vm.Packages, p => !p.IsInstalled && p.CanInstall);
        Assert.DoesNotContain(vm.Packages, p => p.Selected);
        Assert.False(vm.InstallCommand.CanExecute(null));
        vm.Packages.First(p => p.CanInstall && !p.IsInstalled).Selected = true;
        Assert.True(vm.InstallCommand.CanExecute(null));
        vm.Packages.First(p => p.Selected).Selected = false;
        Save(window, $"engine-setup-{language}.png");
        window.Close();
    }

    [AvaloniaTheory]
    [InlineData("en")]
    [InlineData("pt-PT")]
    [InlineData("pt-BR")]
    public void Engine_setup_on_a_short_screen_scrolls_the_list_and_keeps_its_buttons(string language)
    {
        TestServices.EnsureInitialized(language);
        var vm = new EngineSetupViewModel(AppHost.Get<EngineDownloadService>(), AppHost.Get<Filee.Core.Localization.ILocalizer>());
        var window = new EngineSetupWindow { DataContext = vm };
        var closed = false;
        window.Closed += (_, _) => closed = true;
        window.Show();
        Pump();
        var fullHeight = window.ClientSize.Height;

        // A screen with room for the whole list leaves the window as it was.
        window.FitTo(new Avalonia.PixelRect(0, 0, 1920, (int)fullHeight + 200), 1);
        Pump();
        Assert.Equal(fullHeight, window.ClientSize.Height);

        // 1366 × 768 at 150 % less the taskbar (#370): 480 high in window units, shorter than the list.
        window.FitTo(new Avalonia.PixelRect(0, 0, 1366, 720), 1.5);
        Pump();
        Assert.True(fullHeight > 480, $"The list is {fullHeight} high, too short to test this.");
        Assert.InRange(window.ClientSize.Height, 200, 480);
        Assert.InRange(window.Position.Y, 0, 720 - window.ClientSize.Height * 1.5);
        var scroller = window.FindControl<ScrollViewer>("PackageScroller")!;
        Assert.True(scroller.Extent.Height > scroller.Viewport.Height);
        foreach (var name in new[] { "CloseButton", "InstallButton" })
        {
            var button = window.FindControl<Button>(name)!;
            var bottom = Avalonia.VisualExtensions.TranslatePoint(button, new Avalonia.Point(0, button.Bounds.Height), window)!.Value.Y;
            Assert.InRange(bottom, 0, window.ClientSize.Height);
        }
        Save(window, $"engine-setup-short-screen-{language}.png");

        // Esc closes it like Cancel / Close in the other dialogs.
        window.KeyPress(Key.Escape, RawInputModifiers.None, PhysicalKey.Escape, null);
        Pump();
        Assert.True(closed);
    }

    [AvaloniaFact]
    public void Donut_toolbar_waits_for_files_in_drag_mode()
    {
        TestServices.EnsureInitialized("en");
        var vm = AppHost.Get<RadialViewModel>();
        vm.ResetForDrag();
        var window = new RadialWindow { DataContext = vm };
        window.Show();
        Pump();

        Assert.Empty(vm.Items);
        // Nothing shows until files are dragged in (a Ctrl + drag without files must not open anything).
        Assert.Equal(0, vm.DonutOpacity);
        Save(window, "donut-drag-waiting.png");
        vm.Load([@"C:\photos\a.jpg"], clickMode: false);
        Assert.Equal(1, vm.DonutOpacity);
        window.Close();
    }

    [AvaloniaFact]
    public void Dark_theme_with_custom_accent_renders()
    {
        TestServices.EnsureInitialized("en");
        var theme = new ThemeSettings { Mode = ThemeMode.Dark, Accent = "#1D9E75", CornerRadius = 22 };
        AppHost.Get<ThemeService>().Apply(theme, "en");
        using var vm = new MainWindowViewModel(AppHost.Services, AppHost.Get<Filee.Core.Localization.ILocalizer>(), AppHost.Get<UpdateService>(), AppHost.Get<UserDataStore>());
        vm.Navigate("toolbar");
        var window = new MainWindow { DataContext = vm, Width = 1080, Height = 820 };
        window.Show();
        Pump();

        Save(window, "page-toolbar-dark.png");
        window.Close();
        AppHost.Get<ThemeService>().Apply(new ThemeSettings(), "en");
    }

    [AvaloniaFact]
    public void Custom_theme_colours_replace_the_built_in_ones_and_go_away_with_the_file()
    {
        TestServices.EnsureInitialized("en");
        var service = AppHost.Get<ThemeService>();
        var dark = new ThemeSettings { Mode = ThemeMode.Dark };
        var custom = new CustomTheme
        {
            Dark = { ["page"] = "#101820", ["surface"] = "#18222C", ["surfaceAlt"] = "#22303C", ["text"] = "#E8E4D8" },
        };
        try
        {
            service.Apply(dark, "en", custom);
            using var vm = new MainWindowViewModel(AppHost.Services, AppHost.Get<Filee.Core.Localization.ILocalizer>(), AppHost.Get<UpdateService>(), AppHost.Get<UserDataStore>());
            vm.Navigate("theme");
            var window = new MainWindow { DataContext = vm, Width = 1080, Height = 820 };
            window.Show();
            Pump();

            Assert.Equal(Avalonia.Media.Color.Parse("#101820"), Assert.IsAssignableFrom<Avalonia.Media.ISolidColorBrush>(window.Background).Color);
            Assert.Equal(Avalonia.Media.Color.Parse("#E8E4D8"), BrushColor(window, "TextPrimaryBrush"));
            // Colours the file does not set, and the other variant, keep Filee's own.
            Assert.Equal(Avalonia.Media.Color.Parse("#AEACA4"), BrushColor(window, "TextSecondaryBrush"));
            Assert.Equal(Avalonia.Media.Color.Parse("#F6F5F1"), BrushColor(window, "PageBrush", Avalonia.Styling.ThemeVariant.Light));
            Save(window, "page-theme-custom.png");

            // Applying without a theme file (deleted, or emptied) restores the built-in colours on the open window.
            service.Apply(dark, "en");
            Pump();
            Assert.Equal(Avalonia.Media.Color.Parse("#1B1B19"), Assert.IsAssignableFrom<Avalonia.Media.ISolidColorBrush>(window.Background).Color);
            window.Close();

            service.Apply(dark, "en", custom);
            var radial = AppHost.Get<RadialViewModel>();
            radial.Load([@"C:\photos\a.jpg"], clickMode: true);
            var donut = new RadialWindow { DataContext = radial };
            donut.Show();
            donut.DonutControl.SetExternalHighlight(1);
            Pump();
            Assert.Equal(Avalonia.Media.Color.Parse("#18222C"), Assert.IsAssignableFrom<Avalonia.Media.ISolidColorBrush>(donut.DonutControl.SliceBrush).Color);
            Save(donut, "donut-custom-theme.png");
            donut.Close();
        }
        finally
        {
            service.Apply(new ThemeSettings(), "en");
        }
    }

    [Fact]
    public void Every_custom_theme_name_maps_to_a_brush()
    {
        Assert.Equal(CustomTheme.Keys.Order(), ThemeService.CustomBrushKeys.Keys.Order());
    }

    private static Avalonia.Media.Color BrushColor(Window window, string key, Avalonia.Styling.ThemeVariant? variant = null)
    {
        Assert.True(window.TryFindResource(key, variant ?? window.ActualThemeVariant, out var value), key);
        return Assert.IsAssignableFrom<Avalonia.Media.ISolidColorBrush>(value).Color;
    }

    [AvaloniaFact]
    public void Preset_popup_renders()
    {
        TestServices.EnsureInitialized("ko");
        var preset = AppHost.Get<UserDataStore>().FindPreset("jpg-70")!;
        var window = new PresetEditorWindow { DataContext = new PresetEditorViewModel(preset, AppHost.Get<Filee.Core.Localization.ILocalizer>()) };
        window.Show();
        Pump();

        Save(window, "preset-popup-ko.png");
        window.Close();
    }

    [AvaloniaFact]
    public void Preset_editor_shows_and_saves_rotation_and_flip()
    {
        TestServices.EnsureInitialized("ko");
        var preset = Filee.Core.Presets.BuiltInData.CreatePresets().Single(p => p.Id == "rotate-left");
        var vm = new PresetEditorViewModel(preset, AppHost.Get<Filee.Core.Localization.ILocalizer>());
        Assert.Equal(Filee.Core.Presets.ImageRotation.Left90, vm.Rotation.Value); // not a hidden option any more
        Assert.Equal(Filee.Core.Presets.ImageFlip.None, vm.Flip.Value);
        var window = new PresetEditorWindow { DataContext = vm, Height = 900 };
        window.Show();
        Pump();
        Save(window, "preset-rotate-ko.png");
        window.Close();

        // Rotate and convert in one: turn left, mirror, and make it a JPG.
        vm.Flip = vm.Flips.Single(f => f.Value == Filee.Core.Presets.ImageFlip.Horizontal);
        vm.Target = vm.Targets.Single(t => t.Value == "jpg");
        Assert.True(vm.Apply());

        Assert.Equal(Filee.Core.Presets.ImageRotation.Left90, preset.Image.Rotation);
        Assert.Equal(Filee.Core.Presets.ImageFlip.Horizontal, preset.Image.Flip);
        Assert.Equal("jpg", preset.TargetFormat);
    }

    [AvaloniaTheory]
    [InlineData("en")]
    [InlineData("de")]
    [InlineData("ru")]
    public void Custom_resize_shows_its_fields_and_never_writes_a_name_older_versions_reject(string language)
    {
        TestServices.EnsureInitialized(language);
        var loc = AppHost.Get<ILocalizer>();
        var preset = Filee.Core.Presets.BuiltInData.CreatePresets().Single(p => p.Id == "jpg-70");
        var vm = new PresetEditorViewModel(preset, loc);

        vm.Resize = vm.ResizeModes.Single(r => r.Value == Filee.Core.Presets.ResizeMode.Percent);
        Assert.False(vm.ShowCustom);

        var raised = new List<string>();
        vm.PropertyChanged += (_, e) => raised.Add(e.PropertyName!);
        vm.Resize = vm.ResizeModes.Single(r => r.Value == Filee.Core.Presets.ResizeMode.Custom);
        Assert.True(vm.ShowCustom);
        Assert.Contains(nameof(vm.ShowCustom), raised);   // the boxes appear without reopening the editor

        vm.CustomWidth = 777;
        vm.CustomHeight = 333;
        vm.LockAspect = true;
        var window = new PresetEditorWindow { DataContext = vm, Height = 900 };
        window.Show();
        Pump();
        Save(window, $"preset-custom-{language}.png");
        window.Close();

        Assert.True(vm.Apply());
        // Stored as customSize with resize None, so an older Filee keeps reading presets.json instead of treating it
        // as broken and overwriting the user's presets with the built-in ones (issue #576).
        Assert.Equal(Filee.Core.Presets.ResizeMode.None, preset.Image.Resize);
    }

    [AvaloniaFact]
    public void Custom_resize_stores_a_size_that_switching_the_mode_clears()
    {
        TestServices.EnsureInitialized("en");
        var loc = AppHost.Get<ILocalizer>();
        var preset = Filee.Core.Presets.BuiltInData.CreatePresets().Single(p => p.Id == "jpg-70");
        var vm = new PresetEditorViewModel(preset, loc);
        vm.Resize = vm.ResizeModes.Single(r => r.Value == Filee.Core.Presets.ResizeMode.Custom);
        vm.CustomWidth = 777;
        vm.CustomHeight = 333;
        vm.LockAspect = true;
        Assert.True(vm.Apply());
        Assert.NotNull(preset.Image.CustomSize);
        Assert.Equal((777, 333, true), (preset.Image.CustomSize!.Width, preset.Image.CustomSize!.Height, preset.Image.CustomSize.LockAspect));

        // Reads back as Custom, and switching the mode clears the custom size.
        var reloaded = new PresetEditorViewModel(preset, loc);
        Assert.Equal(Filee.Core.Presets.ResizeMode.Custom, reloaded.Resize.Value);
        Assert.Equal(333, reloaded.CustomHeight);
        vm.Resize = vm.ResizeModes.Single(r => r.Value == Filee.Core.Presets.ResizeMode.Percent);
        Assert.True(vm.Apply());
        Assert.Null(preset.Image.CustomSize);
        Assert.Equal(Filee.Core.Presets.ResizeMode.Percent, preset.Image.Resize);
    }

    [AvaloniaTheory]
    [InlineData("en", false)]
    [InlineData("en", true)]
    [InlineData("de", false)]
    [InlineData("de", true)]
    [InlineData("ar", false)]
    [InlineData("ar", true)]
    public void Min_short_edge_shows_its_field_and_never_writes_a_name_older_versions_reject(string language, bool dark)
    {
        TestServices.EnsureInitialized(language);
        var theme = AppHost.Get<ThemeService>();
        if (dark)
            theme.Apply(new ThemeSettings { Mode = ThemeMode.Dark }, language);
        try
        {
            var loc = AppHost.Get<ILocalizer>();
            var preset = Filee.Core.Presets.BuiltInData.CreatePresets().Single(p => p.Id == "jpg-70");
            var vm = new PresetEditorViewModel(preset, loc);
            Assert.False(vm.ShowMinShortEdge);

            var raised = new List<string>();
            vm.PropertyChanged += (_, e) => raised.Add(e.PropertyName!);
            vm.Resize = vm.ResizeModes.Single(r => r.Value == Filee.Core.Presets.ResizeMode.MinShortEdge);
            Assert.True(vm.ShowMinShortEdge);
            Assert.False(vm.ShowCustom);
            Assert.Contains(nameof(vm.ShowMinShortEdge), raised);   // the box appears without reopening the editor
            Assert.Equal(1080, vm.MinShortEdge);

            var window = new PresetEditorWindow { DataContext = vm, Height = 900 };
            window.Show();
            Pump();
            var box = window.GetVisualDescendants().OfType<NumericUpDown>()
                .Single(n => n.IsEffectivelyVisible && Avalonia.Automation.AutomationProperties.GetName(n) == loc["presets.min_short_edge"]);
            Assert.False(box.ShowButtonSpinner);
            box.BringIntoView();
            Pump();
            Save(window, $"preset-min-short-edge-{language}-{(dark ? "dark" : "light")}.png");
            window.Close();

            Assert.True(vm.Apply());
            // Stored as minShortEdge with resize None, so Filee 2.1.0 keeps reading presets.json (#652).
            Assert.Equal(Filee.Core.Presets.ResizeMode.None, preset.Image.Resize);
            Assert.Equal(1080, preset.Image.MinShortEdge);
        }
        finally
        {
            if (dark)
                theme.Apply(new ThemeSettings(), language);
        }
    }

    [AvaloniaFact]
    public void Min_short_edge_is_stored_clamped_and_switching_the_mode_clears_it()
    {
        TestServices.EnsureInitialized("en");
        var loc = AppHost.Get<ILocalizer>();
        var preset = Filee.Core.Presets.BuiltInData.CreatePresets().Single(p => p.Id == "jpg-70");
        var vm = new PresetEditorViewModel(preset, loc);
        vm.Resize = vm.ResizeModes.Single(r => r.Value == Filee.Core.Presets.ResizeMode.MinShortEdge);
        vm.MinShortEdge = 50000;
        Assert.True(vm.Apply());
        Assert.Equal(16384, preset.Image.MinShortEdge);
        Assert.Null(preset.Image.CustomSize);

        vm.MinShortEdge = 720;
        Assert.True(vm.Apply());
        var reloaded = new PresetEditorViewModel(preset, loc);
        Assert.Equal(Filee.Core.Presets.ResizeMode.MinShortEdge, reloaded.Resize.Value);
        Assert.Equal(720, reloaded.MinShortEdge);

        // Custom replaces it rather than leaving both behind...
        vm.Resize = vm.ResizeModes.Single(r => r.Value == Filee.Core.Presets.ResizeMode.Custom);
        Assert.True(vm.Apply());
        Assert.Null(preset.Image.MinShortEdge);
        Assert.NotNull(preset.Image.CustomSize);

        // ...and so does any other mode.
        vm.Resize = vm.ResizeModes.Single(r => r.Value == Filee.Core.Presets.ResizeMode.MinShortEdge);
        Assert.True(vm.Apply());
        Assert.Null(preset.Image.CustomSize);
        vm.Resize = vm.ResizeModes.Single(r => r.Value == Filee.Core.Presets.ResizeMode.Percent);
        Assert.True(vm.Apply());
        Assert.Null(preset.Image.MinShortEdge);
        Assert.Equal(Filee.Core.Presets.ResizeMode.Percent, preset.Image.Resize);

        // A minimum of 0 or below from a hand-edited file does nothing, so the editor shows the preset's own resize.
        preset.Image.MinShortEdge = -5;
        Assert.Equal(Filee.Core.Presets.ResizeMode.Percent, new PresetEditorViewModel(preset, loc).Resize.Value);
    }

    [AvaloniaTheory]
    [InlineData("en", false)]
    [InlineData("ru", false)]
    [InlineData("ar", true)]
    public void Preset_editor_offers_the_subfolder_only_for_several_files_with_a_subfolder(string language, bool dark)
    {
        TestServices.EnsureInitialized(language);
        var theme = AppHost.Get<ThemeService>();
        var loc = AppHost.Get<Filee.Core.Localization.ILocalizer>();
        // PDF → page images saves into a folder per document.
        var preset = Filee.Core.Presets.BuiltInData.CreatePresets().Single(p => p.Id == "pdf-split");
        var vm = new PresetEditorViewModel(preset, loc);
        Assert.True(vm.ShowSubfolder);
        Assert.False(vm.SubfolderOnlyForSeveralFiles);

        vm.SubfolderOnlyForSeveralFiles = true;
        if (dark)
            theme.Apply(new ThemeSettings { Mode = ThemeMode.Dark }, language);
        try
        {
            var window = new PresetEditorWindow { DataContext = vm, Height = 1400 };
            window.Show();
            Pump();
            Save(window, $"preset-subfolder-{language}{(dark ? "-dark" : "")}.png");
            window.Close();
        }
        finally
        {
            if (dark)
                theme.Apply(new ThemeSettings(), language);
        }
        Assert.True(vm.Apply());
        Assert.True(preset.Output.SubfolderOnlyForSeveralFiles);

        // Hidden with another location, and not kept on behind it.
        vm = new PresetEditorViewModel(preset, loc);
        Assert.True(vm.SubfolderOnlyForSeveralFiles);
        vm.Location = vm.Locations.Single(l => l.Value == Filee.Core.Presets.OutputLocation.SameFolder);
        Assert.False(vm.ShowSubfolder);
        Assert.True(vm.Apply());
        Assert.False(preset.Output.SubfolderOnlyForSeveralFiles);
    }

    [AvaloniaTheory]
    [InlineData("en")]
    [InlineData("ko")]
    [InlineData("pt-PT")]
    [InlineData("pt-BR")]
    public void Preset_editor_shows_and_saves_watermark_page_numbers_and_password(string language)
    {
        TestServices.EnsureInitialized(language);
        var loc = AppHost.Get<Filee.Core.Localization.ILocalizer>();
        var preset = Filee.Core.Presets.BuiltInData.CreatePresets().Single(p => p.Id == "merge-pdf");
        var vm = new PresetEditorViewModel(preset, loc);
        Assert.True(vm.ShowPdfBuild);
        vm.Watermark = "  DRAFT ";
        vm.PageNumbers = true;
        vm.PdfPassword = "1234";

        var window = new PresetEditorWindow { DataContext = vm, Height = 1400 };
        window.Show();
        Pump();
        Save(window, $"preset-pdf-finishing-{language}.png");
        window.Close();

        Assert.True(vm.Apply());
        Assert.Equal(("DRAFT", true, "1234"), (preset.Pdf.Watermark, preset.Pdf.PageNumbers, preset.Pdf.Password));
        Assert.True(preset.Pdf.FinishesPdf);

        // Not for other targets: nothing is kept behind them.
        vm = new PresetEditorViewModel(preset, loc);
        vm.Target = vm.Targets.Single(t => t.Value == "png");
        Assert.True(vm.Apply());
        Assert.False(preset.Pdf.FinishesPdf);
    }

    [AvaloniaFact]
    public void Preset_editor_password_fits_readers_and_is_off_with_pdfa()
    {
        TestServices.EnsureInitialized("en");
        var loc = AppHost.Get<Filee.Core.Localization.ILocalizer>();
        var preset = new Filee.Core.Presets.Preset { TargetFormat = "pdf", Name = "Locked" };
        var vm = new PresetEditorViewModel(preset, loc);

        // 54 Korean letters are 162 UTF-8 bytes; readers use 127, so the box keeps the 42 letters that fit.
        vm.PdfPassword = new string('비', 54);
        Assert.Equal(new string('비', 42), vm.PdfPassword);
        vm.PdfPassword = "pässwörd";
        Assert.Equal("pässwörd", vm.PdfPassword);

        vm.PdfA = true;
        Assert.True(vm.Apply());
        Assert.Equal("", preset.Pdf.Password); // PDF/A can't be encrypted
        vm.PdfA = false;
        Assert.True(vm.Apply());
        Assert.Equal("pässwörd", preset.Pdf.Password);
    }

    [AvaloniaTheory]
    [InlineData("en")]
    [InlineData("ko")]
    public void Preset_editor_shows_and_saves_text_recognition(string language)
    {
        TestServices.EnsureInitialized(language);
        var loc = AppHost.Get<Filee.Core.Localization.ILocalizer>();
        var preset = Filee.Core.Presets.BuiltInData.CreatePresets().Single(p => p.Id == "searchable-pdf");
        var vm = new PresetEditorViewModel(preset, loc);
        Assert.True(vm.ShowOcr);
        Assert.True(vm.Ocr);
        Assert.Equal("eng", vm.OcrLanguage.Value);
        Assert.Equal("eng", vm.OcrLanguageChoices[0].Value); // English first, the others by their own names
        // On a Mac Apple Vision reads the common languages, with nothing to download.
        Assert.Equal(loc[OperatingSystem.IsMacOS() ? "presets.ocr_hint_macos" : "presets.ocr_hint"], vm.OcrHint);
        if (OperatingSystem.IsMacOS())
            Assert.Null(vm.OcrLanguageChoices.Single(l => l.Value == "deu").Detail);

        var window = new PresetEditorWindow { DataContext = vm, Height = 1400 };
        window.Show();
        Pump();
        Save(window, $"preset-ocr-{language}.png");
        window.Close();

        // Scanned letters into Word, in German.
        vm.Target = vm.Targets.Single(t => t.Value == "docx");
        vm.OcrLanguage = vm.OcrLanguageChoices.Single(l => l.Value == "deu");
        Assert.Equal("Deutsch", vm.OcrLanguage.Label);
        Assert.True(vm.Apply());
        Assert.True(preset.Pdf.Ocr);
        Assert.Equal("deu", preset.Pdf.OcrLanguage);

        // Not for pictures: the box is hidden there, and not kept on behind it.
        vm = new PresetEditorViewModel(preset, loc);
        vm.Target = vm.Targets.Single(t => t.Value == "png");
        Assert.False(vm.ShowOcr);
        Assert.True(vm.Apply());
        Assert.False(preset.Pdf.Ocr);
    }

    [AvaloniaTheory]
    [InlineData("en")]
    [InlineData("ko")]
    [InlineData("pt-PT")]
    [InlineData("pt-BR")]
    public void Preset_editor_shows_and_saves_the_fits_options(string language)
    {
        TestServices.EnsureInitialized(language);
        var loc = AppHost.Get<Filee.Core.Localization.ILocalizer>();
        var preset = new Filee.Core.Presets.Preset { TargetFormat = "tiff", Name = "Astro TIFF" };
        var vm = new PresetEditorViewModel(preset, loc);
        // TIFF: linear (the default) or stretched; pictures: debayer (the default) or mono.
        Assert.True(vm.ShowFitsTiff);
        Assert.False(vm.ShowFitsDebayer);
        Assert.Equal(Filee.Core.Presets.FitsTiffMode.Linear, vm.FitsTiffMode.Value);
        Assert.Equal(loc["presets.fits_tiff.Stretched"], vm.FitsTiffModes[1].Label);

        var window = new PresetEditorWindow { DataContext = vm, Height = 1400 };
        window.Show();
        Pump();
        Save(window, $"preset-fits-tiff-{language}.png");
        window.Close();

        vm.FitsTiffMode = vm.FitsTiffModes.Single(m => m.Value == Filee.Core.Presets.FitsTiffMode.Stretched);
        Assert.True(vm.Apply());
        Assert.Equal(Filee.Core.Presets.FitsTiffMode.Stretched, preset.Image.FitsTiff);

        vm = new PresetEditorViewModel(preset, loc);
        vm.Target = vm.Targets.Single(t => t.Value == "png");
        Assert.False(vm.ShowFitsTiff);
        Assert.True(vm.ShowFitsDebayer);
        Assert.True(vm.FitsDebayer);
        vm.FitsDebayer = false;
        Assert.True(vm.Apply());
        Assert.False(preset.Image.FitsDebayer);

        // Neither is offered where no picture is written.
        vm.Target = vm.Targets.Single(t => t.Value == "pdf");
        Assert.False(vm.ShowFitsTiff || vm.ShowFitsDebayer);
    }

    [AvaloniaFact]
    public void Preset_editor_hides_and_clears_what_text_recognition_does_not_do()
    {
        TestServices.EnsureInitialized("en");
        var loc = AppHost.Get<Filee.Core.Localization.ILocalizer>();
        var preset = new Filee.Core.Presets.Preset
        {
            TargetFormat = "pdf",
            Name = "Scans",
            Pdf = { SplitPages = true, Compression = Filee.Core.Presets.PdfCompression.Screen, PageSize = Filee.Core.Presets.PdfPageSize.A4, MarginMm = 10 },
        };
        var vm = new PresetEditorViewModel(preset, loc);
        Assert.True(vm.ShowPdfSplit && vm.ShowPdfCompression && vm.ShowPageSize);

        vm.Ocr = true;

        Assert.False(vm.ShowPdfSplit);
        Assert.False(vm.ShowPdfCompression);
        Assert.False(vm.ShowPdfCompressionOptions);
        Assert.False(vm.ShowPageSize);
        Assert.True(vm.Apply());
        var pdf = preset.Pdf;
        Assert.True(pdf.Ocr);
        Assert.Equal((false, Filee.Core.Presets.PdfCompression.None, Filee.Core.Presets.PdfPageSize.FitImage, 0.0),
            (pdf.SplitPages, pdf.Compression, pdf.PageSize, pdf.MarginMm));

        // Without it they are back.
        vm.Ocr = false;
        Assert.True(vm.ShowPdfSplit && vm.ShowPdfCompression && vm.ShowPageSize);
    }

    [AvaloniaFact]
    public void Preset_editor_keeps_rotation_visible_for_pdf_and_drops_it_for_targets_that_cannot_turn()
    {
        TestServices.EnsureInitialized("en");
        var loc = AppHost.Get<Filee.Core.Localization.ILocalizer>();

        // Photos → PDF are turned on the pages: the PDF card shows the rotation, and it is kept.
        var toPdf = Filee.Core.Presets.BuiltInData.CreatePresets().Single(p => p.Id == "rotate-left");
        var vm = new PresetEditorViewModel(toPdf, loc);
        vm.Target = vm.Targets.Single(t => t.Value == "pdf");
        Assert.False(vm.ShowImage);
        Assert.True(vm.ShowTurnForPdf);
        Assert.True(vm.Apply());
        Assert.Equal(Filee.Core.Presets.ImageRotation.Left90, toPdf.Image.Rotation);

        // A video can't be turned: a rotation left from the image target would fail every file with nothing on screen.
        var toVideo = Filee.Core.Presets.BuiltInData.CreatePresets().Single(p => p.Id == "rotate-left");
        vm = new PresetEditorViewModel(toVideo, loc);
        vm.Flip = vm.Flips.Single(f => f.Value == Filee.Core.Presets.ImageFlip.Vertical);
        vm.Target = vm.Targets.Single(t => t.Value == "mp4");
        Assert.False(vm.ShowTurnForPdf);
        Assert.True(vm.Apply());
        Assert.Equal(Filee.Core.Presets.ImageRotation.None, toVideo.Image.Rotation);
        Assert.Equal(Filee.Core.Presets.ImageFlip.None, toVideo.Image.Flip);
    }

    [AvaloniaFact]
    public void Preset_editor_saves_every_frame_only_for_png_and_jpg()
    {
        TestServices.EnsureInitialized("en");
        var loc = AppHost.Get<Filee.Core.Localization.ILocalizer>();

        var preset = new Filee.Core.Presets.Preset { TargetFormat = "jpg" };
        var vm = new PresetEditorViewModel(preset, loc);
        Assert.True(vm.ShowSaveEveryFrame);
        vm.SaveEveryFrame = true;
        vm.FrameInterval = 5;
        Assert.Equal("One minute of 30 fps video gives 360 pictures, at most 100,000 per video.", vm.FrameEstimate);
        vm.FrameInterval = 5000; // out of range: clamped
        Assert.True(vm.Apply());
        Assert.True(preset.Media.SaveEveryFrame);
        Assert.Equal(1000, preset.Media.FrameInterval);

        // Ticked, then another target: nothing on screen says so any more, so it isn't saved.
        vm = new PresetEditorViewModel(preset, loc);
        Assert.True(vm.SaveEveryFrame);
        vm.Target = vm.Targets.Single(t => t.Value == "webp");
        Assert.False(vm.ShowSaveEveryFrame);
        Assert.True(vm.Apply());
        Assert.False(preset.Media.SaveEveryFrame);
        Assert.Equal(1, preset.Media.FrameInterval);
    }

    [AvaloniaFact]
    public void Preset_editor_shows_playback_speed_only_for_targets_that_keep_animations()
    {
        TestServices.EnsureInitialized("ko");
        var loc = AppHost.Get<Filee.Core.Localization.ILocalizer>();
        var preset = new Filee.Core.Presets.Preset { TargetFormat = "gif", Name = "Slow GIF" };
        var vm = new PresetEditorViewModel(preset, loc);
        Assert.True(vm.ShowAnimationSpeed);
        Assert.Equal(1, vm.AnimationSpeed.Value);
        Assert.Equal(["0.25×", "0.5×", "0.75×", "1× (원본)", "1.5×", "2×", "4×"], vm.AnimationSpeeds.Select(s => s.Label));
        vm.AnimationSpeed = vm.AnimationSpeeds.Single(s => s.Value == 0.5);
        var window = new PresetEditorWindow { DataContext = vm, Height = 900 };
        window.Show();
        Pump();
        Save(window, "preset-animation-speed-ko.png");
        window.Close();

        foreach (var target in new[] { "webp", "apng", "mng", Filee.Core.Presets.BuiltInData.SameAsSource })
        {
            vm.Target = vm.Targets.Single(t => t.Value == target);
            Assert.True(vm.ShowAnimationSpeed, target);
        }
        vm.Target = vm.Targets.Single(t => t.Value == "gif");
        vm.AnimationSpeed = null!; // the combo box clearing its selection keeps the value
        Assert.Equal(0.5, vm.AnimationSpeed.Value);
        Assert.True(vm.Apply());
        Assert.Equal(0.5, preset.Image.AnimationSpeed);

        // A speed set for GIF and left behind by a still target isn't saved: nothing on screen would say so.
        vm = new PresetEditorViewModel(preset, loc);
        Assert.Equal(0.5, vm.AnimationSpeed.Value);
        foreach (var target in new[] { "png", "jpg", "mp4", "pdf" })
        {
            vm.Target = vm.Targets.Single(t => t.Value == target);
            Assert.False(vm.ShowAnimationSpeed, target);
        }
        Assert.True(vm.Apply());
        Assert.Equal(1, preset.Image.AnimationSpeed);

        // A speed set outside the editor is offered instead of being lost.
        preset.TargetFormat = "webp";
        preset.Image.AnimationSpeed = 3;
        Assert.Equal("3×", new PresetEditorViewModel(preset, loc).AnimationSpeed.Label);
    }

    [AvaloniaFact]
    public void Preset_editor_shows_and_saves_background_removal()
    {
        TestServices.EnsureInitialized("ko");
        var preset = Filee.Core.Presets.BuiltInData.CreatePresets().Single(p => p.Id == "remove-background");
        var vm = new PresetEditorViewModel(preset, AppHost.Get<Filee.Core.Localization.ILocalizer>());
        Assert.True(vm.RemoveBackground);
        Assert.Equal(25, vm.BackgroundTolerance);
        var window = new PresetEditorWindow { DataContext = vm, Height = 900 };
        window.Show();
        Pump();
        Save(window, "preset-remove-background-ko.png");
        window.Close();

        vm.BackgroundTolerance = 140; // out of range: clamped
        vm.KeepEnclosedBackground = true;
        Assert.True(vm.Apply());

        Assert.True(preset.Image.RemoveBackground);
        Assert.Equal(100, preset.Image.BackgroundTolerance);
        Assert.True(preset.Image.KeepEnclosedBackground);
    }

    [AvaloniaFact]
    public void Preset_editor_shows_and_saves_pdf_compression()
    {
        TestServices.EnsureInitialized("ko");
        var preset = Filee.Core.Presets.BuiltInData.CreatePresets().Single(p => p.Id == "compress-pdf");
        var vm = new PresetEditorViewModel(preset, AppHost.Get<Filee.Core.Localization.ILocalizer>());
        Assert.True(vm.ShowPdfCompression);
        Assert.True(vm.ShowPdfCompressionOptions);
        Assert.Equal(Filee.Core.Presets.PdfCompression.Ebook, vm.CompressionLevel.Value);
        Assert.Equal(["None", "Screen", "Ebook", "Print"], vm.CompressionLevels.Select(c => c.Value.ToString()));
        var window = new PresetEditorWindow { DataContext = vm, Height = 900 };
        window.Show();
        Pump();
        Save(window, "preset-compress-pdf-ko.png");
        window.Close();

        vm.CompressionLevel = vm.CompressionLevels.Single(c => c.Value == Filee.Core.Presets.PdfCompression.Screen);
        vm.CompressWithGhostscript = true;
        vm.KeepMetadata = false;
        Assert.True(vm.Apply());
        Assert.Equal(Filee.Core.Presets.PdfCompression.Screen, preset.Pdf.Compression);
        Assert.True(preset.Pdf.CompressWithGhostscript);
        Assert.False(preset.Image.KeepMetadata);

        // Off: Ghostscript and metadata have nothing to do. Other targets don't compress PDFs at all.
        vm.CompressionLevel = vm.CompressionLevels[0];
        Assert.False(vm.ShowPdfCompressionOptions);
        vm.Target = vm.Targets.Single(t => t.Value == "png");
        Assert.False(vm.ShowPdfCompression);
    }

    [AvaloniaTheory]
    [InlineData("en")]
    [InlineData("ja")]
    [InlineData("ko")]
    [InlineData("ru")]
    [InlineData("ar")]
    public void Sidebar_shows_the_version_and_a_new_release(string language)
    {
        TestServices.EnsureInitialized(language);
        var updates = AppHost.Get<UpdateService>();
        using var vm = new MainWindowViewModel(AppHost.Services, AppHost.Get<Filee.Core.Localization.ILocalizer>(), updates, AppHost.Get<UserDataStore>());
        var window = new MainWindow { DataContext = vm, Width = 1080, Height = 820 };
        window.Show();
        Pump();
        var button = window.FindControl<Button>("UpdateButton")!;
        var version = window.FindControl<TextBlock>("VersionLabel")!;
        Assert.False(button.IsVisible);
        Assert.Contains(UpdateService.CurrentVersion, version.Text);

        try
        {
            updates.Notes = [ReleaseNotes.Parse("9.9.9", """
                <!-- update
                level: recommended
                ko: 엑셀에서 정한 페이지 나누기가 PDF에 반영돼요
                ko: 한글 문서의 보기 상자와 수식이 PDF에서 제대로 나와요
                en: Excel page breaks carry over to PDF
                en: Boxes and equations of 한글 documents come out right in PDFs
                zh: Excel 中设置的分页符会保留到 PDF 中
                zh: 韩文 Hangul 文档中的框和公式在 PDF 中正确显示
                -->
                """)];
            updates.LatestVersion = "9.9.9";
            Pump();
            Assert.True(button.IsVisible);
            Assert.Contains("9.9.9", vm.UpdateText);
            Save(window, $"sidebar-update-{language}.png");

            var loc = AppHost.Get<Filee.Core.Localization.ILocalizer>();
            var notice = new UpdateNoticeWindow(updates, loc, loc.Format("update.notice_title", "9.9.9"));
            notice.Show();
            Pump();
            Save(notice, $"update-notice-{language}.png");

            // A required update: red pill on the card and in the sidebar; an optional one: plain button, grey pill.
            updates.Notes = [ReleaseNotes.Parse("9.9.9", """
                <!-- update
                level: required
                ko: 변환 결과가 잘못 나오던 문제를 고쳤어요
                en: Fixes wrong conversion results
                zh: 修复了转换结果错误的问题
                -->
                """)];
            Pump();
            Save(notice, $"update-notice-required-{language}.png");
            Save(window, $"sidebar-update-required-{language}.png");
            updates.Notes = [ReleaseNotes.Parse("9.9.9", "<!-- update\nlevel: optional\nko: 새 기능\nen: A new feature\n-->")];
            Pump();
            Save(window, $"sidebar-update-optional-{language}.png");

            // While the installer downloads, the card, the sidebar button and the tray show the progress.
            updates.Step = UpdateStep.Downloading;
            updates.DownloadPercent = 42;
            Pump();
            Assert.Contains("42", vm.UpdateText);
            Save(notice, $"update-notice-downloading-{language}.png");
            Save(window, $"sidebar-update-downloading-{language}.png");
            updates.Step = UpdateStep.Idle;
            notice.Close();

            var feedback = new FeedbackNoticeWindow();
            feedback.Show();
            Pump();
            Save(feedback, $"feedback-notice-{language}.png");
            feedback.Close();
        }
        finally
        {
            updates.Step = UpdateStep.Idle;
            updates.LatestVersion = null;
            updates.Notes = [];
            window.Close();
        }
    }

    /// <summary>
    /// The extension chips of a profile that shares extensions with "Images" (warning chips), has one Filee doesn't
    /// know (muted chip) and shows suggestions for what is being typed (dark: a refused duplicate instead).
    /// </summary>
    [AvaloniaTheory]
    [InlineData("en", false)]
    [InlineData("ko", false)]
    [InlineData("zh-CN", false)]
    [InlineData("en", true)]
    [InlineData("ko", true)]
    [InlineData("ru", false)]
    [InlineData("ar", true)]
    public void Toolbar_extension_editor_renders(string language, bool dark)
    {
        var photos = new ToolbarProfile
        {
            Id = "render-photos",
            Name = language == "ko" ? "사진" : "Photos",
            Extensions = ["jpg", "png", "heic", "dng", "webp", "xyz"],
            PresetIds = ["to-jpg", "to-webp", "half-size", "to-pdf"],
        };
        WithProfiles(language, dark, 1240, profiles => profiles.Insert(profiles.FindIndex(p => p.IsFallback), photos), (window, vm) =>
        {
            vm.SelectedProfile = vm.Profiles.Single(p => p.Profile == photos);
            Pump();
            var editor = window.GetVisualDescendants().OfType<TagEditor>().Single();
            editor.FocusInput();
            Pump();
            if (dark)
            {
                window.KeyTextInput("PNG");
                window.KeyPress(Key.Enter, RawInputModifiers.None, PhysicalKey.None, null);
                Assert.NotNull(vm.ExtensionTags!.InputError);
            }
            else
            {
                window.KeyTextInput("we");
                Pump();
                Assert.True(editor.IsSuggestionListOpen);
            }
            Pump();

            Assert.Equal(6, vm.ExtensionTags!.Tags.Count);
            Assert.Equal(2, vm.ExtensionTags.Notes.Count); // shared with "Images" + unknown
            Save(window, $"toolbar-extensions-{language}{(dark ? "-dark" : "")}.png");
        });
    }

    /// <summary>
    /// #522: the profile list's Move up / Move down arrows beside "New profile", the hint under them, and the remark under
    /// the chips before and after a new profile with .jpg moves above "Images".
    /// </summary>
    [AvaloniaTheory]
    [InlineData("en", false)]
    [InlineData("en", true)]
    [InlineData("de", false)]
    [InlineData("de", true)]
    [InlineData("ar", false)]
    [InlineData("ar", true)]
    public void Toolbar_profile_order_renders(string language, bool dark)
    {
        var photos = new ToolbarProfile
        {
            Id = "render-photos",
            Name = language == "de" ? "Fotos" : language == "ar" ? "صوري" : "Photos",
            Extensions = ["jpg", "heic"],
            PresetIds = ["to-jpg", "to-webp", "half-size", "to-pdf"],
        };
        WithProfiles(language, dark, 1240, profiles => profiles.Insert(profiles.FindIndex(p => p.IsFallback), photos), (window, vm) =>
        {
            var item = vm.Profiles.Single(p => p.Profile == photos);
            vm.SelectedProfile = item;
            Pump();
            var up = window.GetVisualDescendants().OfType<Button>().Single(b => b.Name == "MoveProfileUp");
            var down = window.GetVisualDescendants().OfType<Button>().Single(b => b.Name == "MoveProfileDown");
            var hint = window.GetVisualDescendants().OfType<TextBlock>().Single(t => t.Name == "ProfileOrderHint");
            Assert.True(up.IsEffectivelyEnabled);
            Assert.False(down.IsEffectivelyEnabled); // the last normal profile
            Assert.True(hint.IsEffectivelyVisible && hint.Bounds.Height > 0);
            // The arrows sit between the list and "New profile", which keeps the column's width and shows its whole name.
            var list = window.GetVisualDescendants().OfType<ListBox>().Single(l => l.Name == "ProfileList");
            var add = window.GetVisualDescendants().OfType<Button>().Single(b => b.Command == vm.AddProfileCommand);
            var name = add.GetVisualDescendants().OfType<TextBlock>().Single();
            Assert.Equal(list.Bounds.Width, add.Bounds.Width, 0.5);
            Assert.True(name.DesiredSize.Width <= add.Bounds.Width - 30, $"{name.DesiredSize.Width} in {add.Bounds.Width}");
            Assert.True(Avalonia.VisualExtensions.TranslatePoint(up, default, list)!.Value.Y > list.Bounds.Height - 1);
            Assert.True(Avalonia.VisualExtensions.TranslatePoint(add, default, up)!.Value.Y > up.Bounds.Height - 1);
            Assert.Contains(vm.ExtensionTags!.Notes, n => n.IsWarning);
            Save(window, $"toolbar-profile-order-before-{language}{(dark ? "-dark" : "")}.png");

            vm.ProfileSearch = "jpg";
            Pump();
            vm.MoveProfileUpCommand.Execute(null);
            vm.ProfileSearch = "";
            Pump();
            var store = AppHost.Get<UserDataStore>();
            Assert.Equal(store.Profiles.FindIndex(p => p.Id == "images") - 1, store.Profiles.IndexOf(photos));
            Assert.Same(item, vm.SelectedProfile);
            Assert.True(down.IsEffectivelyEnabled);
            Save(window, $"toolbar-profile-order-after-{language}{(dark ? "-dark" : "")}.png");
        });
    }

    /// <summary>A second mixed-selection donut limited to images and PDF, two groups expanded.</summary>
    [AvaloniaTheory]
    [InlineData("en", false, "render-scans")]
    [InlineData("ko", false, "render-scans")]
    [InlineData("zh-CN", false, "render-scans")]
    [InlineData("ko", true, "render-scans")]
    [InlineData("en", false, "mixed")]
    [InlineData("en", true, "mixed")]
    public void Toolbar_mixed_selection_editor_renders(string language, bool dark, string profileId)
    {
        var scans = new ToolbarProfile
        {
            Id = "render-scans",
            Name = language == "ko" ? "스캔 모음" : "Scans",
            IsFallback = true,
            Extensions = ["jpg", "png", "tiff", "pdf"],
            PresetIds = ["to-pdf", "merge-pdf", "zip-all"],
        };
        WithProfiles(language, dark, 1600, profiles => profiles.Add(scans), (window, vm) =>
        {
            vm.SelectedProfile = vm.Profiles.Single(p => p.Profile.Id == profileId);
            Pump();
            var mixed = vm.MixedExtensions!;
            if (profileId != "mixed")
                mixed.Groups[0].IsExpanded = true; // Images: partly checked, many chips
            mixed.Groups[1].IsExpanded = true; // PDF: all checked (Scans)
            Pump();

            Assert.True(vm.IsMixed);
            Assert.Null(vm.ExtensionTags);
            Assert.Equal(profileId == "mixed" ? false : null, mixed.Groups[0].State);
            Assert.True(vm.CanDelete); // two mixed profiles: either may go
            Save(window, $"toolbar-mixed-{profileId.Replace("render-", "")}-{language}{(dark ? "-dark" : "")}.png");
        });
    }

    /// <summary>The preset popup with the video/audio and archive sections, and the target list.</summary>
    [AvaloniaTheory]
    [InlineData("en", false)]
    [InlineData("ko", false)]
    [InlineData("zh-CN", false)]
    [InlineData("ko", true)]
    [InlineData("ru", false)]
    [InlineData("ar", true)]
    [InlineData("pt-BR", false)]
    [InlineData("fr", false)]
    public void Preset_editor_shows_media_and_archive_options(string language, bool dark)
    {
        TestServices.EnsureInitialized(language);
        var theme = AppHost.Get<ThemeService>();
        if (dark)
            theme.Apply(new ThemeSettings { Mode = ThemeMode.Dark }, language);
        try
        {
            var store = AppHost.Get<UserDataStore>();
            var loc = AppHost.Get<ILocalizer>();
            var suffix = $"{language}{(dark ? "-dark" : "")}";

            var media = new PresetEditorViewModel(store.FindPreset("mp4-720")!, loc);
            Assert.True(media.ShowMedia && media.ShowMaxHeight && media.ShowRemoveAudio);
            Assert.False(media.ShowPdf || media.ShowImage || media.ShowArchive);
            Assert.Equal(720, media.MaxHeight.Value);
            var window = new PresetEditorWindow { DataContext = media, Height = 900 };
            window.Show();
            Pump();
            Save(window, $"preset-media-{suffix}.png");

            // The target list: categories next to the names. (Headless popups live in the window's overlay layer,
            // so the open list is part of the window's frame.)
            var box = window.GetVisualDescendants().OfType<ComboBox>().First(c => c.Name == "TargetBox");
            box.IsDropDownOpen = true;
            Pump();
            Assert.True(box.GetVisualDescendants().OfType<Popup>().Single().IsOpen);
            Save(window, $"preset-targets-{suffix}.png");
            box.IsDropDownOpen = false;
            window.Close();

            // HEVC preset: the codec choice next to the other video options.
            var hevc = new PresetEditorViewModel(store.FindPreset("mp4-hevc")!, loc);
            Assert.True(hevc.ShowVideoCodec && !hevc.ShowAudioCodec);
            Assert.Equal(Filee.Core.Presets.VideoCodec.Hevc, hevc.VideoCodecChoice.Value);
            window = new PresetEditorWindow { DataContext = hevc, Height = 900 };
            window.Show();
            Pump();
            Save(window, $"preset-codec-{suffix}.png");
            window.Close();

            var archive = new PresetEditorViewModel(store.FindPreset("zip-all")!, loc);
            Assert.True(archive.ShowArchive && archive.ShowArchiveOptions && archive.CombineIntoOne);
            Assert.False(archive.ShowMedia || archive.ShowPdf);
            window = new PresetEditorWindow { DataContext = archive, Height = 760 };
            window.Show();
            Pump();
            Save(window, $"preset-archive-{suffix}.png");
            window.Close();

            // Audio targets have no picture options; lossless ones only channels, WAV also sample rate and bit depth (#37);
            // AMR is fixed mono 8 kHz; "Extract" only explains.
            archive.Target = archive.Targets.Single(t => t.Value == "mp3");
            Assert.True(archive.ShowMedia && archive.ShowAudioBitrate && archive.ShowAudioChannels && !archive.ShowMaxHeight && !archive.ShowRemoveAudio);
            Assert.False(archive.ShowWav);
            archive.Target = archive.Targets.Single(t => t.Value == "flac");
            Assert.True(archive.ShowMedia && archive.ShowAudioChannels && !archive.ShowAudioBitrate && !archive.ShowWav);
            archive.Target = archive.Targets.Single(t => t.Value == "wav");
            Assert.True(archive.ShowMedia && archive.ShowAudioChannels && archive.ShowWav);
            window = new PresetEditorWindow { DataContext = archive, Height = 760 };
            window.Show();
            Pump();
            Save(window, $"preset-wav-{suffix}.png");
            window.Close();
            archive.Target = archive.Targets.Single(t => t.Value == "amr");
            Assert.False(archive.ShowAudioChannels || archive.ShowWav);
            archive.Target = archive.Targets.Single(t => t.Value == Filee.Core.Formats.FormatRegistry.Folder);
            Assert.True(archive.ShowArchive && archive.ShowExtractNote && !archive.ShowArchiveOptions);
        }
        finally
        {
            if (dark)
                theme.Apply(new ThemeSettings(), language);
        }
    }

    /// <summary>The preset popup of "Trace to SVG": mode, colours and detail; colours only in colour mode.</summary>
    [AvaloniaTheory]
    [InlineData("en")]
    [InlineData("ja")]
    [InlineData("ko")]
    [InlineData("zh-CN")]
    [InlineData("ru")]
    [InlineData("ar")]
    public void Preset_editor_shows_tracing_options(string language)
    {
        TestServices.EnsureInitialized(language);
        var store = AppHost.Get<UserDataStore>();
        var vm = new PresetEditorViewModel(store.FindPreset("trace-svg")!.Clone(), AppHost.Get<ILocalizer>());
        Assert.True(vm.ShowTrace && vm.ShowTraceColors);
        Assert.False(vm.ShowImage || vm.ShowMedia || vm.ShowArchive);

        var window = new PresetEditorWindow { DataContext = vm, Height = 760 };
        window.Show();
        Pump();
        Assert.True(window.GetVisualDescendants().OfType<Border>().Single(b => b.Name == "TraceCard").IsVisible);
        Save(window, $"preset-trace-{language}.png");
        window.Close();

        vm.TraceMode = vm.TraceModes.Single(m => m.Value == Filee.Core.Presets.TracingMode.BlackAndWhite);
        Assert.False(vm.ShowTraceColors);
        vm.Target = vm.Targets.Single(t => t.Value == "dxf");
        Assert.True(vm.ShowTrace);
        vm.Target = vm.Targets.Single(t => t.Value == "png");
        Assert.False(vm.ShowTrace);
    }

    [AvaloniaFact]
    public void Preset_editor_saves_tracing_options()
    {
        TestServices.EnsureInitialized("en");
        var preset = new Filee.Core.Presets.Preset { TargetFormat = "svg", Name = "Logo" };
        var vm = new PresetEditorViewModel(preset, AppHost.Get<ILocalizer>());
        Assert.Equal(["Colour", "Black and white (line art)"], vm.TraceModes.Select(m => m.Label));

        vm.TraceMode = vm.TraceModes.Single(m => m.Value == Filee.Core.Presets.TracingMode.BlackAndWhite);
        vm.TraceColors = 200;
        vm.TraceDetail = 80;
        Assert.True(vm.Apply());

        Assert.Equal((Filee.Core.Presets.TracingMode.BlackAndWhite, 64, 80), (preset.Trace.Mode, preset.Trace.Colors, preset.Trace.Detail));
    }

    [AvaloniaTheory]
    [InlineData("en")]
    [InlineData("ja")]
    [InlineData("ko")]
    [InlineData("zh-CN")]
    [InlineData("ru")]
    [InlineData("ar")]
    public void Preset_editor_offers_markdown_without_pictures(string language)
    {
        TestServices.EnsureInitialized(language);
        var store = AppHost.Get<UserDataStore>();
        var preset = store.FindPreset("to-md")!.Clone();
        var vm = new PresetEditorViewModel(preset, AppHost.Get<ILocalizer>());
        Assert.True(vm.ShowLeaveOutPictures);
        Assert.False(vm.LeaveOutPictures);

        var window = new PresetEditorWindow { DataContext = vm, Height = 760 };
        window.Show();
        Pump();
        Assert.True(window.GetVisualDescendants().OfType<Border>().Single(b => b.Name == "DocumentCard").IsVisible);
        Save(window, $"preset-markdown-{language}.png");
        window.Close();

        vm.LeaveOutPictures = true;
        Assert.True(vm.Apply());
        Assert.True(preset.Document.LeaveOutPictures);

        // Other targets don't show it, and don't keep it.
        vm.Target = vm.Targets.Single(t => t.Value == "docx");
        Assert.False(vm.ShowLeaveOutPictures);
        Assert.True(vm.Apply());
        Assert.False(preset.Document.LeaveOutPictures);
    }

    [AvaloniaFact]
    public void Preset_editor_offers_the_autocad_version_for_dwg_and_dxf_only()
    {
        TestServices.EnsureInitialized("en");
        var preset = new Filee.Core.Presets.Preset { TargetFormat = "dwg", Name = "Old DWG" };
        var vm = new PresetEditorViewModel(preset, AppHost.Get<ILocalizer>());
        Assert.True(vm.ShowCad);
        Assert.False(vm.ShowCadColors); // DWG to DWG draws nothing
        Assert.Equal(["AutoCAD 2018", "AutoCAD 2013", "AutoCAD 2010", "AutoCAD 2007", "AutoCAD 2004", "AutoCAD 2000", "Same as the source"],
            vm.CadVersions.Select(v => v.Label));

        vm.CadVersion = vm.CadVersions.Single(v => v.Value == Filee.Core.Presets.CadVersion.AutoCad2004);
        Assert.True(vm.Apply());
        Assert.Equal(Filee.Core.Presets.CadVersion.AutoCad2004, preset.Cad.Version);
        Assert.Equal(Filee.Core.Presets.CadVersion.AutoCad2004, new PresetEditorViewModel(preset, AppHost.Get<ILocalizer>()).CadVersion.Value);

        // Not for other targets: the choice isn't kept behind them.
        vm.Target = vm.Targets.Single(t => t.Value == "png");
        Assert.False(vm.ShowCad);
        Assert.True(vm.Apply());
        Assert.Equal(Filee.Core.Presets.CadVersion.AutoCad2018, preset.Cad.Version);
    }

    [AvaloniaTheory]
    [InlineData("en", false)]
    [InlineData("en", true)]
    [InlineData("de", false)]
    [InlineData("de", true)]
    [InlineData("ar", false)]
    [InlineData("ar", true)]
    public void Preset_editor_offers_cad_colours_for_drawings_made_into_pdf_svg_and_pictures(string language, bool dark)
    {
        TestServices.EnsureInitialized(language);
        var theme = AppHost.Get<ThemeService>();
        var loc = AppHost.Get<ILocalizer>();
        var preset = AppHost.Get<UserDataStore>().FindPreset("to-pdf")!.Clone();
        var vm = new PresetEditorViewModel(preset, loc);
        Assert.True(vm.ShowCadColors);
        Assert.False(vm.ShowCad); // the AutoCAD version is for DWG and DXF
        Assert.Equal(Filee.Core.Presets.CadColors.AsDrawn, vm.CadColors.Value);
        Assert.Equal(Enum.GetValues<Filee.Core.Presets.CadColors>().Select(c => loc[$"presets.cad_colors.{c}"]), vm.CadColorChoices.Select(c => c.Label));

        vm.CadColors = vm.CadColorChoices.Single(c => c.Value == Filee.Core.Presets.CadColors.BlackAndWhite);
        if (dark)
            theme.Apply(new ThemeSettings { Mode = ThemeMode.Dark }, language);
        try
        {
            var window = new PresetEditorWindow { DataContext = vm, Height = 900 };
            window.Show();
            Pump();
            var card = window.GetVisualDescendants().OfType<Border>().Single(b => b.Name == "CadColorsCard");
            Assert.True(card.IsEffectivelyVisible);
            card.BringIntoView();
            Pump();
            Save(window, $"preset-cad-colours-{language}{(dark ? "-dark" : "")}.png");
            window.Close();
        }
        finally
        {
            if (dark)
                theme.Apply(new ThemeSettings(), language);
        }
        Assert.True(vm.Apply());
        Assert.Equal(Filee.Core.Presets.CadColors.BlackAndWhite, preset.Cad.Colors);
        Assert.Equal(Filee.Core.Presets.CadColors.BlackAndWhite, new PresetEditorViewModel(preset, loc).CadColors.Value);

        // SVG and pictures take it too; DWG and Markdown don't show it, and don't keep it.
        foreach (var target in (string[])["svg", "png", "jpg", "tiff"])
        {
            vm.Target = vm.Targets.Single(t => t.Value == target);
            Assert.True(vm.ShowCadColors, target);
        }
        vm.Target = vm.Targets.Single(t => t.Value == "dwg");
        Assert.False(vm.ShowCadColors);
        Assert.True(vm.Apply());
        Assert.Equal(Filee.Core.Presets.CadColors.AsDrawn, preset.Cad.Colors);
        vm.Target = vm.Targets.Single(t => t.Value == "md");
        Assert.False(vm.ShowCadColors);
    }

    [AvaloniaFact]
    public void Preset_editor_offers_save_as_zip_for_geospatial_targets_only()
    {
        TestServices.EnsureInitialized("en");
        var preset = new Filee.Core.Presets.Preset { TargetFormat = "shp", Name = "Shapefile" };
        var vm = new PresetEditorViewModel(preset, AppHost.Get<ILocalizer>());
        Assert.True(vm.ShowZipResult);
        Assert.Equal("Geospatial", vm.Target.Detail);

        vm.ZipResult = true;
        Assert.True(vm.Apply());
        Assert.True(preset.Output.ZipResult);

        vm.Target = vm.Targets.Single(t => t.Value == "kml");
        Assert.True(vm.ShowZipResult);
        vm.Target = vm.Targets.Single(t => t.Value == "png");
        Assert.False(vm.ShowZipResult);
        // The box ticked for Shapefile, hidden for PNG, doesn't zip the PNG.
        Assert.True(vm.Apply());
        Assert.False(preset.Output.ZipResult);
    }

    [AvaloniaFact]
    public void Preset_editor_saves_replace_the_original_off_by_default()
    {
        TestServices.EnsureInitialized("en");
        var preset = new Filee.Core.Presets.Preset { TargetFormat = Filee.Core.Presets.BuiltInData.SameAsSource, Name = "Trim" };
        var vm = new PresetEditorViewModel(preset, AppHost.Get<ILocalizer>());
        Assert.False(vm.ReplaceOriginal);

        vm.ReplaceOriginal = true;
        Assert.True(vm.Apply());
        Assert.True(preset.Output.ReplaceOriginal);
        Assert.True(new PresetEditorViewModel(preset, AppHost.Get<ILocalizer>()).ReplaceOriginal);
        Assert.Contains("Recycle Bin / Trash", AppHost.Get<ILocalizer>()["presets.replace_original_hint"]);
    }

    [AvaloniaFact]
    public void Preset_editor_saves_media_and_archive_options()
    {
        TestServices.EnsureInitialized("en");
        var preset = new Filee.Core.Presets.Preset { TargetFormat = "mp4", Name = "Clip" };
        var vm = new PresetEditorViewModel(preset, AppHost.Get<ILocalizer>());
        Assert.Equal("*", vm.Targets[0].Value); // "Same as source" stays first
        Assert.Equal([0, 32, 48, 64, 96, 128, 192, 256, 320], vm.AudioBitrates.Select(b => b.Value)); // 32-64 for speech (#37)
        Assert.All(vm.Targets.Skip(1), t => Assert.True(Filee.Core.Formats.FormatRegistry.Get(t.Value).Writable));
        Assert.Equal("Video", vm.Target.Detail);

        vm.MediaQuality = vm.MediaQualities.Single(q => q.Value == Filee.Core.Presets.MediaQuality.Small);
        vm.MaxHeight = vm.MaxHeights.Single(h => h.Value == 1080);
        vm.AudioBitrate = vm.AudioBitrates.Single(b => b.Value == 192);
        vm.RemoveAudio = true;
        vm.AudioChannels = vm.AudioChannelChoices.Single(c => c.Value == 1);
        vm.SampleRate = vm.SampleRates.Single(r => r.Value == 16000);
        vm.WavFormat = vm.WavFormats.Single(f => f.Value == Filee.Core.Presets.WavSampleFormat.Pcm24);
        Assert.Equal("16 kHz", vm.SampleRate.Label);
        vm.ArchiveLevel = vm.ArchiveLevels.Single(l => l.Value == Filee.Core.Presets.ArchiveLevel.Maximum);
        vm.CombineIntoOne = true;
        Assert.True(vm.Apply());

        Assert.Equal(Filee.Core.Presets.MediaQuality.Small, preset.Media.Quality);
        Assert.Equal(1080, preset.Media.MaxHeight);
        Assert.Equal(192, preset.Media.AudioBitrateKbps);
        Assert.True(preset.Media.RemoveAudio);
        Assert.Equal((1, 16000, Filee.Core.Presets.WavSampleFormat.Pcm24),
            (preset.Media.AudioChannels, preset.Media.AudioSampleRate, preset.Media.WavFormat));
        Assert.Equal(Filee.Core.Presets.ArchiveLevel.Maximum, preset.Archive.Level);
        Assert.True(preset.Archive.CombineIntoOne);

        // A value set outside the editor is offered instead of being lost.
        preset.Media.MaxHeight = 600;
        Assert.Equal("600p", new PresetEditorViewModel(preset, AppHost.Get<ILocalizer>()).MaxHeight.Label);
    }

    [AvaloniaFact]
    public void Preset_editor_offers_hardware_encoding_for_h264_hevc_and_av1()
    {
        TestServices.EnsureInitialized("en");
        var preset = new Filee.Core.Presets.Preset { TargetFormat = "mp4", Name = "Fast" };
        var vm = new PresetEditorViewModel(preset, AppHost.Get<ILocalizer>());
        Assert.True(vm.ShowHardwareEncoding);
        Assert.False(vm.HardwareEncoding); // off unless asked for
        vm.HardwareEncoding = true;

        // HEVC and AV1 have a hardware path; VP9 (WebM's usual codec) has none.
        vm.VideoCodecChoice = vm.VideoCodecs.Single(c => c.Value == Filee.Core.Presets.VideoCodec.Av1);
        Assert.True(vm.ShowHardwareEncoding);
        vm.VideoCodecChoice = vm.VideoCodecs.Single(c => c.Value == Filee.Core.Presets.VideoCodec.Hevc);
        Assert.True(vm.ShowHardwareEncoding);
        vm.Target = vm.Targets.Single(t => t.Value == "webm");
        Assert.False(vm.ShowHardwareEncoding);
        vm.Target = vm.Targets.Single(t => t.Value == "avi");
        Assert.False(vm.ShowHardwareEncoding);
        vm.Target = vm.Targets.Single(t => t.Value == "mp3");
        Assert.False(vm.ShowHardwareEncoding);
        vm.Target = vm.Targets.Single(t => t.Value == "ts");
        Assert.True(vm.ShowHardwareEncoding);
        vm.Target = vm.Targets.Single(t => t.Value == "mov");
        Assert.True(vm.Apply());
        Assert.True(preset.Media.HardwareEncoding);
        Assert.Equal(Filee.Core.Presets.VideoCodec.Hevc, preset.Media.VideoCodec);

        Assert.True(new PresetEditorViewModel(preset, AppHost.Get<ILocalizer>()).HardwareEncoding);

        // WebM written as AV1 (the "MP4 AV1" kind of preset, in WebM) offers it too.
        var webm = new PresetEditorViewModel(new Filee.Core.Presets.Preset { TargetFormat = "webm", Name = "AV1" }, AppHost.Get<ILocalizer>());
        Assert.False(webm.ShowHardwareEncoding);
        webm.VideoCodecChoice = webm.VideoCodecs.Single(c => c.Value == Filee.Core.Presets.VideoCodec.Av1);
        Assert.True(webm.ShowHardwareEncoding);
    }

    [AvaloniaFact]
    public void Preset_editor_offers_the_codecs_each_target_can_hold()
    {
        TestServices.EnsureInitialized("en");
        var preset = new Filee.Core.Presets.Preset { TargetFormat = "mp4", Name = "Codec" };
        var vm = new PresetEditorViewModel(preset, AppHost.Get<ILocalizer>());
        Assert.True(vm.ShowVideoCodec && !vm.ShowAudioCodec);
        Assert.Equal([Filee.Core.Presets.VideoCodec.Default, Filee.Core.Presets.VideoCodec.Hevc, Filee.Core.Presets.VideoCodec.Av1],
            vm.VideoCodecs.Select(c => c.Value));
        Assert.StartsWith("H.264", vm.VideoCodecChoice.Label);
        vm.VideoCodecChoice = vm.VideoCodecs.Single(c => c.Value == Filee.Core.Presets.VideoCodec.Hevc);

        // WebM has no HEVC: its list is VP9 / AV1 and the choice shows as VP9; MKV takes HEVC again.
        vm.Target = vm.Targets.Single(t => t.Value == "webm");
        Assert.Equal(["VP9", "AV1 (smallest, slow)"], vm.VideoCodecs.Select(c => c.Label));
        Assert.Equal(Filee.Core.Presets.VideoCodec.Default, vm.VideoCodecChoice.Value);
        vm.Target = vm.Targets.Single(t => t.Value == "mkv");
        Assert.Equal(Filee.Core.Presets.VideoCodec.Hevc, vm.VideoCodecChoice.Value);
        vm.Target = vm.Targets.Single(t => t.Value == "avi");
        Assert.False(vm.ShowVideoCodec);

        // M4A: AAC or ALAC; ALAC is lossless, so quality and bitrate go away.
        vm.Target = vm.Targets.Single(t => t.Value == "m4a");
        Assert.True(vm.ShowAudioCodec && vm.ShowAudioBitrate && vm.ShowMediaQuality && !vm.ShowVideoCodec);
        vm.AudioCodecChoice = vm.AudioCodecs.Single(c => c.Value == Filee.Core.Presets.AudioCodec.Alac);
        Assert.False(vm.ShowAudioBitrate || vm.ShowMediaQuality);
        Assert.True(vm.ShowMedia && vm.ShowAudioChannels);
        Assert.True(vm.Apply());
        Assert.Equal((Filee.Core.Presets.VideoCodec.Default, Filee.Core.Presets.AudioCodec.Alac), (preset.Media.VideoCodec, preset.Media.AudioCodec));

        // New lossless targets and W64 (WAV options); subtitles have no media or PDF options.
        vm.Target = vm.Targets.Single(t => t.Value == "wv");
        Assert.False(vm.ShowAudioBitrate || vm.ShowAudioCodec);
        vm.Target = vm.Targets.Single(t => t.Value == "w64");
        Assert.True(vm.ShowWav);
        vm.Target = vm.Targets.Single(t => t.Value == "smi");
        Assert.False(vm.ShowMedia || vm.ShowPdf || vm.ShowImage);
        Assert.Equal("Subtitle", vm.Target.Detail);
    }

    /// <summary>The geospatial donut in the toolbar editor: GeoJSON, Shapefile, KML, CSV, GPX and KMZ for geo files.</summary>
    [AvaloniaTheory]
    [InlineData("en")]
    [InlineData("ko")]
    public void Toolbar_geospatial_donut_renders(string language)
    {
        WithProfiles(language, false, 1240, _ => { }, (window, vm) =>
        {
            vm.SelectedProfile = vm.Profiles.Single(p => p.Profile.Id == "geo");
            Pump();
            Assert.Equal(["to-geojson", "to-shp", "to-kml", "to-csv", "to-gpx", "to-kmz"], vm.SelectedProfile.Profile.PresetIds);
            Assert.Contains("shp", vm.ExtensionTags!.Tags.Select(t => t.Text.TrimStart('.')));
            Save(window, $"toolbar-geospatial-{language}.png");
        });
    }

    /// <summary>
    /// The palette tabs of the mixed donut (no extensions, so every kind and no judging) wrap inside the 230 px column:
    /// every tab whole, in rows, reachable with the arrow keys, the last one too.
    /// </summary>
    [AvaloniaTheory]
    [InlineData("en", false)]
    [InlineData("en", true)]
    [InlineData("ko", false)]
    [InlineData("ko", true)]
    [InlineData("es", false)]
    [InlineData("es", true)]
    [InlineData("ru", false)]
    [InlineData("ru", true)]
    public void Palette_tabs_fit_narrow_column(string language, bool dark)
    {
        WithProfiles(language, dark, 820, _ => { }, (window, vm) =>
        {
            vm.SelectedProfile = vm.Profiles.Single(p => p.Profile.Id == "mixed");
            Pump();
            Assert.Empty(vm.SelectedProfile.Profile.Extensions);
            var column = window.GetVisualDescendants().OfType<StackPanel>().Single(s => s.Name == "PaletteColumn");
            var tabs = window.GetVisualDescendants().OfType<ListBox>().Single(l => l.Name == "PaletteTabs");
            Assert.True(tabs.IsEffectivelyVisible);
            Assert.Equal(Enum.GetValues<PaletteTab>(), tabs.Items.Cast<PaletteTabItem>().Select(t => t.Id));

            Avalonia.Rect InWindow(Avalonia.Visual v) =>
                new Avalonia.Rect(v.Bounds.Size).TransformToAABB(Avalonia.VisualExtensions.TransformToVisual(v, window)!.Value);
            var columnBox = InWindow(column);
            var rowBox = InWindow(tabs);
            Assert.Equal(230, columnBox.Width, 0.5);
            var items = Enumerable.Range(0, tabs.ItemCount).Select(i => (ListBoxItem)tabs.ContainerFromIndex(i)!).ToList();
            var boxes = items.Select(InWindow).ToList();
            for (var i = 0; i < items.Count; i++)
            {
                var box = boxes[i];
                Assert.True(box.Left >= columnBox.Left - 0.5 && box.Right <= columnBox.Right + 0.5, $"tab {i} {box} outside {columnBox}");
                Assert.True(box.Top >= rowBox.Top - 0.5 && box.Bottom <= rowBox.Bottom + 0.5, $"tab {i} {box} outside {rowBox}");
                var text = items[i].GetVisualDescendants().OfType<TextBlock>().Single();
                Assert.Single(text.TextLayout.TextLines);
                Assert.True(text.TextLayout.WidthIncludingTrailingWhitespace <= text.Bounds.Width + 0.5, text.Text);
                if (i == 0)
                    continue;
                // Reading order: right of the previous tab on its row, or on a row below it.
                var previous = boxes[i - 1];
                Assert.True(Math.Abs(box.Top - previous.Top) < 0.5 ? box.Left >= previous.Right - 0.5 : box.Top >= previous.Bottom - 0.5,
                    $"tab {i} {box} overlaps or precedes {previous}");
            }
            Assert.True(boxes.Select(b => Math.Round(b.Top)).Distinct().Count() >= 2);
            var suffix = dark ? "dark" : "light";
            Save(window, $"toolbar-tabs-{language}-{suffix}.png");

            // Right along a row, Down at its end to the tab on the next row nearest below, up to the last tab.
            void Press(Key key, PhysicalKey physical)
            {
                window.KeyPress(key, RawInputModifiers.None, physical, null);
                window.KeyRelease(key, RawInputModifiers.None, physical, null);
                Pump();
            }
            bool SameRow(int a, int b) => Math.Abs(boxes[a].Top - boxes[b].Top) < 0.5;
            int Nearest(int from, bool below)
            {
                var beyond = Enumerable.Range(0, boxes.Count)
                    .Where(i => below ? boxes[i].Top >= boxes[from].Bottom - 0.5 : boxes[i].Bottom <= boxes[from].Top + 0.5).ToList();
                var row = below ? beyond.Min(i => boxes[i].Top) : beyond.Max(i => boxes[i].Top);
                return beyond.Where(i => Math.Abs(boxes[i].Top - row) < 0.5).MinBy(i => Math.Abs(boxes[i].Center.X - boxes[from].Center.X));
            }
            var visited = new HashSet<int>();
            void Expect(int index)
            {
                Assert.Same(tabs.Items[index], tabs.SelectedItem);
                Assert.Same(vm.Tabs[index], vm.SelectedTab);
                Assert.True(items[index].IsFocused, $"tab {index} not focused");
                visited.Add(index);
            }
            Assert.True(items[0].Focus());
            // The first row has nothing above it: Up stays.
            Press(Key.Up, PhysicalKey.ArrowUp);
            Expect(0);
            var current = 0;
            var downs = 0;
            while (current < items.Count - 1)
            {
                if (SameRow(current, current + 1))
                {
                    Press(Key.Right, PhysicalKey.ArrowRight);
                    current++;
                }
                else
                {
                    Press(Key.Down, PhysicalKey.ArrowDown);
                    current = Nearest(current, below: true);
                    downs++;
                }
                Expect(current);
            }
            Assert.True(downs >= 1);
            // The last row has nothing below it: Down stays.
            Press(Key.Down, PhysicalKey.ArrowDown);
            Expect(items.Count - 1);
            var last = items[^1];
            last.BringIntoView();
            Pump();
            var scroller = window.FindControl<ScrollViewer>("PageScroller")!;
            Assert.True(last.IsEffectivelyVisible);
            Assert.True(InWindow(scroller).Intersects(InWindow(last)));
            Assert.True(InWindow(last).Right <= InWindow(column).Right + 0.5);
            var chips = window.GetVisualDescendants().OfType<Border>().Where(b => b.DataContext is PaletteChip && b.Classes.Contains("chip"))
                .Select(b => ((PaletteChip)b.DataContext!).PresetId).ToList();
            // The last tab is Font: font presets, no image or archive ones.
            Assert.Equal(PaletteTab.Font, vm.SelectedTab!.Id);
            Assert.Contains("to-ttf", chips);
            Assert.DoesNotContain("to-zip", chips);
            Assert.DoesNotContain("to-png", chips);
            Save(window, $"toolbar-tabs-{language}-{suffix}-font.png");

            // Up goes back to the row above, to the tab nearest above.
            var above = Nearest(items.Count - 1, below: false);
            Press(Key.Up, PhysicalKey.ArrowUp);
            Expect(above);
            Assert.False(SameRow(above, items.Count - 1));

            // From there Right reaches the tabs a Down skipped, then Left walks back over every tab, across the row ends,
            // to the first.
            for (current = above; current < items.Count - 1; current++)
            {
                Press(Key.Right, PhysicalKey.ArrowRight);
                Expect(current + 1);
            }
            for (current = items.Count - 1; current > 0; current--)
            {
                Press(Key.Left, PhysicalKey.ArrowLeft);
                Expect(current - 1);
            }
            Assert.Equal(Enumerable.Range(0, items.Count), visited.Order());
        });
    }

    /// <summary>A search shows a preset this donut can't run: dimmed, with its reason, under its own tab.</summary>
    [AvaloniaTheory]
    [InlineData("en", false)]
    [InlineData("ko", true)]
    public void Palette_search_reveals_unusable(string language, bool dark)
    {
        using var f = new PresetAvailabilityTests.Fixture();
        TestServices.EnsureInitialized(language);
        var theme = AppHost.Get<ThemeService>();
        f.Preset("test-wav").Name = "Hidden WAV sample";
        f.Preset("test-jpg").Name = "Hidden JPG sample";
        if (dark)
            theme.Apply(new ThemeSettings { Mode = ThemeMode.Dark }, language);
        using var vm = f.PageWithPalette("png");
        Dispatcher.UIThread.RunJobs();
        var page = new ToolbarPage { DataContext = vm };
        var window = new Window { Width = 1080, Height = 820, Content = page };
        window.Bind(Window.BackgroundProperty, window.GetResourceObservable("PageBrush"));
        try
        {
            window.Show();
            Pump();
            var search = page.FindControl<TextBox>("PaletteSearchBox")!;
            Assert.True(search.Focus());
            window.KeyTextInput("Hidden");
            Pump();
            var tabs = page.FindControl<ListBox>("PaletteTabs")!;
            Assert.True(tabs.IsEffectivelyVisible);
            Assert.Equal([PaletteTab.All, PaletteTab.Image, PaletteTab.Media], tabs.Items.Cast<PaletteTabItem>().Select(t => t.Id));
            var media = (ListBoxItem)tabs.ContainerFromIndex(2)!;
            var point = Avalonia.VisualExtensions.TranslatePoint(media, new Avalonia.Point(media.Bounds.Width / 2, media.Bounds.Height / 2), window)!.Value;
            window.MouseDown(point, MouseButton.Left);
            window.MouseUp(point, MouseButton.Left);
            Pump();
            Assert.Same(vm.Tabs[2], tabs.SelectedItem);
            var chip = page.GetVisualDescendants().OfType<Border>().Single(b => b.DataContext is PaletteChip { PresetId: "test-wav" });
            Assert.Contains("dimmed", chip.Classes);
            Assert.Equal(f.Loc["error.no_route"], ToolTip.GetTip(chip));
            var suffix = dark ? "dark" : "light";
            Save(window, $"toolbar-search-unusable-{language}-{suffix}.png");
            ToolTip.SetIsOpen(chip, true);
            Pump();
            Save(window, $"toolbar-search-unusable-{language}-{suffix}-tooltip.png");
            ToolTip.SetIsOpen(chip, false);
        }
        finally
        {
            window.Close();
            if (dark)
                theme.Apply(new ThemeSettings(), language);
        }
    }

    /// <summary>Shows the toolbar page (tall, so the profile card is visible) with temporarily changed profiles.</summary>
    private static void WithProfiles(string language, bool dark, double height, Action<List<ToolbarProfile>> change, Action<Window, ToolbarPageViewModel> act)
    {
        TestServices.EnsureInitialized(language);
        var store = AppHost.Get<UserDataStore>();
        var theme = AppHost.Get<ThemeService>();
        var snapshot = store.Profiles.Select(p => p.Clone()).ToList();
        Window? window = null;
        try
        {
            change(store.Profiles);
            if (dark)
                theme.Apply(new ThemeSettings { Mode = ThemeMode.Dark }, language);
            using var vm = new MainWindowViewModel(AppHost.Services, AppHost.Get<ILocalizer>(), AppHost.Get<UpdateService>(), AppHost.Get<UserDataStore>());
            vm.Navigate("toolbar");
            window = new MainWindow { DataContext = vm, Width = 1080, Height = height };
            window.Show();
            Pump();
            act(window, (ToolbarPageViewModel)vm.CurrentPage);
        }
        finally
        {
            window?.Close();
            if (dark)
                theme.Apply(new ThemeSettings(), language);
            store.Profiles.Clear();
            store.Profiles.AddRange(snapshot);
            store.SaveLibrary();
        }
    }

    [AvaloniaTheory]
    [InlineData("en")]
    [InlineData("ja")]
    [InlineData("ko")]
    [InlineData("ru")]
    [InlineData("ar")]
    public void Excluded_apps_render_as_tags(string language)
    {
        TestServices.EnsureInitialized(language);
        var store = AppHost.Get<UserDataStore>();
        var before = store.Settings.ExcludedProcesses.ToList();
        try
        {
            store.Settings.ExcludedProcesses.Clear();
            store.Settings.ExcludedProcesses.AddRange(["Photoshop", "code"]);
            var vm = new TriggersPageViewModel(store, AppHost.Get<Filee.Core.Localization.ILocalizer>());
            var window = new Window { Content = new Filee.App.Views.Pages.TriggersPage { DataContext = vm }, Width = 820, Height = 1500 };
            window.Show();
            Pump();
            Assert.Equal(["Photoshop", "code"], vm.ExcludedApps.Tags.Select(t => t.Value));
            Save(window, $"triggers-excluded-{language}.png");
            window.Close();
        }
        finally
        {
            store.Settings.ExcludedProcesses.Clear();
            store.Settings.ExcludedProcesses.AddRange(before);
        }
    }

    [AvaloniaTheory]
    [InlineData("en")]
    [InlineData("ja")]
    [InlineData("ko")]
    [InlineData("zh-CN")]
    [InlineData("ru")]
    [InlineData("ar")]
    public void Close_dialog_renders(string language)
    {
        TestServices.EnsureInitialized(language);
        var dialog = new CloseAskWindow();
        dialog.Show();
        Pump();
        Save(dialog, $"window-close-{language}.png");
        dialog.Close();
    }

    [AvaloniaTheory]
    [InlineData("en")]
    [InlineData("ja")]
    [InlineData("ko")]
    [InlineData("zh-CN")]
    [InlineData("ru")]
    [InlineData("ar")]
    public void Format_request_notice_renders(string language)
    {
        TestServices.EnsureInitialized(language);
        var loc = AppHost.Get<ILocalizer>();
        var notice = new FormatRequestNoticeWindow([".ncm"], loc.Format("format_request.notice_title", ".ncm"));
        notice.Show();
        Pump();
        Save(notice, $"window-format-request-{language}.png");
        notice.Close();
    }

    [AvaloniaTheory]
    [InlineData("en")]
    [InlineData("ko")]
    [InlineData("zh-CN")]
    public void Extract_live_photo_video_option_renders_and_saves_for_mp4_and_mov_only(string language)
    {
        TestServices.EnsureInitialized(language);
        var preset = Filee.Core.Presets.BuiltInData.MotionPhotoPresets().Single();
        var vm = new PresetEditorViewModel(preset, AppHost.Get<ILocalizer>());
        Assert.True(vm.ShowExtractMotionPhoto);
        Assert.True(vm.ExtractMotionPhoto);
        var window = new PresetEditorWindow { DataContext = vm, Height = 980 };
        window.Show();
        Pump();
        Save(window, $"preset-extract-motion-{language}.png");
        window.Close();

        vm.Target = vm.Targets.Single(t => t.Value == "mov");
        Assert.True(vm.ShowExtractMotionPhoto);
        Assert.True(vm.Apply());
        Assert.True(preset.Media.ExtractMotionPhoto);
        // A box ticked for MP4 and left behind by another target saves nothing.
        var restored = new PresetEditorViewModel(preset, AppHost.Get<ILocalizer>());
        restored.Target = restored.Targets.Single(t => t.Value == "webm");
        Assert.False(restored.ShowExtractMotionPhoto);
        Assert.True(restored.Apply());
        Assert.False(preset.Media.ExtractMotionPhoto);
    }

    [AvaloniaTheory]
    [InlineData("en")]
    [InlineData("ko")]
    [InlineData("ja")]
    [InlineData("zh-CN")]
    [InlineData("ru")]
    [InlineData("ar")]
    [InlineData("pt-PT")]
    [InlineData("pt-BR")]
    [InlineData("fr")]
    public void Live_photo_options_render_for_jpg_and_heic_and_save_only_there(string language)
    {
        TestServices.EnsureInitialized(language);
        var preset = Filee.Core.Presets.BuiltInData.LivePhotoPresets().First();
        var vm = new PresetEditorViewModel(preset, AppHost.Get<ILocalizer>());
        Assert.True(vm.ShowLivePhotoChoice);
        Assert.True(vm.IsLivePhoto);
        Assert.False(vm.ShowImage);
        Assert.False(vm.ShowSaveEveryFrame);
        Assert.Equal(3, vm.LivePhotoKinds.Count);
        var window = new PresetEditorWindow { DataContext = vm, Height = 980 };
        window.Show();
        Pump();
        Save(window, $"preset-live-photo-{language}.png");
        window.Close();

        // HEIC is an iPhone's: no Motion Photo there.
        vm.Target = vm.Targets.Single(t => t.Value == "heic");
        Assert.Equal(2, vm.LivePhotoKinds.Count);
        Assert.True(vm.IsLivePhoto);
        vm.LivePhotoCodecChoice = vm.LivePhotoCodecs.Single(c => c.Value == Filee.Core.Presets.VideoCodec.Hevc);
        vm.LivePhotoLength = 60;
        Assert.True(vm.Apply());
        Assert.Equal(("heic", Filee.Core.Presets.LivePhotoKind.Apple), (preset.TargetFormat, preset.Media.LivePhoto));
        Assert.Equal(Filee.Core.Presets.VideoCodec.Hevc, preset.Media.VideoCodec);
        Assert.Equal(Filee.Core.Presets.MediaOptions.MaxLivePhotoLength, preset.Media.LivePhotoLength);

        // A kind left behind by a target that can't be one saves nothing.
        var restored = new PresetEditorViewModel(preset, AppHost.Get<ILocalizer>());
        restored.Target = restored.Targets.Single(t => t.Value == "png");
        Assert.False(restored.ShowLivePhotoChoice);
        Assert.True(restored.ShowImage);
        Assert.True(restored.Apply());
        Assert.Equal(Filee.Core.Presets.LivePhotoKind.None, preset.Media.LivePhoto);
    }

    public static TheoryData<string, bool> ClipLooks => new()
    {
        { "en", false }, { "en", true }, { "ru", false }, { "ru", true }, { "ar", false }, { "ar", true }, { "ja", false }, { "hi", true },
        { "pt-PT", false }, { "pt-PT", true }, { "pt-BR", false }, { "pt-BR", true },
    };

    /// <summary>
    /// "Cut a clip": the frame at the active handle large, start / length / end, the timeline with the clip between its
    /// handles and the toolbar, in light and dark, short and long languages and right to left.
    /// </summary>
    [AvaloniaTheory]
    [MemberData(nameof(ClipLooks))]
    public void Clip_window_renders(string language, bool dark)
    {
        ClipWindowTests.WithClipWindow(language, dark, ["Match highlights.mp4"], (window, vm, frames, _) =>
        {
            vm.MoveHandle(ClipHandle.Start, 95.3);
            vm.SetLength(30);
            // Cut in three: the middle piece out, the last one faster and louder, a fade in.
            vm.MovePlayhead(103);
            vm.Split();
            vm.MovePlayhead(110);
            vm.Split();
            vm.MovePlayhead(106);
            vm.Delete(closeUp: false); // a gap, with its button
            vm.MovePlayhead(118);
            vm.SelectedSpeed = vm.Speeds.Single(s => s.Value == 2);
            vm.SelectedVolume = 1.5;
            vm.HasFadeIn = true;
            vm.IsZoomed = true;
            var adding = vm.AddMusicAsync(Path.Combine("music", "Summer song.mp3"));
            ClipWindowTests.WaitFor(() => vm.MusicLoudness.Count > 0);
            vm.MoveMusic(3);
            vm.MovePlayhead(98);
            vm.SelectPiece(0, Filee.App.Controls.ClipLane.Audio);
            vm.IsCurrentMuted = false;
            // The sequence's own pictures of the clip, taken again once its ends rest.
            ClipWindowTests.WaitFor(() => vm.DetailStart == vm.Start && vm.DetailEnd == vm.End && vm.DetailLoudness.Count > 0);
            ClipWindowTests.WaitFor(() => frames.Times.Contains(vm.PreviewTime));
            Pump();

            Assert.Equal(("1:35.3", "2:05.3"), (vm.StartText, vm.EndText));
            Assert.Equal(7.7 + 7 + 15.3 / 2, vm.Length, 6); // the gap stays until closed
            Assert.True(window.ClipTimeline.Bounds.Width > 600);
            Assert.True(window.ClipTimeline.XOf(vm.Start) < window.ClipTimeline.XOf(vm.End));
            Save(window, $"clip-{language}-{(dark ? "dark" : "light")}.png");
        });
    }

    internal static void Pump()
    {
        // Let layout, bindings and a few animation frames run.
        for (var i = 0; i < 40; i++)
        {
            Dispatcher.UIThread.RunJobs();
            AvaloniaHeadlessPlatform.ForceRenderTimerTick();
        }
    }

    internal static void Save(TopLevel window, string name)
    {
        // Disposed at the end, so the frame stays alive while Skia encodes it: a collection in between (the idle memory
        // trim runs one on another thread) would otherwise finalize its image under the encoder.
        using var frame = window.CaptureRenderedFrame();
        Assert.NotNull(frame);
        using var stream = File.Create(Path.Combine(TestServices.ScreenshotDirectory, name));
        frame.Save(stream, new Avalonia.Media.Imaging.PngBitmapEncoderOptions());
    }
}