From 789c2dae3e347d7185c04448c11424e41e3bb5b1 Mon Sep 17 00:00:00 2001 From: Claude Date: Mon, 12 Oct 2026 15:53:58 +0000 Subject: [PATCH] fix(jobs): announce every finished render once and open every target A finished render's toast is claimed once (JobsViewModel.ClaimRenderToast): the editor that followed the render to its end says it with its output, also when the sequence cannot be read again (then without Show in folder) or the editor closed meanwhile; any other render is said by the Jobs screen. Before, the Jobs screen stayed silent whenever an editor had the sequence open, so a failed reload or a render the editor did not follow ended without a completion toast. Open on a job over several sequences (toast, Windows notification, Jobs row) shows the Library with every one of them selected, clearing a search or filter that hides one and reading pages until each is listed, instead of opening the first in the editor. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC --- src/Titano.App/Editor/EditorViewModel.cs | 29 +++++-- src/Titano.App/Sections/JobsViewModel.cs | 43 +++++++--- src/Titano.App/Sections/LibraryViewModel.cs | 42 +++++++++- .../Titano.App.Tests/Editor/EditorFixture.cs | 10 ++- .../Windows/ShellNotificationTests.cs | 81 ++++++++++++++++--- 5 files changed, 174 insertions(+), 31 deletions(-) diff --git a/src/Titano.App/Editor/EditorViewModel.cs b/src/Titano.App/Editor/EditorViewModel.cs index 508c7b37..6bd9affa 100644 --- a/src/Titano.App/Editor/EditorViewModel.cs +++ b/src/Titano.App/Editor/EditorViewModel.cs @@ -937,7 +937,8 @@ public sealed class EditorViewModel : LocalizedViewModel, IAsyncDisposable else OnServerJobChanged(); LearnAnalysisSpeed(job); if (!wasActive) return; - if (job.State == JobState.Done) _ = ReloadAsync(job.Kind == JobKind.Render ? job : null); + // A render this editor followed to its end is said here, with its output, unless the Jobs screen said it first. + if (job.State == JobState.Done) _ = ReloadAsync(job.Kind == JobKind.Render && Shell.Jobs.ClaimRenderToast(job.Id) ? job : null); else if (IsRemote && job.State is JobState.Failed or JobState.Cancelled) ReportServerJobEnded(job); }); } @@ -1010,23 +1011,37 @@ public sealed class EditorViewModel : LocalizedViewModel, IAsyncDisposable if (job is { Kind: JobKind.DeepAnalyse, State: JobState.Done, ItemsPerSecond: > 0 and var speed }) _analysisSecondsPerFrame = 1 / speed; } - /// Reads the sequence again after a job; a finished render offers its follow-ups (BRIEF §11.5). + /// + /// Reads the sequence again after a job. A finished render whose toast this editor took () + /// is said in any case, also when the editor closed meanwhile: with its output and follow-ups (BRIEF §11.5) once the + /// sequence is read again, without them when that failed. + /// private async Task ReloadAsync(Job? render) { + var reloaded = false; try { await Session.ReloadAsync(); + reloaded = true; } catch (Exception ex) when (ex is System.IO.IOException or System.IO.InvalidDataException or InvalidOperationException or UnauthorizedAccessException - or System.Net.Http.HttpRequestException or Protocol.Client.TitanoApiException or OperationCanceledException) + or System.Net.Http.HttpRequestException or Protocol.Client.TitanoApiException or OperationCanceledException + or Data.DatabaseException) { // A server that does not answer in time cancels the request (OperationCanceledException). Shell.ReportError(ex); - return; } - if (render is null || _disposed) return; - // A server's render stays on the server: nothing to show in Explorer. - var output = Session.Content.Renders.FirstOrDefault(r => render.Started is not { } started || r.Created >= started)?.OutputPath is { Length: > 0 } path + finally + { + if (render is not null) AnnounceRender(render, reloaded); + } + } + + /// "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) + { + // A server's render stays on the server: nothing to show in Explorer. Before a read the renders are the old ones. + var output = read && Session.Content.Renders.FirstOrDefault(r => render.Started is not { } started || r.Created >= started)?.OutputPath is { Length: > 0 } path ? path : null; Shell.ShowToast(new Toast diff --git a/src/Titano.App/Sections/JobsViewModel.cs b/src/Titano.App/Sections/JobsViewModel.cs index fff2a7fb..f0de54fa 100644 --- a/src/Titano.App/Sections/JobsViewModel.cs +++ b/src/Titano.App/Sections/JobsViewModel.cs @@ -63,6 +63,10 @@ public sealed class JobsViewModel : SectionViewModel private readonly Dictionary _rows = []; private readonly HashSet _unseenFailures = []; private readonly JobEndings _endings = new(); + + /// Finished renders whose toast was taken (). + private readonly HashSet _renderToasts = []; + private readonly JobActions _actions; private CoalescingThrottle? _throttle; private IJobQueue? _queue; @@ -250,10 +254,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 && EditorAnnounces(job)) return; + if (notice == JobNotice.Done && job.Kind == JobKind.Render && !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. + /// + internal bool ClaimRenderToast(Guid jobId) => _renderToasts.Add(jobId); + /// /// The toast of a job that ended, with one action (BRIEF §12.1, §0.2 rule 6). Several endings at once (a batch /// finished, or failed together) say how many and lead to this screen. Clicking the Windows notification of a @@ -311,11 +322,6 @@ public sealed class JobsViewModel : SectionViewModel }; } - /// A finished render of the sequence open in the editor: the editor says it, with its output file. - private bool EditorAnnounces(Job job) => - job is { Kind: JobKind.Render, State: JobState.Done } && Shell.Sequence.Editor is { IsRemote: false } editor - && job.TargetIds.Contains(editor.Session.Content.Sequence.Id); - /// A job changed state (any thread; tests feed it too): buffered until the next flush. internal void OnJobChanged(Job job) { @@ -403,13 +409,32 @@ public sealed class JobsViewModel : SectionViewModel SyncRows(); } - /// Opens what a job worked on inside Titano: its sequence in the editor, or the Archive screen. + /// + /// 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. + /// internal async Task OpenTargetAsync(Job job) { var db = Shell.Services.Database; if (db is null || job.TargetIds.Count == 0) return; - if (await db.Sequences.GetAsync(job.TargetIds[0]) is { } sequence) Shell.OpenSequence(sequence.Id); - else Shell.Navigate(SectionKey.Archive); + var sequences = new List(); + foreach (var id in job.TargetIds.Distinct()) + { + if (await db.Sequences.GetAsync(id) is { } sequence) sequences.Add(sequence.Id); + } + switch (sequences.Count) + { + case 0: + Shell.Navigate(SectionKey.Archive); + break; + case 1: + Shell.OpenSequence(sequences[0]); + break; + default: + Shell.Navigate(SectionKey.Library); + await Shell.Library.ShowSelectedAsync(sequences); + break; + } } /// Shows the folder of what a job worked on in Explorer. diff --git a/src/Titano.App/Sections/LibraryViewModel.cs b/src/Titano.App/Sections/LibraryViewModel.cs index 7fc70225..deaf0b88 100644 --- a/src/Titano.App/Sections/LibraryViewModel.cs +++ b/src/Titano.App/Sections/LibraryViewModel.cs @@ -581,6 +581,37 @@ public sealed class LibraryViewModel : SectionViewModel RaiseMass(); } + /// + /// Shows the sequences of selected, under the mass actions bar (Open on a job over several + /// sequences). Search and filters go when one of them would be hidden or is still being applied, pages are read until + /// each is listed, and the first comes into sight. Ids not in the index are left out. + /// + public async Task ShowSelectedAsync(IReadOnlyCollection ids) + { + if (_pager is null) return; + var wanted = ids.ToHashSet(); + if (_searchDelay.IsEnabled || _pager.IsLoading || !Lists(wanted)) + { + ResetFilters(); + await ReloadAsync(); + while (!Lists(wanted) && _pager is { HasMore: true }) + { + var listed = Items.Count; + await LoadMoreAsync(); + if (Items.Count == listed) break; + } + } + SequenceItem? first = null; + foreach (var item in Items) + { + var chosen = wanted.Contains(item.Sequence.Id); + if (item.IsSelected != chosen) item.IsSelected = chosen; + if (chosen) first ??= item; + } + OnSelectionChanged(); + if (first is not null) ScrollRequested?.Invoke(first); + } + /// Opens Tags on the selection (capture, tests). public void OpenRetag() => OpenRetag(Targets(MassAction.Tag)); @@ -850,6 +881,13 @@ public sealed class LibraryViewModel : SectionViewModel } private void ClearFilters() + { + ResetFilters(); + Reload(); + } + + /// Search and filters back to "any", without reading the list again. + private void ResetFilters() { _suppressReload = true; _searchDelay.Stop(); @@ -863,9 +901,11 @@ public sealed class LibraryViewModel : SectionViewModel _timelineMonth = null; _scrollToMonth = false; _suppressReload = false; - Reload(); } + /// Every sequence of is in the list on screen. + private bool Lists(HashSet ids) => ids.IsSubsetOf(Items.Select(i => i.Sequence.Id)); + /// Shows a saved view: its search, filters and sort, at once. private void Apply(SavedView view) { diff --git a/tests/Titano.App.Tests/Editor/EditorFixture.cs b/tests/Titano.App.Tests/Editor/EditorFixture.cs index 8fb39b85..2099ebd1 100644 --- a/tests/Titano.App.Tests/Editor/EditorFixture.cs +++ b/tests/Titano.App.Tests/Editor/EditorFixture.cs @@ -111,7 +111,15 @@ internal sealed class FakeSequenceSource(SyntheticSequence sequence, SequenceCon /// Awaited by every decode (tests of cancellation). public Task DecodeGate { get; set; } = Task.CompletedTask; - public Task LoadAsync(CancellationToken cancellationToken) => Task.FromResult(Content with { Project = Stored }); + /// Thrown by the next load (the sequence read again after a job). + public Exception? FailNextLoad { get; set; } + + public Task LoadAsync(CancellationToken cancellationToken) + { + if (FailNextLoad is not { } failure) return Task.FromResult(Content with { Project = Stored }); + FailNextLoad = null; + return Task.FromException(failure); + } public async ValueTask DecodeAsync(int index, int maxLongEdge, DecodePurpose purpose, CancellationToken cancellationToken) { diff --git a/tests/Titano.App.Tests/Windows/ShellNotificationTests.cs b/tests/Titano.App.Tests/Windows/ShellNotificationTests.cs index 11b19f09..e784f0fb 100644 --- a/tests/Titano.App.Tests/Windows/ShellNotificationTests.cs +++ b/tests/Titano.App.Tests/Windows/ShellNotificationTests.cs @@ -1,11 +1,15 @@ +using System.IO; using System.Windows; using System.Windows.Controls; using System.Windows.Input; using System.Windows.Shell; +using Titano.App.Editor; using Titano.App.Infrastructure; using Titano.App.Sections; using Titano.App.Settings; using Titano.App.Shell; +using Titano.App.Tests.Editor; +using Titano.Core.Export; using Titano.Core.Localization; using Titano.Core.Model; using Titano.Data.Repositories; @@ -133,26 +137,40 @@ public sealed class ShellNotificationTests Assert.Equal(badge, jobs.Badge); Assert.NotEqual(TaskbarItemProgressState.Error, shell.TaskbarState); - // The editor announces the renders of its own sequence, with their output: the shell says nothing then. - var id = await app.Sample.FillEditorAsync(); - shell.OpenSequence(id); - await shell.Sequence.OpenAsync(id); - Assert.NotNull(shell.Sequence.Editor); + // The editor says the renders it followed to their end, with their output: the shell says nothing then. It says them + // also when the sequence cannot be read again (that error is said too), without Show in folder then. + var content = EditorFixture.Content(EditorFixture.Sunset); + var source = new FakeSequenceSource(EditorFixture.Sunset, content); + var editor = new EditorViewModel(shell, new EditorSession(source, content, []), [], EncoderHost.Client); + await using (editor) + { + foreach (var readable in new[] { true, false }) + { + raised.Clear(); + var render = Job(JobKind.Render, JobState.Running, content.Sequence.Id); + source.Report(render); + jobs.OnJobChanged(render); + await UntilAsync(() => editor.IsBusy); + jobs.Flush(); + if (!readable) source.FailNextLoad = new IOException("The specified network name is no longer available."); + source.Report(render with { State = JobState.Done }); + jobs.OnJobChanged(render with { State = JobState.Done }); + 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.False(raised.Any(t => t.Title == Loc.L("Shell.Job.Done")), "the editor's own render toast is not doubled"); + Assert.Equal(readable ? 0 : 1, raised.Count(t => t.IsError), "a failed read is said beside the render's end"); + if (!readable) Assert.Null(finished.ActionCommand, "without the sequence read again, there is no output to show"); + } + } + // A render the editor did not follow (of another sequence) is the shell's to announce. raised.Clear(); - var render = Job(JobKind.Render, JobState.Running, id); - jobs.OnJobChanged(render); - jobs.Flush(); - jobs.OnJobChanged(render with { State = JobState.Done }); - jobs.Flush(); - Assert.False(raised.Any(t => t.Title == Loc.L("Shell.Job.Done")), "the editor's own render toast is not doubled"); - // A render of another sequence is the shell's to announce. var other = Job(JobKind.Render, JobState.Running, Guid.CreateVersion7()); jobs.OnJobChanged(other); jobs.Flush(); jobs.OnJobChanged(other with { State = JobState.Done }); jobs.Flush(); Assert.Equal(1, raised.Count(t => t.Title == Loc.L("Shell.Job.Done"))); - await shell.Sequence.CloseAsync(); // Server › Upload all: the batch speaks once, when its last upload ends. raised.Clear(); @@ -380,6 +398,43 @@ public sealed class ShellNotificationTests Assert.Equal(shell.Archive.Health.Count(h => !h.IsOk), shell.Archive.Badge); }); + /// + /// 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. + /// + [Test] + public Task OpenOnAJobOverSeveralSequencesSelectsThemAllInTheLibrary() => ScreenHost.RunAsync(async () => + { + await using var app = await ScreenSmokeTests.SampleApp.StartAsync(); + var shell = app.Shell; + shell.CompleteWelcome(); + await app.Sample.FillAsync(); + var db = Assert.NotNull(shell.Services.Database); + var library = shell.Library; + 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"; + + 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); + 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()); + + 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. + await shell.Archive.LoadAsync(); + }); + + /// Lets the dispatcher run what was posted to it (the editor's job events and reload) until holds. + private static async Task UntilAsync(Func done) + { + for (var i = 0; i < 250 && !done(); i++) await Task.Delay(20); + } + /// The Jobs screen read its first page (it would set the job bar and the badge again). private static async Task JobsLoadedAsync(ShellViewModel shell) {