Routing sizes render jobs from the resolved preset, and the node wait applies the same routing as the claim, so a re-routed job neither keeps a stale size nor waits for a node that will never take it. Settings an older server cannot read stay on this side for the remote editor, archive sync and workspace push, and the reason is shown where it applies. A turn on one side and a framing on the other merge as one conflict. Orientation and framing fixes: an out-of-range crop turns with the content it shows, the aspect text transposes exactly, the Rotation row counts turns as shown on screen, and Reset framing undoes the orientation press by press, so keyframes and aspect stay on their content. The advisor places the horizon in the view as shown. A look at zero strength is cleared and no longer reaches the motion vectors. Preview changes: the middle button pans, a press inside a box with no slack pans while zoomed, the selected box shows a ring, and screen readers hear when the crop value changes. Tooltips in en and it updated; stale translations of changed tooltips removed so they fall back to English. Test changes: the pinned hash is OS-independent, and the tautological encoder and warning assertions became real checks. Added a non-screen test of the Straighten slider binding. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
750 lines
39 KiB
C#
750 lines
39 KiB
C#
using System.Collections.Specialized;
|
||
using System.Globalization;
|
||
using System.IO;
|
||
using System.Net.Http;
|
||
using System.Windows;
|
||
using System.Windows.Controls;
|
||
using System.Windows.Input;
|
||
using System.Windows.Media;
|
||
using System.Windows.Media.Imaging;
|
||
using System.Windows.Threading;
|
||
using Chronos.App.DesignTime;
|
||
using Chronos.App.Editor;
|
||
using Chronos.App.Infrastructure;
|
||
using Chronos.App.Sections;
|
||
using Chronos.App.Shell;
|
||
using Chronos.App.Tests.Windows;
|
||
using Chronos.Core.Advice;
|
||
using Chronos.Core.Analysis;
|
||
using Chronos.Core.Export;
|
||
using Chronos.Core.Localization;
|
||
using Chronos.Core.Model;
|
||
using Chronos.Core.Project;
|
||
using Chronos.Core.Render;
|
||
using Chronos.Testing;
|
||
using Chronos.Ui.Controls;
|
||
using Chronos.Ui.Theming;
|
||
using Chronos.Ui.Visuals;
|
||
|
||
namespace Chronos.App.Tests.Editor;
|
||
|
||
/// <summary>
|
||
/// The sequence editor in the real main window, off screen at the minimum capture size, on the synthetic sunset of
|
||
/// <c>--capture</c> (real JPEG frames, deep analysis, advised project): every section shows its measuring tool, its
|
||
/// settings and preview pixels in both themes, and an edit goes through undo and redo.
|
||
/// </summary>
|
||
[WindowsOnly]
|
||
[Serial]
|
||
[Timeout(300_000)]
|
||
public sealed class EditorSmokeTests
|
||
{
|
||
private static readonly AppTheme[] Themes = [AppTheme.Dark, AppTheme.Light];
|
||
|
||
/// <summary>Here rather than with the other texts: it switches the UI language, which only a serial class may do.</summary>
|
||
[Test]
|
||
public void AnOptimiseLinePointsFromTheOldValueToTheNewOneInEitherReadingDirection()
|
||
{
|
||
var change = new SettingChange(AdvisorParameters.DeflickerWindow, 21, 41, "reason", []);
|
||
try
|
||
{
|
||
Loc.SetCulture(CultureInfo.GetCultureInfo("en"));
|
||
Assert.Equal("Deflicker window: 21 frames → 41 frames", EditorText.Change(change));
|
||
Loc.SetCulture(CultureInfo.GetCultureInfo("ar"));
|
||
Assert.Equal(Loc.L("Editor.Optimise.ChangeRtl", Loc.L("Editor.Exposure.Window"), Loc.Plural("Editor.Value.Frames", 21), Loc.Plural("Editor.Value.Frames", 41)),
|
||
EditorText.Change(change), "Arabic reads the old value first, from the right");
|
||
Assert.Contains("←", EditorText.Change(change));
|
||
}
|
||
finally
|
||
{
|
||
Loc.SetCulture(CultureInfo.GetCultureInfo("en"));
|
||
}
|
||
}
|
||
|
||
[Test]
|
||
public Task EverySectionOfTheEditorRendersInBothThemes() => ScreenHost.RunAsync(async () =>
|
||
{
|
||
var environment = AppEnvironment.ForCapture();
|
||
UiLanguage.Apply("en");
|
||
ThemeManager.Apply(AppTheme.Dark);
|
||
var services = new AppServices(environment, new AppSettings { Language = "en", FirstRunCompleted = true }, () => { }, new NoDialogs());
|
||
var sample = SampleData.Configure(services);
|
||
var shell = new ShellViewModel(services);
|
||
var window = new MainWindow(shell)
|
||
{
|
||
WindowStartupLocation = WindowStartupLocation.Manual,
|
||
Left = -20000,
|
||
Top = -20000,
|
||
Width = 1200,
|
||
Height = 788,
|
||
ShowActivated = false,
|
||
ShowInTaskbar = false,
|
||
};
|
||
window.Show();
|
||
try
|
||
{
|
||
await sample.OpenEmptyAsync();
|
||
await shell.StartAsync();
|
||
var id = await sample.FillEditorAsync();
|
||
shell.OpenSequence(id);
|
||
await shell.Sequence.OpenAsync(id);
|
||
var editor = Assert.NotNull(shell.Sequence.Editor);
|
||
Assert.Equal(96, editor.FrameCount);
|
||
Assert.NotNull(editor.Session.Content.Deep, "the sample is analysed");
|
||
Assert.True(editor.Session.Project.Exposure.Deflicker.HasAdvice, "the advice is in the project");
|
||
Assert.Equal("Harbour sunset", editor.Title);
|
||
Assert.Equal("Chronos — Harbour sunset", shell.WindowTitle, "the window title follows the open sequence");
|
||
Assert.False(shell.IsJobBarVisible, "the idle job bar gives its height to the editor");
|
||
|
||
// The Render split button can be clicked once the plan exists (its command re-reads its state).
|
||
Assert.True(await editor.WhenIdleAsync(TimeSpan.FromSeconds(60)), "the editor settled");
|
||
await SettleAsync(window);
|
||
Assert.True(editor.CanRender, editor.RenderBlockedReason ?? "renderable");
|
||
var render = Find<SplitButton>(window).Single(b => b.IsVisible);
|
||
Assert.True(Find<Button>(render).First().IsEnabled, "Render is enabled");
|
||
|
||
foreach (var theme in Themes)
|
||
{
|
||
ThemeManager.Apply(theme);
|
||
foreach (var tab in editor.Tabs)
|
||
{
|
||
editor.SelectedTab = tab;
|
||
await SettleAsync(window);
|
||
Assert.True(await editor.WhenIdleAsync(TimeSpan.FromSeconds(60)), $"{tab.Key}: still busy");
|
||
await SettleAsync(window);
|
||
var view = Find<SequenceView>(window).Single(v => v.IsVisible);
|
||
Assert.NotNull(editor.PreviewImage, $"{tab.Key}: the preview shows pixels");
|
||
ExpectMeasure(view, tab);
|
||
Assert.True(Find<ContentPresenter>(view).Any(p => ReferenceEquals(p.Content, tab) && p.ActualHeight > 100), $"{tab.Key}: settings column");
|
||
Assert.Greater(Distinct(Render(window)), 40, $"{tab.Key} drew almost nothing in {theme}");
|
||
}
|
||
}
|
||
|
||
// The Export tab: Add to queue and Batch follow the plan and the ticked presets.
|
||
ThemeManager.Apply(AppTheme.Dark);
|
||
var export = editor.Tabs.OfType<ExportTab>().Single();
|
||
editor.ShowVectors = true;
|
||
editor.SelectedTab = export;
|
||
await SettleAsync(window);
|
||
Assert.False(Find<PreviewViewport>(window).Single(p => p.IsVisible).ShowVectors, "a tool without a button on the Export tab draws nothing");
|
||
Assert.True(export.AddToQueueCommand.CanExecute(null));
|
||
Assert.False(export.BatchCommand.CanExecute(null), "nothing ticked");
|
||
var batchButton = Find<Button>(window).Single(b => ReferenceEquals(b.Command, export.BatchCommand));
|
||
Assert.False(batchButton.IsEnabled);
|
||
export.Cards.First(c => c.CanBatch).IsInBatch = true;
|
||
await SettleAsync(window);
|
||
Assert.True(batchButton.IsEnabled, "ticking a card enables Batch…");
|
||
editor.ShowVectors = false;
|
||
|
||
// The waveform of the Exposure tab is measured from the preview.
|
||
editor.SelectedTab = editor.Exposure;
|
||
editor.Exposure.ChartMode = ExposureChart.Waveform;
|
||
Assert.True(await editor.WhenIdleAsync(TimeSpan.FromSeconds(60)));
|
||
Assert.NotNull(editor.WaveformImage, "the waveform shows the frame on screen");
|
||
editor.Exposure.ChartMode = ExposureChart.Luminance;
|
||
|
||
// 1:1 renders the source's own pixels; Fit returns to the view's size.
|
||
editor.ZoomMode = PreviewZoomMode.Actual;
|
||
Assert.True(await editor.WhenIdleAsync(TimeSpan.FromSeconds(60)));
|
||
Assert.Equal(editor.Session.Content.SourceWidth, ((BitmapSource)editor.PreviewImage!).PixelWidth, "1:1 shows source pixels");
|
||
editor.ZoomMode = PreviewZoomMode.Fit;
|
||
|
||
// A language switch makes again what the tabs keep in objects: the chart legend and the Auto chips follow at once.
|
||
var chip = editor.Exposure.Rows.OfType<AutoSwitchRow>().First();
|
||
var english = chip.AutoText;
|
||
UiLanguage.Apply("it");
|
||
try
|
||
{
|
||
Assert.True(editor.Exposure.Legend.Any(i => i.Text == "luminanza misurata"), "the legend follows the language");
|
||
Assert.Equal(Loc.L("Common.Auto") + Loc.Separator + Loc.L(chip.IsOn ? "Editor.Value.On" : "Editor.Value.Off"), chip.AutoText);
|
||
Assert.NotEqual(english, chip.AutoText);
|
||
}
|
||
finally
|
||
{
|
||
UiLanguage.Apply("en");
|
||
}
|
||
|
||
// An edit through the session is undone and redone (Ctrl+Z / Ctrl+Y run the same commands).
|
||
ThemeManager.Apply(AppTheme.Dark);
|
||
var before = editor.Session.Project.Exposure.ExposureOffsetEv;
|
||
editor.Session.Edit(p => p with { Exposure = p.Exposure with { ExposureOffsetEv = 0.5 } });
|
||
editor.UndoCommand.Execute(null);
|
||
Assert.Equal(before, editor.Session.Project.Exposure.ExposureOffsetEv);
|
||
editor.RedoCommand.Execute(null);
|
||
Assert.Equal(0.5, editor.Session.Project.Exposure.ExposureOffsetEv);
|
||
await editor.Session.FlushAsync();
|
||
Assert.True(await editor.WhenIdleAsync(TimeSpan.FromSeconds(60)));
|
||
Assert.NotNull(editor.Plan, "the export is planned");
|
||
}
|
||
finally
|
||
{
|
||
ThemeManager.Apply(AppTheme.Dark);
|
||
window.Close();
|
||
await shell.Sequence.CloseAsync();
|
||
shell.Dispose();
|
||
await services.DisposeAsync();
|
||
environment.DeleteCaptureData();
|
||
}
|
||
});
|
||
|
||
/// <summary>
|
||
/// A server sequence opened with this PC's proxies (the sample server's Sunrise over Superga): the header names the
|
||
/// server, the preview shows a proxy, Save to and Sync wait for the server, and Render posts a server job.
|
||
/// </summary>
|
||
[Test]
|
||
public Task AServerSequenceOpensWithItsProxies() => ScreenHost.RunAsync(async () =>
|
||
{
|
||
var environment = AppEnvironment.ForCapture();
|
||
UiLanguage.Apply("en");
|
||
ThemeManager.Apply(AppTheme.Dark);
|
||
var services = new AppServices(environment, new AppSettings { Language = "en", FirstRunCompleted = true }, () => { }, new NoDialogs());
|
||
var sample = SampleData.Configure(services);
|
||
var shell = new ShellViewModel(services);
|
||
var window = new MainWindow(shell)
|
||
{
|
||
WindowStartupLocation = WindowStartupLocation.Manual,
|
||
Left = -20000,
|
||
Top = -20000,
|
||
Width = 1200,
|
||
Height = 788,
|
||
ShowActivated = false,
|
||
ShowInTaskbar = false,
|
||
};
|
||
window.Show();
|
||
try
|
||
{
|
||
await sample.OpenEmptyAsync();
|
||
await shell.StartAsync();
|
||
await sample.FillAsync();
|
||
await services.Server.RestoreAsync();
|
||
await services.Sync.RefreshAsync();
|
||
await sample.CacheProxiesAsync();
|
||
var id = sample.ProxiedSequenceId;
|
||
shell.OpenSequence(id);
|
||
await shell.Sequence.OpenAsync(id);
|
||
var editor = Assert.NotNull(shell.Sequence.Editor);
|
||
Assert.True(editor.IsRemote);
|
||
Assert.Equal("Studio NAS", editor.RemoteText);
|
||
Assert.Equal(3, editor.FrameCount);
|
||
Assert.True(await editor.WhenIdleAsync(TimeSpan.FromSeconds(60)), "the editor settled");
|
||
await SettleAsync(window);
|
||
Assert.NotNull(editor.PreviewImage, "the preview shows a proxy");
|
||
var view = Find<SequenceView>(window).Single(v => v.IsVisible);
|
||
Assert.True(Find<StatusGlyph>(view).Any(g => g is { Kind: StatusKind.Remote, IsVisible: true, Text: "Studio NAS" }), "the header names the server");
|
||
Assert.Greater(Distinct(Render(window)), 40, "the remote editor drew almost nothing");
|
||
|
||
var export = editor.Tabs.OfType<ExportTab>().Single();
|
||
editor.SelectedTab = export;
|
||
await SettleAsync(window);
|
||
Assert.Equal(ExportSyncGate.Remote, editor.SyncGate);
|
||
Assert.False(Find<CheckBox>(view).Single(c => ReferenceEquals(c.DataContext, export) && c.IsVisible).IsEnabled, "Sync: the server's renders stay there");
|
||
Assert.False(Find<ComboBox>(view).Single(c => ReferenceEquals(c.ItemsSource, export.SaveChoices)).IsEnabled, "Save to: the server's exports folder");
|
||
|
||
Assert.True(editor.CanRender, editor.RenderBlockedReason ?? "renderable");
|
||
await editor.RenderAsync(JobPriority.User, batch: false);
|
||
var queued = Assert.Contains(await editor.Session.Source.ListJobsAsync(CancellationToken.None), _ => true);
|
||
Assert.Equal(JobKind.Render, queued.Kind);
|
||
|
||
// Without the Edit right a server sequence is only shown: every change is disabled and says why.
|
||
var content = EditorFixture.Content(EditorFixture.Sunset);
|
||
var looking = new EditorSession(new FakeSequenceSource(EditorFixture.Sunset, content) { IsRemote = true, IsReadOnly = true }, content, []);
|
||
var viewer = new EditorViewModel(shell, looking, [], EncoderHost.Client);
|
||
await using (viewer)
|
||
{
|
||
Assert.False(viewer.IsEditable);
|
||
Assert.Equal(Loc.L("Tooltips.Editor.ReadOnly"), viewer.LockedToolTip);
|
||
Assert.Equal(Loc.L("Tooltips.Editor.ReadOnly"), viewer.Frames.HeroToolTip);
|
||
Assert.False(viewer.Frames.SetHeroCommand.CanExecute(null));
|
||
Assert.False(viewer.OptimiseAllCommand.CanExecute(null));
|
||
Assert.False(viewer.AnalyseCommand.CanExecute(null));
|
||
}
|
||
|
||
// A failed save says why in one localized sentence (BRIEF §0.2 rule 6); the exception's own text stays in the log.
|
||
// The editor's own reasons keep their sentence (they are I/O failures too, which would read "does not answer").
|
||
var toasts = new List<Toast>();
|
||
NotifyCollectionChangedEventHandler collect = (_, e) => toasts.AddRange(e.NewItems?.OfType<Toast>() ?? []);
|
||
shell.PendingToasts.CollectionChanged += collect;
|
||
try
|
||
{
|
||
foreach (var (remote, failure, cause) in new (bool, Exception, string)[]
|
||
{
|
||
(true, new HttpRequestException("No such host is known."), "Server.Error.Unreachable"),
|
||
(false, new UnauthorizedAccessException(@"Access to the path 'D:\Archive\.chronos\sequence.json' is denied."), "Archive.Failed.Access"),
|
||
(true, new ProxiesOutdatedException(Loc.L("Editor.Error.FramesChanged")), "Editor.Error.FramesChanged"),
|
||
(true, new EditorException(Loc.L("Editor.Error.RemoteReadOnly")), "Editor.Error.RemoteReadOnly"),
|
||
(false, new EditorException(Loc.L("Editor.Error.SaveConflict")), "Editor.Error.SaveConflict"),
|
||
(false, new EditorException(Loc.L("Editor.Error.Project"), new InvalidDataException("project.json version 9 is newer")), "Editor.Error.Project"),
|
||
})
|
||
{
|
||
toasts.Clear();
|
||
var saving = new FakeSequenceSource(EditorFixture.Sunset, content) { IsRemote = remote, FailNextSave = failure };
|
||
var failing = new EditorViewModel(shell, new EditorSession(saving, content, []), [], EncoderHost.Client);
|
||
await using (failing)
|
||
{
|
||
failing.Session.Edit(p => p with { HeroFrame = 1 });
|
||
Assert.False(await failing.Session.FlushAsync(), "the save failed");
|
||
var toast = Assert.Contains(toasts, t => t.Title == Loc.L("Editor.Save.Failed"));
|
||
Assert.Equal(Loc.L(cause), toast.Message);
|
||
}
|
||
}
|
||
}
|
||
finally
|
||
{
|
||
shell.PendingToasts.CollectionChanged -= collect;
|
||
}
|
||
}
|
||
finally
|
||
{
|
||
window.Close();
|
||
await shell.Sequence.CloseAsync();
|
||
shell.Dispose();
|
||
await services.DisposeAsync();
|
||
environment.DeleteCaptureData();
|
||
}
|
||
});
|
||
|
||
/// <summary>
|
||
/// Frames inserted under the editor (a sync download, an import of earlier photos) move the frame on screen with its
|
||
/// photo: what the frame actions (Exclude, Set hero, a keyframe) apply to stays the photo the user looks at.
|
||
/// </summary>
|
||
[Test]
|
||
public Task TheFrameOnScreenStaysWhenFramesAreInsertedBeforeIt() => ScreenHost.RunAsync(async () =>
|
||
{
|
||
await using var app = await ScreenSmokeTests.SampleApp.StartAsync();
|
||
var content = EditorFixture.Content(EditorFixture.Sunset, deep: false);
|
||
var source = new FakeSequenceSource(EditorFixture.Sunset, content);
|
||
var editor = new EditorViewModel(app.Shell, new EditorSession(source, content, []), [], EncoderHost.Client);
|
||
await using (editor)
|
||
{
|
||
editor.CurrentIndex = 5;
|
||
var shown = content.Frames[5].Id;
|
||
// An earlier photo arrives and the last frame goes: as many frames as before, each one place later.
|
||
var first = content.Frames[0];
|
||
IReadOnlyList<Chronos.Core.Model.Frame> frames =
|
||
[.. new[] { first with { Id = Guid.CreateVersion7(), CapturedAt = first.CapturedAt!.Value.AddMinutes(-1) } }.Concat(content.Frames.SkipLast(1))
|
||
.Select((f, i) => f with { Index = i })];
|
||
source.Content = content with { Frames = frames, Light = LightAnalyzer.Analyze(frames) };
|
||
|
||
await editor.Session.ReloadAsync();
|
||
|
||
Assert.Equal(6, editor.CurrentIndex);
|
||
Assert.Equal(shown, editor.Session.Content.Frames[editor.CurrentIndex].Id);
|
||
Assert.Equal(6, editor.Frames.Selected?.Index);
|
||
}
|
||
});
|
||
|
||
/// <summary>
|
||
/// A Reorganize of this PC moves the folder of the sequence open in the editor: the editor reads it again where it is
|
||
/// now as soon as its step is done, so its frames decode and its project goes there.
|
||
/// </summary>
|
||
[Test]
|
||
public Task AnOpenSequenceIsReadAgainWhereAReorganizeMovedIt() => ScreenHost.RunAsync(async () =>
|
||
{
|
||
await using var app = await ScreenSmokeTests.SampleApp.StartAsync();
|
||
var id = await app.Sample.FillEditorAsync();
|
||
var db = app.Services.Database!;
|
||
var archives = app.Services.Archives!;
|
||
var source = new LocalSequenceSource(db, id, Chronos.Core.Imaging.Decoders.DecoderFactory.CreateClient(null), null);
|
||
var content = await source.LoadAsync(CancellationToken.None);
|
||
var editor = new EditorViewModel(app.Shell, new EditorSession(source, content, []), [], EncoderHost.Client);
|
||
await using (editor)
|
||
{
|
||
var archive = (await db.Archives.GetAsync(content.Sequence.ArchiveId))!;
|
||
var templates = new Chronos.Core.Archiving.RenameTemplates("Moved/{date}");
|
||
var plan = await archives.PlanReorganizeAsync(archive.Id, [id], templates, CancellationToken.None);
|
||
var moved = plan.Steps.Single().ToFolder;
|
||
await using var engine = new Chronos.Data.Jobs.JobEngine(db, archives.CreateJobHandlers(), new Chronos.Data.Jobs.JobEngineOptions
|
||
{
|
||
WorkerId = "test",
|
||
Kinds = [JobKind.Move],
|
||
PollInterval = TimeSpan.FromMilliseconds(50),
|
||
});
|
||
await engine.StartAsync(CancellationToken.None);
|
||
var job = await Chronos.Data.Archiving.ArchiveJobs.EnqueueAsync(engine, Chronos.Data.Archiving.ArchiveJobs.Reorganize(archive, plan, templates));
|
||
// The editor reads its photos as it opens; on Windows the folder cannot move while one is open, and the job that
|
||
// failed holds the plan for its retry.
|
||
for (var attempt = 1; ; attempt++)
|
||
{
|
||
Job? ended = null;
|
||
for (var i = 0; i < 1200 && ended is null; i++)
|
||
{
|
||
await Task.Delay(25);
|
||
if (await db.Jobs.GetAsync(job.Id) is { State: JobState.Done or JobState.Failed or JobState.Cancelled } now) ended = now;
|
||
}
|
||
Assert.NotNull(ended, "the move job ends");
|
||
if (ended!.State == JobState.Done) break;
|
||
Assert.True(ended.State == JobState.Failed && attempt < 20, ended.Error);
|
||
await Task.Delay(250);
|
||
await engine.ResumeAsync(job.Id, CancellationToken.None);
|
||
}
|
||
|
||
for (var i = 0; i < 400 && editor.Session.Content.Sequence.Folder != moved; i++) await Task.Delay(25);
|
||
Assert.Equal(moved, editor.Session.Content.Sequence.Folder);
|
||
Assert.True(await source.FramesCurrentAsync(CancellationToken.None), "the editor holds the frames where they are now");
|
||
using var frame = await source.DecodeAsync(0, 32, Chronos.Core.Imaging.DecodePurpose.Thumbnail, CancellationToken.None);
|
||
Assert.NotNull(frame, "its frames decode");
|
||
}
|
||
});
|
||
|
||
/// <summary>
|
||
/// At the 1200 px minimum beside the 200 px rail (owner review 1, R1), the preview's tools stay inside the preview in
|
||
/// every language, crop mask on (the crop-result tool enabled): they take a second line rather than lose Play and Full screen.
|
||
/// </summary>
|
||
[Test]
|
||
public Task ThePreviewToolsStayInsideThePreviewInEveryLanguage() => ScreenHost.RunAsync(async () =>
|
||
{
|
||
await using var app = await ScreenSmokeTests.SampleApp.StartAsync();
|
||
app.Window.Width = 1200;
|
||
app.Window.Height = 788;
|
||
var id = await app.Sample.FillEditorAsync();
|
||
app.Shell.OpenSequence(id);
|
||
await app.Shell.Sequence.OpenAsync(id);
|
||
var editor = Assert.NotNull(app.Shell.Sequence.Editor);
|
||
try
|
||
{
|
||
editor.SelectedTab = editor.Exposure;
|
||
editor.ShowCropMask = true;
|
||
foreach (var language in Languages.Shipped)
|
||
{
|
||
UiLanguage.Apply(language);
|
||
await SettleAsync(app.Window);
|
||
var viewport = Find<PreviewViewport>(app.Window).Single(v => v.IsVisible);
|
||
var (left, right) = Span(viewport, app.Window);
|
||
var tools = Find<System.Windows.Controls.Primitives.ButtonBase>(viewport).Where(b => b.IsVisible).ToList();
|
||
Assert.True(tools.Count >= 8, $"{language}: every tool shows ({tools.Count})");
|
||
foreach (var tool in tools)
|
||
{
|
||
var (start, end) = Span(tool, app.Window);
|
||
Assert.True(start >= left - 0.5 && end <= right + 0.5,
|
||
$"{language}: the tool '{System.Windows.Automation.AutomationProperties.GetName(tool)}{tool.Content}' spans {start:0}–{end:0} px, the preview {left:0}–{right:0} px");
|
||
}
|
||
}
|
||
}
|
||
finally
|
||
{
|
||
UiLanguage.Apply("en");
|
||
await app.Shell.Sequence.CloseAsync();
|
||
}
|
||
});
|
||
|
||
/// <summary>
|
||
/// The Camera step edits the crop box on the preview (owner review 1, R5): its mask is on by default and shows the box the
|
||
/// render fits, a drag on the picture is one undo step, a run of key presses another, the box is locked to the output
|
||
/// proportions with the offsets at 0, and a quarter turn shows the turned view frame.
|
||
/// </summary>
|
||
[Test]
|
||
public Task TheCameraStepEditsTheCropBoxOnThePreview() => ScreenHost.RunAsync(async () =>
|
||
{
|
||
await using var app = await ScreenSmokeTests.SampleApp.StartAsync();
|
||
app.Window.Width = 1200;
|
||
app.Window.Height = 788;
|
||
var id = await app.Sample.FillEditorAsync();
|
||
app.Shell.OpenSequence(id);
|
||
await app.Shell.Sequence.OpenAsync(id);
|
||
var editor = Assert.NotNull(app.Shell.Sequence.Editor);
|
||
try
|
||
{
|
||
editor.SelectedTab = editor.Exposure;
|
||
Assert.False(editor.ShowCropMask, "the other steps keep their mask off");
|
||
Assert.False(editor.CropEditable);
|
||
Assert.Equal(Loc.L("Tooltips.Editor.Preview.View"), editor.PreviewToolTip);
|
||
editor.SelectedTab = editor.Tabs.OfType<CameraTab>().Single();
|
||
Assert.True(editor.ShowCropMask, "on by default on the Camera step");
|
||
Assert.True(editor.CropEditable);
|
||
Assert.Equal(Loc.L("Tooltips.Editor.Preview.CropEdit"), editor.PreviewToolTip);
|
||
Assert.True(await editor.WhenIdleAsync(TimeSpan.FromSeconds(60)));
|
||
await SettleAsync(app.Window);
|
||
|
||
var (width, height) = (editor.Session.Content.SourceWidth, editor.Session.Content.SourceHeight);
|
||
RenderGeometry Geometry() => RenderGeometry.Create(editor.Session.Project.Camera, ExportResolver.Resolve(editor.Session.Project.Export), width, height);
|
||
static Rect RectOf(Chronos.Core.Imaging.Geometry.RectD r) => new(r.X, r.Y, r.Width, r.Height);
|
||
Assert.Equal(RectOf(Geometry().EditableCrop), editor.EditCrop, "the mask is the box the render fits");
|
||
Assert.Equal(editor.EditCrop, editor.CropRect);
|
||
var viewport = Find<PreviewViewport>(app.Window).Single(v => v.IsVisible);
|
||
Assert.True(viewport.CropEditable);
|
||
Assert.Equal(editor.EditCrop, viewport.EditCrop);
|
||
Assert.Equal(editor.CropLockRatio, viewport.CropLockRatio);
|
||
Assert.Equal(editor.PreviewToolTip, viewport.ToolTip);
|
||
|
||
// The bottom-right handle dragged in: one undo step, the box locked, the offsets at 0.
|
||
Point At(double nx, double ny)
|
||
{
|
||
var (x, y) = viewport.View.ToView(nx * viewport.ImageSize.Width, ny * viewport.ImageSize.Height);
|
||
return new Point(x, y);
|
||
}
|
||
var before = editor.Session.Project.Camera;
|
||
var box = viewport.EditCrop;
|
||
viewport.Press(At(box.Right, box.Bottom));
|
||
viewport.DragTo(At(box.X + box.Width * 0.7, box.Y + box.Height * 0.7), aboutCentre: false);
|
||
Assert.Same(before, editor.Session.Project.Camera, "nothing changes while dragging");
|
||
viewport.EndDrag(commit: true);
|
||
var cropped = editor.Session.Project.Camera;
|
||
var crop = Assert.NotNull(cropped.Crop);
|
||
Assert.Approximately(0, cropped.OffsetX, 0);
|
||
Assert.Approximately(0, cropped.OffsetY, 0);
|
||
Assert.Approximately(editor.CropLockRatio, crop[2] / crop[3], 1e-9, "locked to the proportions");
|
||
Assert.Less(crop[3], box.Height);
|
||
Assert.Approximately(box.X, crop[0], 1e-9, "anchored at the opposite corner");
|
||
Assert.Equal(new Rect(crop[0], crop[1], crop[2], crop[3]), editor.EditCrop);
|
||
|
||
// Two nudges are one more step.
|
||
Assert.True(viewport.IsCropSelected, "the press took the box");
|
||
Assert.True(viewport.Nudge(Key.Right, ModifierKeys.None));
|
||
Assert.True(viewport.Nudge(Key.Down, ModifierKeys.None));
|
||
editor.Session.EndEditRun();
|
||
var nudged = Assert.NotNull(editor.Session.Project.Camera.Crop);
|
||
Assert.Approximately(crop[0] + 0.01, nudged[0], 1e-9);
|
||
Assert.Approximately(crop[1] + 0.01, nudged[1], 1e-9);
|
||
editor.UndoCommand.Execute(null);
|
||
Assert.SequenceEqual(crop, editor.Session.Project.Camera.Crop!, "one undo takes both nudges back");
|
||
editor.UndoCommand.Execute(null);
|
||
Assert.SequenceEqual(before.Crop ?? [], editor.Session.Project.Camera.Crop ?? [], "and one more the drag");
|
||
editor.RedoCommand.Execute(null);
|
||
Assert.SequenceEqual(crop, editor.Session.Project.Camera.Crop!);
|
||
|
||
// The straighten grid shows while the slider is used, on the Camera step only.
|
||
editor.IsStraightening = true;
|
||
await SettleAsync(app.Window);
|
||
Assert.True(viewport.ShowGrid);
|
||
editor.IsStraightening = false;
|
||
Assert.False(viewport.ShowGrid);
|
||
|
||
// A quarter turn: the box waits for the turned picture, then maps onto it.
|
||
var ratio = editor.CropLockRatio;
|
||
editor.Session.Edit(p => p with { Camera = p.Camera with { Rotate = 90, Crop = null } });
|
||
Assert.Equal(ratio, editor.CropLockRatio, "the box of the picture on screen until the turned one comes");
|
||
Assert.False(editor.CropEditable, "and it cannot be dragged meanwhile: it would land in the turned frame");
|
||
Assert.False(editor.CommitCropCommand.CanExecute(editor.EditCrop));
|
||
Assert.True(await editor.WhenIdleAsync(TimeSpan.FromSeconds(60)));
|
||
Assert.True(editor.CropEditable, "the turned picture is on screen");
|
||
var picture = (System.Windows.Media.Imaging.BitmapSource)editor.PreviewImage!;
|
||
Assert.Less(picture.PixelWidth, picture.PixelHeight, "the landscape source shows turned");
|
||
Assert.Equal(Geometry().LockRatio, editor.CropLockRatio);
|
||
Assert.Equal(RectOf(Geometry().EditableCrop), editor.EditCrop);
|
||
editor.UndoCommand.Execute(null);
|
||
await editor.Session.FlushAsync();
|
||
Assert.True(await editor.WhenIdleAsync(TimeSpan.FromSeconds(60)));
|
||
|
||
// Read-only and newer-format projects are drawn, never edited.
|
||
var content = EditorFixture.Content(EditorFixture.Sunset);
|
||
foreach (var (source, reason) in new[]
|
||
{
|
||
(new FakeSequenceSource(EditorFixture.Sunset, content) { IsReadOnly = true }, "read-only"),
|
||
(new FakeSequenceSource(EditorFixture.Sunset, content with { Project = content.Project with { Version = ProjectSettings.CurrentVersion + 1 } }), "newer format"),
|
||
})
|
||
{
|
||
var locked = new EditorViewModel(app.Shell, new EditorSession(source, source.Content, []), [], EncoderHost.Client);
|
||
await using (locked)
|
||
{
|
||
locked.SelectedTab = locked.Tabs.OfType<CameraTab>().Single();
|
||
Assert.True(locked.ShowCropMask, reason);
|
||
Assert.False(locked.CropEditable, reason);
|
||
Assert.False(locked.CommitCropCommand.CanExecute(new Rect(0.1, 0.1, 0.5, 0.5)), reason);
|
||
Assert.Equal(Loc.L("Tooltips.Editor.Preview.View"), locked.PreviewToolTip);
|
||
}
|
||
}
|
||
}
|
||
finally
|
||
{
|
||
await app.Shell.Sequence.CloseAsync();
|
||
}
|
||
});
|
||
|
||
/// <summary>
|
||
/// At the 1200 px minimum beside the 200 px rail (owner review 1, R1), a server sequence's job keeps its Cancel whole in every
|
||
/// language, also read-only (the longest place line): the title and the summary give way first (BRIEF §11.5, cancel always stays).
|
||
/// </summary>
|
||
[Test]
|
||
public Task AServerJobKeepsItsCancelAtTheMinimumWidthInEveryLanguage() => ScreenHost.RunAsync(async () =>
|
||
{
|
||
await using var app = await ScreenSmokeTests.SampleApp.StartAsync();
|
||
app.Window.Width = 1200;
|
||
app.Window.Height = 788;
|
||
await app.Sample.FillAsync();
|
||
await app.Services.Server.RestoreAsync();
|
||
await app.Services.Sync.RefreshAsync();
|
||
await app.Sample.CacheProxiesAsync();
|
||
await app.Sample.RestrictAccountAsync();
|
||
var id = app.Sample.ProxiedSequenceId;
|
||
app.Shell.OpenSequence(id);
|
||
await app.Shell.Sequence.OpenAsync(id);
|
||
var editor = Assert.NotNull(app.Shell.Sequence.Editor);
|
||
try
|
||
{
|
||
Assert.True(editor.IsReadOnly, "the account may not edit");
|
||
app.Sample.RunServerRender();
|
||
await editor.AttachJobsAsync();
|
||
Assert.NotNull(editor.ServerJobText, "the server's render shows");
|
||
foreach (var language in Languages.Shipped)
|
||
{
|
||
UiLanguage.Apply(language);
|
||
await SettleAsync(app.Window);
|
||
var cancel = Find<Button>(app.Window).Single(b => b.IsVisible && ReferenceEquals(b.Command, editor.CancelServerJobCommand));
|
||
// Drawn whole: its left edge, its middle and its right edge each take the pointer (a layout clip would not).
|
||
foreach (var x in new[] { 2.0, cancel.ActualWidth / 2, cancel.ActualWidth - 2 })
|
||
{
|
||
var point = cancel.TranslatePoint(new Point(x, cancel.ActualHeight / 2), app.Window);
|
||
Assert.True(app.Window.InputHitTest(point) is DependencyObject hit && IsWithin(hit, cancel),
|
||
$"{language}: Cancel is cut at {x:0} px of its {cancel.ActualWidth:0}");
|
||
}
|
||
}
|
||
}
|
||
finally
|
||
{
|
||
UiLanguage.Apply("en");
|
||
app.Sample.EndServerJobs();
|
||
await app.Shell.Sequence.CloseAsync();
|
||
}
|
||
});
|
||
|
||
/// <summary>
|
||
/// At the 1200 px minimum beside the 200 px rail (owner review 1, R1), the frame table's Time column holds the widest time
|
||
/// of every shipped language (two-digit hours, morning and afternoon marks).
|
||
/// </summary>
|
||
[Test]
|
||
public Task TheFrameTableShowsWholeTimesInEveryLanguage() => ScreenHost.RunAsync(async () =>
|
||
{
|
||
await using var app = await ScreenSmokeTests.SampleApp.StartAsync();
|
||
app.Window.Width = 1200;
|
||
app.Window.Height = 788;
|
||
var id = await app.Sample.FillEditorAsync();
|
||
app.Shell.OpenSequence(id);
|
||
await app.Shell.Sequence.OpenAsync(id);
|
||
var editor = Assert.NotNull(app.Shell.Sequence.Editor);
|
||
try
|
||
{
|
||
editor.SelectedTab = editor.Frames;
|
||
var times = new[] { new DateTime(2026, 1, 1, 12, 59, 59), new DateTime(2026, 1, 1, 22, 58, 48), new DateTime(2026, 1, 1, 10, 48, 58) };
|
||
foreach (var language in Languages.Shipped)
|
||
{
|
||
UiLanguage.Apply(language);
|
||
await SettleAsync(app.Window);
|
||
var cell = Find<TextBlock>(app.Window).First(t => t.IsVisible && t.DataContext is FrameRow row && row.Time.Length > 0 && t.Text == row.Time);
|
||
var widest = times.Max(t => Measure(cell, t.ToString("T", Loc.Culture)));
|
||
Assert.True(widest <= cell.ActualWidth + 1, $"{language}: the widest time needs {widest:0} px, the column gives {cell.ActualWidth:0}");
|
||
}
|
||
}
|
||
finally
|
||
{
|
||
UiLanguage.Apply("en");
|
||
await app.Shell.Sequence.CloseAsync();
|
||
}
|
||
});
|
||
|
||
/// <summary>The width <paramref name="text"/> needs in the font, numerals and formatting of <paramref name="like"/>.</summary>
|
||
private static double Measure(TextBlock like, string text)
|
||
{
|
||
var probe = new TextBlock
|
||
{
|
||
Text = text,
|
||
FontFamily = like.FontFamily,
|
||
FontSize = like.FontSize,
|
||
FontStyle = like.FontStyle,
|
||
FontWeight = like.FontWeight,
|
||
FontStretch = like.FontStretch,
|
||
FlowDirection = like.FlowDirection,
|
||
Language = like.Language,
|
||
};
|
||
System.Windows.Documents.Typography.SetNumeralAlignment(probe, System.Windows.Documents.Typography.GetNumeralAlignment(like));
|
||
TextOptions.SetTextFormattingMode(probe, TextOptions.GetTextFormattingMode(like));
|
||
probe.Measure(new Size(double.PositiveInfinity, double.PositiveInfinity));
|
||
return probe.DesiredSize.Width;
|
||
}
|
||
|
||
private static bool IsWithin(DependencyObject node, DependencyObject ancestor)
|
||
{
|
||
for (var at = node; at is not null; at = VisualTreeHelper.GetParent(at))
|
||
{
|
||
if (ReferenceEquals(at, ancestor)) return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
/// <summary>The left and right edges of an element in window coordinates, whichever way the window reads.</summary>
|
||
private static (double Left, double Right) Span(FrameworkElement element, Window window)
|
||
{
|
||
var a = element.TranslatePoint(new Point(0, 0), window).X;
|
||
var b = element.TranslatePoint(new Point(element.ActualWidth, 0), window).X;
|
||
return (Math.Min(a, b), Math.Max(a, b));
|
||
}
|
||
|
||
/// <summary>The measuring tool of each section has content.</summary>
|
||
private static void ExpectMeasure(SequenceView view, EditorTab tab)
|
||
{
|
||
switch (tab)
|
||
{
|
||
case AnalysisTab analysis:
|
||
// The findings, each with the step that deals with it, or the sentence that there are none.
|
||
Assert.True(Find<ListBoxItem>(view).Any(i => i.DataContext is AnalysisFinding && i.IsVisible)
|
||
|| Find<EmptyState>(view).Any(e => e.IsVisible && e.Message == analysis.EmptyText), "Analysis: findings or why there are none");
|
||
break;
|
||
case FramesTab frames:
|
||
Assert.Equal(96, frames.Frames.Count);
|
||
Assert.NotEmpty(Find<ListBoxItem>(view).Where(i => i.DataContext is FrameRow && i.IsVisible));
|
||
break;
|
||
case CameraTab or TimeTab:
|
||
Assert.NotEmpty(Find<CurveEditor>(view).Where(c => c.IsVisible && c.ActualHeight > 50));
|
||
break;
|
||
case ExportTab export:
|
||
Assert.NotEmpty(export.Cards);
|
||
Assert.NotEmpty(Find<Button>(view).Where(b => b.DataContext is PresetCard && b.IsVisible));
|
||
Assert.True(export.Cards.Any(c => c.Estimate is not null), "estimates on the cards");
|
||
break;
|
||
default:
|
||
var chart = Find<SeriesChart>(view).Single(c => c.IsVisible);
|
||
Assert.True(chart.ActualHeight > 50, $"{tab.Key}: chart height");
|
||
Assert.NotEmpty(chart.Series!);
|
||
break;
|
||
}
|
||
}
|
||
|
||
private static async Task SettleAsync(Window window)
|
||
{
|
||
window.UpdateLayout();
|
||
await window.Dispatcher.InvokeAsync(() => { }, DispatcherPriority.ApplicationIdle);
|
||
await Task.Delay(30);
|
||
await window.Dispatcher.InvokeAsync(() => { }, DispatcherPriority.ApplicationIdle);
|
||
window.UpdateLayout();
|
||
}
|
||
|
||
private static RenderTargetBitmap Render(Window window)
|
||
{
|
||
var root = (FrameworkElement)VisualTreeHelper.GetChild(window, 0);
|
||
var dpi = VisualTreeHelper.GetDpi(window);
|
||
var bitmap = new RenderTargetBitmap((int)Math.Ceiling(root.ActualWidth * dpi.DpiScaleX), (int)Math.Ceiling(root.ActualHeight * dpi.DpiScaleY),
|
||
dpi.PixelsPerInchX, dpi.PixelsPerInchY, PixelFormats.Pbgra32);
|
||
bitmap.Render(root);
|
||
return bitmap;
|
||
}
|
||
|
||
private static int Distinct(BitmapSource bitmap)
|
||
{
|
||
var pixels = new byte[bitmap.PixelWidth * bitmap.PixelHeight * 4];
|
||
bitmap.CopyPixels(pixels, bitmap.PixelWidth * 4, 0);
|
||
var colours = new HashSet<int>();
|
||
for (var i = 0; i < pixels.Length && colours.Count < 2000; i += 4 * 5) colours.Add(BitConverter.ToInt32(pixels, i));
|
||
return colours.Count;
|
||
}
|
||
|
||
private static List<T> Find<T>(DependencyObject root)
|
||
where T : DependencyObject
|
||
{
|
||
var found = new List<T>();
|
||
var stack = new Stack<DependencyObject>([root]);
|
||
while (stack.TryPop(out var node))
|
||
{
|
||
if (node is T match) found.Add(match);
|
||
for (var i = 0; i < VisualTreeHelper.GetChildrenCount(node); i++) stack.Push(VisualTreeHelper.GetChild(node, i));
|
||
}
|
||
return found;
|
||
}
|
||
|
||
/// <summary>Dialogs that answer like a user who cancels everything.</summary>
|
||
private sealed class NoDialogs : IAppDialogs
|
||
{
|
||
public string? PickFolder(string title, string? initialFolder = null) => null;
|
||
public string? PickJsonFile(string title) => null;
|
||
public bool Confirm(ConfirmRequest request) => false;
|
||
public bool SignIn(string server, string? username, Func<string, string, Task<string?>> signIn) => false;
|
||
}
|
||
}
|