From 740e56464c68e115a95439d1e42e19f3716b293e Mon Sep 17 00:00:00 2001 From: Claude Date: Mon, 12 Oct 2026 16:21:19 +0000 Subject: [PATCH] fix(jobs): leave a followed render's toast to the editor and bound Open on large jobs The Jobs screen's flush could take a render's end before the editor that followed it had seen it, and announce it without the output file. It now yields while the open editor follows that render (FollowsRender); an editor closed in between still says it once, without the output. Open on a job over more sequences than a Library page (a maintenance run over a whole archive) now opens the Library as it is instead of looking every target up and paging through the list to select them all. Selecting many cards (Open's selection, Clear selection) counts the selection once instead of once per card over every card. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC --- src/Titano.App/Editor/EditorViewModel.cs | 14 ++- src/Titano.App/Sections/JobsViewModel.cs | 23 +++- src/Titano.App/Sections/LibraryViewModel.cs | 39 +++++-- src/Titano.App/Sections/SequenceViewModel.cs | 7 ++ .../Windows/ShellNotificationTests.cs | 103 +++++++++++++++++- 5 files changed, 164 insertions(+), 22 deletions(-) diff --git a/src/Titano.App/Editor/EditorViewModel.cs b/src/Titano.App/Editor/EditorViewModel.cs index 6bd9affa..2e4ca35a 100644 --- a/src/Titano.App/Editor/EditorViewModel.cs +++ b/src/Titano.App/Editor/EditorViewModel.cs @@ -930,7 +930,13 @@ public sealed class EditorViewModel : LocalizedViewModel, IAsyncDisposable if (!_jobs.Concerns(job)) return; _dispatcher.BeginInvoke(() => { - if (_disposed) return; + if (_disposed) + { + // Closed after the Jobs screen left this render's end to it (FollowsRender): said without a read. + if (job is { Kind: JobKind.Render, State: JobState.Done } && _jobs.IsActive(job.Id) && Shell.Jobs.ClaimRenderToast(job.Id)) + AnnounceRender(job, read: false); + return; + } var wasActive = _jobs.IsActive(job.Id); // Progress alone (several times a second on a server) only moves the server job's text and bar. if (_jobs.Track(job)) OnBusyChanged(); @@ -1037,6 +1043,12 @@ public sealed class EditorViewModel : LocalizedViewModel, IAsyncDisposable } } + /// + /// This editor follows the render (UI thread): it saw it wait or run and has not seen it end yet, so it will take its + /// toast () when it does. + /// + internal bool FollowsRender(Guid jobId) => !_disposed && _jobs.IsActive(jobId); + /// "Render finished" with the output file and Show in folder; : the sequence was read again after the render. private void AnnounceRender(Job render, bool read) { diff --git a/src/Titano.App/Sections/JobsViewModel.cs b/src/Titano.App/Sections/JobsViewModel.cs index f0de54fa..1aa9de27 100644 --- a/src/Titano.App/Sections/JobsViewModel.cs +++ b/src/Titano.App/Sections/JobsViewModel.cs @@ -3,6 +3,7 @@ using System.IO; using System.Windows.Input; using Titano.App.Infrastructure; using Titano.App.Jobs; +using Titano.App.Library; using Titano.App.Settings; using Titano.App.Shell; using Titano.Core.Diagnostics; @@ -254,14 +255,17 @@ public sealed class JobsViewModel : SectionViewModel if (job.State != JobState.Failed) _unseenFailures.Remove(job.Id); else if (before != JobState.Failed && !IsSelected) _unseenFailures.Add(job.Id); var notice = JobNotices.For(before, job); - if (notice == JobNotice.Done && job.Kind == JobKind.Render && !ClaimRenderToast(job.Id)) return; + // A flush can take the end before the editor that follows the render has seen it: the editor says it, with its output. + if (notice == JobNotice.Done && job.Kind == JobKind.Render + && (Shell.Sequence.Editor?.FollowsRender(job.Id) == true || !ClaimRenderToast(job.Id))) return; _endings.Add(notice, job); } /// /// Takes the toast of a finished render, which is said once (UI thread): true for the first caller only, which then /// raises it. The editor of the render's sequence takes it when it sees the render end, and says it with the output - /// file even when the sequence cannot be read again; a render the editor did not follow is said here. + /// file even when the sequence cannot be read again or the editor closed meanwhile; a render the editor did not + /// follow is said here. /// internal bool ClaimRenderToast(Guid jobId) => _renderToasts.Add(jobId); @@ -411,14 +415,23 @@ public sealed class JobsViewModel : SectionViewModel /// /// Opens what a job worked on inside Titano: its sequence in the editor; several sequences (a deep analysis of a - /// Library selection) in the Library, every one of them selected; else the Archive screen. + /// Library selection) in the Library, every one of them selected; else the Archive screen. A job over more sequences + /// than a Library page holds (a maintenance run over a whole archive) opens the Library as it is: looking each one + /// up, then reading page after page to select them all, would hold the screen. /// internal async Task OpenTargetAsync(Job job) { var db = Shell.Services.Database; if (db is null || job.TargetIds.Count == 0) return; - var sequences = new List(); - foreach (var id in job.TargetIds.Distinct()) + var targets = job.TargetIds.Distinct().ToList(); + if (targets.Count > LibraryPager.DefaultPageSize) + { + Shell.Navigate(SectionKey.Library); + return; + } + // Each one is looked up: an id no longer in the index would have the Library read every page in search of it. + var sequences = new List(targets.Count); + foreach (var id in targets) { if (await db.Sequences.GetAsync(id) is { } sequence) sequences.Add(sequence.Id); } diff --git a/src/Titano.App/Sections/LibraryViewModel.cs b/src/Titano.App/Sections/LibraryViewModel.cs index deaf0b88..1a65e73e 100644 --- a/src/Titano.App/Sections/LibraryViewModel.cs +++ b/src/Titano.App/Sections/LibraryViewModel.cs @@ -71,6 +71,10 @@ public sealed class LibraryViewModel : SectionViewModel private bool _isLoading; private bool _hasLoaded; private bool _suppressReload; + + /// Many cards change selection at once (): the selection is counted once after them. + private bool _bulkSelect; + private int _layoutIndex; private SequenceItem? _selected; private int _selectionCount; @@ -601,15 +605,30 @@ public sealed class LibraryViewModel : SectionViewModel if (Items.Count == listed) break; } } - SequenceItem? first = null; - foreach (var item in Items) + SelectOnly(item => wanted.Contains(item.Sequence.Id)); + if (Items.FirstOrDefault(i => i.IsSelected) is { } first) ScrollRequested?.Invoke(first); + } + + /// + /// Selects exactly the cards picks. The selection, its summary and the mass actions' + /// tooltips are worked out once at the end: once per card, each over every card, a whole archive would hold the screen. + /// + private void SelectOnly(Func chosen) + { + _bulkSelect = true; + try { - var chosen = wanted.Contains(item.Sequence.Id); - if (item.IsSelected != chosen) item.IsSelected = chosen; - if (chosen) first ??= item; + foreach (var item in Items) + { + var selected = chosen(item); + if (item.IsSelected != selected) item.IsSelected = selected; + } + } + finally + { + _bulkSelect = false; } OnSelectionChanged(); - if (first is not null) ScrollRequested?.Invoke(first); } /// Opens Tags on the selection (capture, tests). @@ -960,15 +979,11 @@ public sealed class LibraryViewModel : SectionViewModel await LoadViewsAsync(); } - private void ClearSelection() - { - foreach (var item in Items) item.IsSelected = false; - OnSelectionChanged(); - } + private void ClearSelection() => SelectOnly(_ => false); private void OnItemChanged(object? sender, PropertyChangedEventArgs e) { - if (e.PropertyName == nameof(SequenceItem.IsSelected)) OnSelectionChanged(); + if (e.PropertyName == nameof(SequenceItem.IsSelected) && !_bulkSelect) OnSelectionChanged(); } private void RaiseState() diff --git a/src/Titano.App/Sections/SequenceViewModel.cs b/src/Titano.App/Sections/SequenceViewModel.cs index 8e7f1393..9f52f821 100644 --- a/src/Titano.App/Sections/SequenceViewModel.cs +++ b/src/Titano.App/Sections/SequenceViewModel.cs @@ -142,6 +142,13 @@ public sealed class SequenceViewModel : SectionViewModel await editor.DisposeAsync(); } + /// Shows , which the caller opened over a source of its own (tests), as the open sequence. + internal void Attach(EditorViewModel editor) + { + _openId = editor.Session.Content.Sequence.Id; + Editor = editor; + } + public override void Dispose() { Shell.PropertyChanged -= OnShellChanged; diff --git a/tests/Titano.App.Tests/Windows/ShellNotificationTests.cs b/tests/Titano.App.Tests/Windows/ShellNotificationTests.cs index e784f0fb..e5bcc36e 100644 --- a/tests/Titano.App.Tests/Windows/ShellNotificationTests.cs +++ b/tests/Titano.App.Tests/Windows/ShellNotificationTests.cs @@ -5,6 +5,7 @@ using System.Windows.Input; using System.Windows.Shell; using Titano.App.Editor; using Titano.App.Infrastructure; +using Titano.App.Library; using Titano.App.Sections; using Titano.App.Settings; using Titano.App.Shell; @@ -398,9 +399,58 @@ public sealed class ShellNotificationTests Assert.Equal(shell.Archive.Health.Count(h => !h.IsOk), shell.Archive.Badge); }); + /// + /// The Jobs screen's flush can take a render's end before the editor that followed the render has seen it: it leaves + /// the toast to the editor, which says it once with its output, and once without it when it closed in between. + /// + [Test] + public Task TheEditorSaysTheRenderItFollowedAlsoWhenTheJobsScreenSeesItsEndFirst() => ScreenHost.RunAsync(async () => + { + await using var app = await ScreenSmokeTests.SampleApp.StartAsync(); + var shell = app.Shell; + shell.CompleteWelcome(); + await JobsLoadedAsync(shell); + var jobs = shell.Jobs; + var raised = new List(); + shell.PendingToasts.CollectionChanged += (_, e) => raised.AddRange(e.NewItems?.Cast() ?? []); + var content = EditorFixture.Content(EditorFixture.Sunset); + var source = new FakeSequenceSource(EditorFixture.Sunset, content); + var editor = new EditorViewModel(shell, new EditorSession(source, content, []), [], EncoderHost.Client); + shell.Sequence.Attach(editor); + + foreach (var closes in new[] { false, true }) + { + raised.Clear(); + var render = Job(JobKind.Render, JobState.Running, content.Sequence.Id); + source.Report(render); + jobs.OnJobChanged(render); + await UntilAsync(() => editor.FollowsRender(render.Id)); + jobs.Flush(); + + // The end reaches the Jobs screen first; the editor's own callback runs after its flush. + jobs.OnJobChanged(render with { State = JobState.Done }); + jobs.Flush(); + Assert.False(raised.Any(t => t.Title == Loc.L("Shell.Job.Done")), "the Jobs screen leaves the end of a followed render to the editor"); + source.Report(render with { State = JobState.Done }); + if (closes) + { + await shell.Sequence.CloseAsync(); + Assert.Null(shell.Sequence.Editor); + } + await UntilAsync(() => raised.Any(t => t.Title == Loc.L("Editor.Render.Done"))); + jobs.Flush(); + var finished = Assert.Contains(raised, t => t.Title == Loc.L("Editor.Render.Done")); + Assert.Equal(1, raised.Count(t => t.Title == Loc.L("Editor.Render.Done")), "said once"); + Assert.False(raised.Any(t => t.Title == Loc.L("Shell.Job.Done")), "and never by the Jobs screen as well"); + if (closes) Assert.Null(finished.ActionCommand, "a closed editor does not read the sequence again for the output"); + } + }); + /// /// Open on a job that worked on several sequences (a deep analysis of a Library selection) shows every one of them - /// selected in the Library, also those a search hid; a job on an archive opens the Archive screen. + /// selected in the Library: also those a search hides, whether it is still pending or applied, and those beyond the + /// pages read so far. A job over more sequences than a page leaves the Library as it is; a job on an archive opens + /// the Archive screen. /// [Test] public Task OpenOnAJobOverSeveralSequencesSelectsThemAllInTheLibrary() => ScreenHost.RunAsync(async () => @@ -414,15 +464,60 @@ public sealed class ShellNotificationTests await library.RefreshAsync(); var ids = (await db.Sequences.ListAsync(new SequenceQuery { Sort = SequenceSort.Oldest, Limit = 3 })).Items.Select(s => s.Id).ToList(); Assert.Count(3, ids); - library.SearchText = "no such sequence"; + bool Listed(Guid id) => library.Items.Any(i => i.Sequence.Id == id); + Job Analysis(IReadOnlyList targets) => + Job(JobKind.DeepAnalyse, JobState.Done, targets[0]) with { TargetIds = targets, TargetLabel = Loc.Plural("Library.Selection.Count", targets.Count) }; - var analysis = Job(JobKind.DeepAnalyse, JobState.Done, ids[0]) with { TargetIds = ids, TargetLabel = Loc.Plural("Library.Selection.Count", ids.Count) }; - await shell.Jobs.OpenTargetAsync(analysis); + // A search still waiting to apply. + library.SearchText = "no such sequence"; + await shell.Jobs.OpenTargetAsync(Analysis(ids)); Assert.Equal(SectionKey.Library, shell.Current.Key); Assert.Equal(string.Empty, library.SearchText, "the search that hid them is cleared"); Assert.Equal(ids.Count, library.SelectionCount, "every sequence the job worked on, not only the first"); Assert.SequenceEqual(ids.Order(), library.SelectedItems().Select(i => i.Sequence.Id).Order()); + // A search applied: the list no longer holds them. + library.SearchText = "no such sequence"; + await UntilAsync(() => !ids.Any(Listed)); + Assert.False(ids.Any(Listed), "the search hides them"); + await shell.Jobs.OpenTargetAsync(Analysis(ids)); + Assert.Equal(string.Empty, library.SearchText); + Assert.SequenceEqual(ids.Order(), library.SelectedItems().Select(i => i.Sequence.Id).Order()); + + // More sequences than a page: those beyond the first page are read until each is listed. + var archiveId = Assert.NotNull(await db.Sequences.GetAsync(ids[0])).ArchiveId; + var bulk = new List(); + for (var i = 0; i < LibraryPager.DefaultPageSize + 10; i++) + { + var sequence = new Sequence + { + Id = Guid.CreateVersion7(), + ArchiveId = archiveId, + Folder = $"2021/2021-03-01 Bulk {i:000}", + Title = $"Bulk {i:000}", + FirstCapture = new DateTime(2021, 3, 1).AddHours(i), + LastCapture = new DateTime(2021, 3, 1).AddHours(i + 1), + FrameCount = 10, + UpdatedAt = DateTimeOffset.UtcNow, + }; + await db.Sequences.UpsertAsync(sequence); + bulk.Add(sequence.Id); + } + await library.RefreshAsync(); + var beyond = bulk.Where(id => !Listed(id)).Take(3).ToList(); + Assert.Count(3, beyond); + await shell.Jobs.OpenTargetAsync(Analysis(beyond)); + Assert.Greater(library.Items.Count, LibraryPager.DefaultPageSize, "the next pages were read"); + Assert.SequenceEqual(beyond.Order(), library.SelectedItems().Select(i => i.Sequence.Id).Order()); + + // A job over more sequences than a page (a maintenance run over the archive) opens the Library as it is. + shell.Navigate(SectionKey.Jobs); + library.SearchText = "Bulk"; + await shell.Jobs.OpenTargetAsync(Analysis(bulk)); + Assert.Equal(SectionKey.Library, shell.Current.Key); + Assert.Equal("Bulk", library.SearchText, "its search is not cleared"); + Assert.SequenceEqual(beyond.Order(), library.SelectedItems().Select(i => i.Sequence.Id).Order(), "nor its selection replaced"); + await shell.Jobs.OpenTargetAsync(Job(JobKind.Verify, JobState.Done, Guid.CreateVersion7())); Assert.Equal(SectionKey.Archive, shell.Current.Key); // The Archive screen reads its figures when it opens: let that end before the app closes.