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 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
184 lines
6.9 KiB
C#
184 lines
6.9 KiB
C#
using System.Globalization;
|
|
using Titano.App.Editor;
|
|
using Titano.Core.Analysis;
|
|
using Titano.Core.Analysis.Deep;
|
|
using Titano.Core.Diagnostics.Synthetic;
|
|
using Titano.Core.Imaging;
|
|
using Titano.Core.Localization;
|
|
using Titano.Core.Model;
|
|
using Titano.Core.Project;
|
|
using Titano.Core.Render.Diagnostics;
|
|
using Titano.Data.Archiving.Jobs;
|
|
|
|
namespace Titano.App.Tests.Editor;
|
|
|
|
/// <summary>A synthetic sunset with flicker and two exposure steps, as the editor tests open it.</summary>
|
|
internal static class EditorFixture
|
|
{
|
|
private static readonly Lazy<SyntheticSequence> Shared = new(() => Sequence());
|
|
|
|
static EditorFixture() => Loc.SetCulture(CultureInfo.GetCultureInfo("en"));
|
|
|
|
public static SyntheticSequence Sunset => Shared.Value;
|
|
|
|
public static SyntheticSequence Sequence(int frames = 72) => SyntheticSequence.Create(new SyntheticSequenceOptions
|
|
{
|
|
Width = 96,
|
|
Height = 64,
|
|
FrameCount = frames,
|
|
StartEv = 0,
|
|
EndEv = -2,
|
|
FlickerEv = 0.25,
|
|
ExposureSteps = [new SyntheticExposureStep(24, -1), new SyntheticExposureStep(48, -1)],
|
|
StartKelvin = 5200,
|
|
EndKelvin = 3400,
|
|
});
|
|
|
|
/// <summary>The sequence as <see cref="ISequenceSource.LoadAsync"/> returns it, with a deep analysis when asked.</summary>
|
|
public static SequenceContent Content(SyntheticSequence sequence, ProjectSettings? project = null, bool deep = true)
|
|
{
|
|
var id = Guid.CreateVersion7();
|
|
var frames = sequence.Frames.Select(f => f with { SequenceId = id }).ToList();
|
|
var row = new Sequence
|
|
{
|
|
Id = id,
|
|
ArchiveId = Guid.CreateVersion7(),
|
|
Title = "Harbour sunset",
|
|
Folder = "2026/2026-09-28 Synthetic",
|
|
CameraMake = sequence.Options.CameraMake,
|
|
CameraModel = sequence.Options.CameraModel,
|
|
FirstCapture = frames[0].CapturedAt,
|
|
LastCapture = frames[^1].CapturedAt,
|
|
FrameCount = frames.Count,
|
|
MedianInterval = sequence.Options.IntervalSeconds,
|
|
};
|
|
var report = deep ? DeepAnalyzer.AnalyzeAsync(new Frames(sequence)).GetAwaiter().GetResult() : null;
|
|
return new SequenceContent(row, frames, project ?? new ProjectSettings(), LightAnalyzer.Analyze(frames), report, sequence.Options.Width,
|
|
sequence.Options.Height, null, [], []);
|
|
}
|
|
|
|
/// <summary>Synthetic frames as the deep analysis reads them.</summary>
|
|
private sealed class Frames(SyntheticSequence sequence) : IFrameSource
|
|
{
|
|
public int Count => sequence.Count;
|
|
|
|
public LightFrame Metadata(int index) => LightFrame.From(sequence.Metadata[index], index);
|
|
|
|
public ValueTask<ImageBuffer?> LoadAsync(int index, int maxLongEdge, CancellationToken cancellationToken) =>
|
|
ValueTask.FromResult<ImageBuffer?>(sequence.Render(index));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// An in-memory <see cref="ISequenceSource"/>: synthetic pixels, a stored project with the same merge rule as the
|
|
/// archive, recorded jobs. <see cref="ExternalEdit"/> simulates someone else changing the stored project before a save.
|
|
/// </summary>
|
|
internal sealed class FakeSequenceSource(SyntheticSequence sequence, SequenceContent content) : ISequenceSource
|
|
{
|
|
private readonly SyntheticFrameSource _pixels = new(sequence);
|
|
|
|
public ProjectSettings Stored { get; set; } = content.Project;
|
|
|
|
public SequenceContent Content { get; set; } = content;
|
|
|
|
public List<ArchiveJobRequest> Submitted { get; } = [];
|
|
|
|
/// <summary>A server sequence: renders become one job per preset.</summary>
|
|
public bool IsRemote { get; init; }
|
|
|
|
public bool IsReadOnly { get; set; }
|
|
|
|
public bool IsOutdated { get; private set; }
|
|
|
|
/// <summary>Jobs cancelled and retried through the source.</summary>
|
|
public List<Guid> Cancelled { get; } = [];
|
|
|
|
public List<Guid> Retried { get; } = [];
|
|
|
|
/// <summary>Jobs <see cref="ListJobsAsync"/> returns.</summary>
|
|
public List<Job> Jobs { get; } = [];
|
|
|
|
public int Saves { get; private set; }
|
|
|
|
public int Decodes { get; private set; }
|
|
|
|
/// <summary>Applied to the stored project before the next save reads it.</summary>
|
|
public Func<ProjectSettings, ProjectSettings>? ExternalEdit { get; set; }
|
|
|
|
/// <summary>Thrown by the next save.</summary>
|
|
public Exception? FailNextSave { get; set; }
|
|
|
|
/// <summary>Awaited by every decode (tests of cancellation).</summary>
|
|
public Task DecodeGate { get; set; } = Task.CompletedTask;
|
|
|
|
/// <summary>Thrown by the next load (the sequence read again after a job).</summary>
|
|
public Exception? FailNextLoad { get; set; }
|
|
|
|
public Task<SequenceContent> LoadAsync(CancellationToken cancellationToken)
|
|
{
|
|
if (FailNextLoad is not { } failure) return Task.FromResult(Content with { Project = Stored });
|
|
FailNextLoad = null;
|
|
return Task.FromException<SequenceContent>(failure);
|
|
}
|
|
|
|
public async ValueTask<ImageBuffer?> DecodeAsync(int index, int maxLongEdge, DecodePurpose purpose, CancellationToken cancellationToken)
|
|
{
|
|
await DecodeGate.WaitAsync(cancellationToken);
|
|
Decodes++;
|
|
return await _pixels.GetFrameAsync(index, maxLongEdge, purpose, cancellationToken);
|
|
}
|
|
|
|
public Task<ProjectSettings> SaveProjectAsync(ProjectSettings project, ProjectSettings basis, CancellationToken cancellationToken)
|
|
{
|
|
if (FailNextSave is { } failure)
|
|
{
|
|
FailNextSave = null;
|
|
return Task.FromException<ProjectSettings>(failure);
|
|
}
|
|
if (ExternalEdit is { } edit)
|
|
{
|
|
Stored = edit(Stored);
|
|
ExternalEdit = null;
|
|
}
|
|
Stored = ProjectMerge.SameValues(Stored, basis) ? project : ProjectMerge.Merge(basis, project, Stored);
|
|
Saves++;
|
|
return Task.FromResult(Stored);
|
|
}
|
|
|
|
public Task<Guid> SubmitAsync(ArchiveJobRequest request, CancellationToken cancellationToken)
|
|
{
|
|
Submitted.Add(request);
|
|
return Task.FromResult(Guid.CreateVersion7());
|
|
}
|
|
|
|
public event Action<Job>? JobChanged;
|
|
|
|
public event Action? ReadOnlyChanged;
|
|
|
|
/// <summary>The server's frames changed under the proxies (as a server sequence finds out).</summary>
|
|
public void MarkOutdated()
|
|
{
|
|
IsOutdated = IsReadOnly = true;
|
|
ReadOnlyChanged?.Invoke();
|
|
}
|
|
|
|
public Task CancelJobAsync(Guid jobId, CancellationToken cancellationToken)
|
|
{
|
|
Cancelled.Add(jobId);
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
public Task RetryJobAsync(Guid jobId, CancellationToken cancellationToken)
|
|
{
|
|
Retried.Add(jobId);
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
public Task<IReadOnlyList<Job>> ListJobsAsync(CancellationToken cancellationToken) => Task.FromResult<IReadOnlyList<Job>>([.. Jobs]);
|
|
|
|
/// <summary>A job of the sequence changed (as the engine or the server reports it).</summary>
|
|
public void Report(Job job) => JobChanged?.Invoke(job);
|
|
|
|
public ValueTask DisposeAsync() => ValueTask.CompletedTask;
|
|
}
|