using Chronos.Core.Advice; using Chronos.Core.Diagnostics; using Chronos.Core.Export; using Chronos.Core.Imaging.Geometry; using Chronos.Core.Model; using Chronos.Core.Project; using Chronos.Core.Render; using Chronos.Core.Video; using Chronos.Data.Archiving.Jobs; using Chronos.Data.Processing; using Chronos.Data.Projects; namespace Chronos.App.Editor; /// /// One sequence open in the editor (BRIEF §12.3): its content, the advisor's view of it (§10.3), the project with undo /// and redo, and the actions of every section — edit, Optimise (§10.4), Reset, exclusions and hero, analysis and render /// jobs. Every change is saved shortly after it is made (); a change stored meanwhile by /// someone else (an analysis job, another client) is merged in. On a server sequence, settings both sides changed to /// different values wait for the user's choice (). Frames inserted under the editor (a sync /// download, an import of earlier photos, a scan) are read again before the next save or render, and the project's frame /// positions, its undo steps included, move with their frames as the stored ones did. Call from one thread (the UI thread). /// public sealed class EditorSession : IAsyncDisposable { public static readonly TimeSpan DefaultSaveDelay = TimeSpan.FromMilliseconds(400); /// Times a save reads the frames again when frames keep changing under it. private const int FollowAttempts = 3; /// Sections "Optimise all" walks through, in panel order. public static IReadOnlyList OptimisedSections { get; } = [AdvisorSection.Frames, AdvisorSection.Timing, AdvisorSection.Exposure, AdvisorSection.Motion, AdvisorSection.Camera, AdvisorSection.Export]; private readonly IReadOnlyList _codecs; private readonly ProjectSaver _saver; private ProjectSettings _basis; /// /// The sequence being read again () until its content is taken: saves and other reads wait /// for it. /// private Task _reading = Task.CompletedTask; public EditorSession(ISequenceSource source, SequenceContent content, IReadOnlyList codecs, TimeSpan? saveDelay = null) { ArgumentNullException.ThrowIfNull(source); ArgumentNullException.ThrowIfNull(content); Source = source; _codecs = codecs ?? []; _basis = content.Project; // Undo steps take outside changes as the source merges them (a workspace project: positions photo by photo). History = new ProjectHistory(content.Project, merge: (basis, ours, theirs) => source.Merge(basis, ours, theirs).Merged); History.Changed += OnProjectChanged; _saver = new ProjectSaver(SaveAsync, saveDelay ?? DefaultSaveDelay); _saver.Failed += OnSaveFailed; (Content, Context, Advice, Presets) = Analyse(content, _codecs); } /// The project changed (edit, undo, redo, Optimise, a merge). public event Action? ProjectChanged; /// The sequence was read again (after an analysis): frames, reports, advice and presets. public event Action? ContentChanged; /// /// Saving the project failed (raised once per run of failures; the save is retried until it succeeds). A conflict /// raises instead. /// public event Action? SaveFailed; /// A save met settings changed on the server too ( was null): the user picks a side. public event Action? ConflictFound; /// /// An edit not stored yet met a newer Chronos's settings stored meanwhile, which this one never merges with: the edit /// was kept aside at the path given () and the newer settings shown read-only. /// public event Action? EditSetAside; public ISequenceSource Source { get; } /// A server sequence edited with proxies: saved, analysed and rendered on the server. public bool IsRemote => Source.IsRemote; /// The project is shown, not changed (): edits, undo and redo do nothing. public bool IsReadOnly => Source.IsReadOnly; public SequenceContent Content { get; private set; } public SequenceContext Context { get; private set; } /// The advisor's recommendations and findings for the current analyses. public AdvisorResult Advice { get; private set; } /// Sequence presets that fit the content, best first (BRIEF §10.3). public IReadOnlyList Presets { get; private set; } public ProjectHistory History { get; } public ProjectSettings Project => History.Current; /// A change is waiting for its save, being saved, or waiting for a retry after a failed save. public bool HasPendingSave => _saver.HasPendingChanges; /// Why the pending change could not be stored; null when the last save succeeded. public Exception? LastSaveError => _saver.LastError; /// /// Settings this editor and someone on the server changed to different values, as the last save found them; null /// when there are none. Saves wait (they are retried and meet it again) until . /// public ProjectConflictException? Conflict { get; private set; } /// /// Applies as an undoable step; false when it changes nothing. A crop box locked to the /// output proportions follows a change of them () in the same step. /// /// Consecutive edits with the same key are one undo step (a slider drag). public bool Edit(Func change, string? mergeKey = null) { ArgumentNullException.ThrowIfNull(change); if (IsReadOnly) return false; var before = Project; return History.Apply(KeepCropLocked(before, change(before), Content.SourceWidth, Content.SourceHeight), mergeKey); } /// /// One press of the Camera step's orientation controls (Rotate left or right, Mirror, Flip) as one undo step: the /// picture turns or mirrors as the user sees it, and the crop and the keyframes with it (, /// owner review 1, R6). /// public bool Orient(OrientationOp op) => Edit(p => OrientationEdit.Apply(p, op)); /// /// "Reset framing": the crop, its offsets, the rotation, mirror, flip and straighten cleared as one undo step; the /// keyframes stay (). /// public bool ResetFraming() => Edit(WithoutFraming); /// The crop's width over its height in normalised view units for (). public double CropLockRatio(ProjectSettings project) => LockRatioOf(project, Content.SourceWidth, Content.SourceHeight); /// /// The lock ratio of the Camera step's crop (): the output ratio the render fits /// the crop to, in units of the view frame of a source of the given size; a 1×1 view when the size is unknown. /// public static double LockRatioOf(ProjectSettings project, int sourceWidth, int sourceHeight) { ArgumentNullException.ThrowIfNull(project); var (width, height) = sourceWidth > 0 && sourceHeight > 0 ? (sourceWidth, sourceHeight) : (1, 1); return RenderGeometry.Create(project.Camera, ExportResolver.Resolve(project.Export), width, height).LockRatio; } /// /// The project without framing: no crop, no offsets, no rotation, mirror, flip or straighten. The orientation is undone /// press by press (: the flip, the mirror, then quarter turns back), so the keyframes, the /// parked ones and the aspect stay on the content they framed: a 9:16 set on a quarter-turned landscape is 16:9 again. /// public static ProjectSettings WithoutFraming(ProjectSettings project) { ArgumentNullException.ThrowIfNull(project); var upright = project; if (upright.Camera.Flip) upright = OrientationEdit.Apply(upright, OrientationOp.Flip); if (upright.Camera.Mirror) upright = OrientationEdit.Apply(upright, OrientationOp.Mirror); for (var turns = FrameOrientation.TurnsOf(upright.Camera.Rotate); turns > 0; turns--) upright = OrientationEdit.Apply(upright, OrientationOp.RotateLeft); return upright with { Camera = upright.Camera with { Crop = null, OffsetX = 0, OffsetY = 0, Rotate = 0, Mirror = false, Flip = false, Straighten = 0 } }; } /// Something clears is set. public static bool HasFraming(CameraSettings camera) { ArgumentNullException.ThrowIfNull(camera); return camera.Crop is not null || camera.OffsetX != 0 || camera.OffsetY != 0 || camera.Rotate != 0 || camera.Mirror || camera.Flip || camera.Straighten != 0; } /// /// with its crop refitted to new output proportions (owner review 1, R5: an aspect change, a /// turn of a "source" aspect, an export preset of another shape): a box that was locked to the proportions before keeps /// its centre and area at the new ratio (). A legacy free crop, one placed by offsets, and a /// box already at the new ratio stay as they are (the render fits them, ). /// public static ProjectSettings KeepCropLocked(ProjectSettings before, ProjectSettings after, int sourceWidth, int sourceHeight) { ArgumentNullException.ThrowIfNull(before); ArgumentNullException.ThrowIfNull(after); var camera = after.Camera; if (CropFrame.IsWhole(camera.Crop) || camera.OffsetX != 0 || camera.OffsetY != 0) return after; if (ReferenceEquals(before.Camera, camera) && ReferenceEquals(before.Export, after.Export)) return after; var ratio = LockRatioOf(after, sourceWidth, sourceHeight); var box = CropFrame.Of(camera.Crop); if (IsLocked(box, ratio)) return after; if (before.Camera.OffsetX != 0 || before.Camera.OffsetY != 0 || !IsLocked(CropFrame.Of(before.Camera.Crop), LockRatioOf(before, sourceWidth, sourceHeight))) return after; return after with { Camera = camera with { Crop = CropFrame.ToCrop(CropFrame.Refit(box, ratio)) } }; static bool IsLocked(RectD box, double lockRatio) => double.Abs(box.Width / box.Height / lockRatio - 1) < 1e-6; } /// The drag or key press behind a run of merged edits ended (). public void EndEditRun() => History.EndRun(); public bool Undo() => !IsReadOnly && History.Undo(); public bool Redo() => !IsReadOnly && History.Redo(); /// "Optimise section": the advisor's heavier decisions for , one undo step; returns what changed. public IReadOnlyList Optimise(AdvisorSection section) => Optimise([section]); /// "Optimise all": every section, one undo step. public IReadOnlyList OptimiseAll() => Optimise(OptimisedSections); /// "Reset": the section's Auto settings back to Auto. public bool ResetSection(AdvisorSection section) => Edit(p => EditorSettings.ResetSection(p, section)); /// Adds frames to, or removes them from, the project's exclusions. public bool SetExcluded(IEnumerable frames, bool excluded) { var chosen = frames.Where(i => (uint)i < (uint)Content.Count).ToHashSet(); return Edit(p => p with { ExcludedFrames = excluded ? [.. p.ExcludedFrames.Union(chosen).Order()] : [.. p.ExcludedFrames.Where(i => !chosen.Contains(i))], }); } /// Makes the hero frame (sequence thumbnail). public bool SetHero(int frame) => (uint)frame < (uint)Content.Count && Edit(p => p with { HeroFrame = frame }); /// /// Applies a sequence preset (BRIEF §10.3) as one undoable step: its timing, exposure, motion, aspect and export /// preset; the user's frames (exclusions, hero), crop (refitted to the preset's aspect), orientation, keyframes, remap /// curve, exposure offset, look and output naming stay. /// public bool ApplyPreset(SequencePreset preset) { ArgumentNullException.ThrowIfNull(preset); var s = preset.Settings; return Edit(p => p with { Timing = s.Timing with { RemapCurve = p.Timing.RemapCurve, FitToSeconds = p.Timing.FitToSeconds }, Exposure = s.Exposure with { ExposureOffsetEv = p.Exposure.ExposureOffsetEv, HighlightKnee = p.Exposure.HighlightKnee }, Motion = s.Motion, Camera = p.Camera with { Aspect = s.Camera.Aspect }, Export = p.Export with { Preset = s.Export.Preset, Overrides = new ExportOverrides() }, }); } /// /// A render of with the project as it is now (the job embeds it, so a render queued before /// the save lands still renders what the user sees). /// public ArchiveJobRequest RenderRequest(ExportSettings export, bool useProxies = false) => ProcessingJobs.Render(Content.Sequence, export, Content.SourceWidth, Content.SourceHeight, Project with { Export = export }, useProxies); /// /// The jobs that render and its batch: one job on this PC (the sequence is prepared once), /// one per preset on a server, where a render node uploads one file per job (BRIEF §14.7), and for a workspace project /// one per preset at its home with the project's portable settings (, owner review 2, R8). /// public IReadOnlyList RenderRequests(ExportSettings export) => Source switch { IProjectRenders renders => renders.RenderRequests(Content.Sequence, Project, export, Content.SourceWidth, Content.SourceHeight), _ when IsRemote => ProcessingJobs.RenderEach(Content.Sequence, export, Content.SourceWidth, Content.SourceHeight, Project with { Export = export }), _ => [RenderRequest(export)], }; /// /// A source can save one frame as an image (owner review 1, R8, "Save frame"): a sequence of this PC or of a server, or a /// source that makes its own still jobs (, a workspace project). A source that renders /// elsewhere () without still jobs of its own saves none. /// public bool CanSaveFrames => Source is IProjectStills or not IProjectRenders; /// /// The job that saves frame as one image (one of /// ) at the output size of , with every correction of the /// project as it is now and no playback (): routed as is, /// on this PC's engine or on the server, as one job. The frame is named by its position and by its photo, whose hash /// wins when frames moved meanwhile. Null when the source saves no frames (). /// /// is not a frame of the sequence, or is no still format. public IReadOnlyList? StillRequests(ExportSettings export, VideoCodec codec, int frameIndex) { ArgumentNullException.ThrowIfNull(export); ArgumentOutOfRangeException.ThrowIfGreaterThanOrEqual((uint)frameIndex, (uint)Content.Count, nameof(frameIndex)); var photo = Content.Frames[frameIndex].Sha256; return Source switch { IProjectStills stills => stills.StillRequests(Content.Sequence, Project, export, codec, frameIndex, photo, Content.SourceWidth, Content.SourceHeight), IProjectRenders => null, _ => [ProcessingJobs.Still(Content.Sequence, export, codec, frameIndex, photo, Content.SourceWidth, Content.SourceHeight, Project with { Export = export })], }; } /// /// Makes a "Save both" copy of this PC's settings the project, as one undoable step; null when it stores the same values. /// /// The restore, which its toast can take back while it is the last change. /// The copy cannot be read. public async Task RestoreAsync(SavedCopy copy) { ArgumentNullException.ThrowIfNull(copy); var restored = await Task.Run(() => SavedCopies.Read(copy)); var before = Project; return Edit(_ => restored) ? new ProjectRestore(this, before, Project) : null; } /// /// Settles against the settings stored meanwhile (the server's, a workspace's working state a sync /// wrote) as the last save read them. Both choices first take in what only the other side changed (like any merge, /// without an undo step). then saves the editor's values of the settings both changed; /// otherwise the other side's values become the project as one undoable step, so Ctrl+Z brings the editor's back (and /// saves them). /// /// False when there is no conflict to settle (a later save already went through). public bool ResolveConflict(bool keepMine) { if (Conflict is not { Server: var theirs }) return false; Conflict = null; var basis = _basis; _basis = theirs; try { History.Replace(Source.Merge(basis, Project, theirs).Merged); if (!keepMine) History.Apply(Source.Merge(basis, theirs, Project).Merged); } catch (NewerSettingsException ex) { // Never merged with a newer Chronos's settings: the edit is kept aside, those settings shown read-only. _ = TakeNewerAsync(theirs, ex, CancellationToken.None); return true; } // The change waiting for its retry goes now, on top of the server's settings. _ = _saver.FlushAsync(); return true; } /// The export of the project with preset chosen (own values, no batch). public ExportSettings ExportFor(string presetId) => Project.Export with { Preset = Project.Export.Preset.WithManual(presetId), Overrides = new ExportOverrides(), Batch = [] }; public ArchiveJobRequest AnalysisRequest() => ProcessingJobs.DeepAnalysis([Content.Sequence.Id], Content.Sequence.DisplayTitle); public Task SubmitAsync(ArchiveJobRequest request, CancellationToken cancellationToken = default) => Source.SubmitAsync(request, cancellationToken); /// /// Makes the project's frame positions name the sequence's frames as they are now, before the project is taken along /// (a render embeds it): frames inserted since the last read (a sync download, an import of earlier photos, a scan) /// are read again and the positions follow them (). A server sequence whose frames changed /// becomes outdated instead (: read-only, its renders refused). /// public async Task EnsureFramesAsync(CancellationToken cancellationToken = default) { while (!_reading.IsCompleted) await _reading; var current = await Source.FramesCurrentAsync(cancellationToken); // A read that began meanwhile (a save that met the new frames) may have taken them already: it ends first. while (!_reading.IsCompleted) await _reading; if (!current && !IsRemote) await ReloadAsync(cancellationToken); } /// /// Reads the sequence again (an analysis finished): new reports and advice, the frames with the project's positions /// following them (), the stored project merged into the open one. Saves wait until it is taken, /// and a read waits for the one under way, so each follows the frames the one before it took. A stored project of a /// newer Chronos met with an edit not stored yet is never merged: the edit is kept aside and the newer settings shown /// read-only (). /// public async Task ReloadAsync(CancellationToken cancellationToken = default) { await _saver.FlushAsync(); var taken = await BeginReadAsync(); try { var content = await Source.LoadAsync(cancellationToken); Follow(content); // Settings a server or a sync stored that conflict with the editor's waiting change are not merged over it: that // change's retry meets them and asks (Conflict). ProjectMergeResult? merge = null; try { merge = Conflict is null ? Source.Merge(_basis, Project, content.Project) : null; } catch (NewerSettingsException ex) { await TakeNewerAsync(content.Project, ex, cancellationToken); } if (merge is not null && (!Source.AsksConflicts || !merge.HasConflicts)) { _basis = content.Project; History.Replace(merge.Merged); } } finally { taken.SetResult(); } ContentChanged?.Invoke(); } /// /// Reads the project again after the user took the other side's values of the settings both changed (a workspace /// project's "Take the library's", settled by its sync): what only the other side changed comes in as any merge does, /// without an undo step (: the stored project as keeping the editor's values would have left /// it), then the values taken become the project as one undoable step, so Ctrl+Z brings the editor's back (and saves /// them), as does for a server's. /// /// That step, which a toast's Undo can take back while it is the last change; null when it changed nothing. public async Task TakeOverAsync(ProjectSettings kept, CancellationToken cancellationToken = default) { ArgumentNullException.ThrowIfNull(kept); await _saver.FlushAsync(); var taken = await BeginReadAsync(); ProjectRestore? step = null; try { var content = await Source.LoadAsync(cancellationToken); Follow(content); var basis = _basis; _basis = content.Project; try { History.Replace(Source.Merge(basis, Project, kept).Merged); var before = Project; if (!IsReadOnly && History.Apply(Source.Merge(kept, Project, content.Project).Merged)) step = new ProjectRestore(this, before, Project); } catch (NewerSettingsException ex) { _basis = basis; await TakeNewerAsync(content.Project, ex, cancellationToken); } } finally { taken.SetResult(); } ContentChanged?.Invoke(); return step; } /// Stores pending changes now; false when the save failed (the change stays pending and is retried). public Task FlushAsync() => _saver.FlushAsync(); /// /// Stops retrying a change that could not be stored while the user decides about it (); /// end it with or . /// /// True when a change is still not stored; false when a retry stored it meanwhile (nothing to decide). public Task HoldPendingAsync() => _saver.HoldAsync(); /// The user kept the change: it is retried in the background as before. public void KeepPending() => _saver.Release(); /// The user discarded the change: it is dropped and never written, and nothing more is saved (the editor closes). public void DiscardPending() => _saver.Stop(); /// /// Stores what is pending one last time, stops retrying and releases the source; callers that must not lose an edit /// flush and ask first (SequenceViewModel.ConfirmCloseAsync). /// public async ValueTask DisposeAsync() { History.Changed -= OnProjectChanged; if (!await _saver.FlushAsync()) Log.Warning("editor", $"The last change of {Content.Sequence.DisplayTitle} was not saved", _saver.LastError); _saver.Stop(); await Source.DisposeAsync(); } /// /// Takes as the sequence. Frames inserted or removed since the last read (a sync download, /// an import of earlier photos, a scan) moved the stored project's frame positions with their frames: the editor's /// project, its undo and redo steps and its basis move the same way (), so /// they keep naming the frames the user chose. Call while the read is under way (). /// private void Follow(SequenceContent content) { var before = Content.Frames.Select(f => f.Id).ToList(); (Content, Context, Advice, Presets) = Analyse(content, _codecs); if (before.SequenceEqual(content.Frames.Select(f => f.Id))) return; var after = content.Frames; Log.Info("editor", $"The frames of {content.Sequence.DisplayTitle} changed while it was open; its frame positions follow them"); _basis = Move(_basis); History.Remap(Move); ProjectSettings Move(ProjectSettings project) => NamesFrames(project) && ProjectSettings.FollowFrames(project.ToJson(), before, after) is { } moved ? ProjectSettings.FromJson(moved) : project; } /// /// The stored project is a newer Chronos's () while the editor holds an edit not stored yet, /// which this Chronos can neither merge with it nor store over it (): the edit is /// kept aside by the source (, said by ), never /// dropped silently, and only then are the newer settings taken, read-only, the pending save dropped with it. A source /// that keeps nothing aside, or a set-aside that fails, leaves the editor as it is (logged): the next read tries again. /// Never throws. /// private async Task TakeNewerAsync(ProjectSettings newer, NewerSettingsException cause, CancellationToken cancellationToken) { var unsaved = Project; string? kept; try { kept = await Source.SetAsideAsync(unsaved, cancellationToken); } catch (Exception ex) when (ex is not OutOfMemoryException) { Log.Warning("editor", $"The edit of {Content.Sequence.DisplayTitle} not stored yet could not be kept aside; it stays in the editor", ex); return; } if (kept is null) { Log.Warning("editor", $"The edit of {Content.Sequence.DisplayTitle} not stored yet meets newer settings and stays in the editor: {cause.Message}"); return; } Log.Info("editor", $"The edit of {Content.Sequence.DisplayTitle} not stored yet was kept in {kept}: the stored project is a newer Chronos's ({cause.Message})"); _saver.Drop(); Conflict = null; _basis = newer; History.Replace(newer); EditSetAside?.Invoke(kept); } /// /// Waits for the read under way (two jobs that end together read the sequence one after the other), then marks a new /// one under way until the returned source is completed. /// private async Task BeginReadAsync() { while (!_reading.IsCompleted) await _reading; var taken = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); _reading = taken.Task; return taken; } /// Exclusions, a hero, keyframes or frames waiting for their photos: positions that follow frames. private static bool NamesFrames(ProjectSettings project) => project.ExcludedFrames.Count > 0 || project.HeroFrame is not null || project.Camera.Keyframes.Count > 0 || project.PendingFrames is { Count: > 0 }; private static (SequenceContent, SequenceContext, AdvisorResult, IReadOnlyList) Analyse(SequenceContent content, IReadOnlyList codecs) { var context = SequenceContext.FromFrames(content.Frames, codecs); return (content, context, Advisor.Recommend(content.Light, content.Deep, context), SequencePresets.Generate(content.Light, content.Deep, context)); } private IReadOnlyList Optimise(IReadOnlyList sections) { if (IsReadOnly) return []; var settings = Project; var advice = AdviceFor(settings.Camera); var changes = new List(); foreach (var section in sections) { var result = Advisor.Optimise(section, settings, advice); settings = result.Settings; changes.AddRange(result.Changes); } History.Apply(KeepCropLocked(Project, settings, Content.SourceWidth, Content.SourceHeight)); return changes; } /// /// The advice for the view of : while the camera is not turned, flipped or straightened, /// else worked out again on the turned view (), so that "Optimise" after a turn /// keeps the transposed aspect wrote instead of the unturned one. /// private AdvisorResult AdviceFor(CameraSettings camera) => camera.Rotate == Context.Rotate && camera.Flip == Context.Flip && camera.Straighten.Equals(Context.Straighten) ? Advice : Advisor.Recommend(Content.Light, Content.Deep, Context.ForCamera(camera)); private void OnSaveFailed(Exception ex, int failures) { // A conflict is retried without the network until the user settles it: noted once, when it is found. if (ex is ProjectConflictException) return; Log.Warning("editor", $"Saving the project of {Content.Sequence.DisplayTitle} failed (attempt {failures})", ex); if (failures == 1) SaveFailed?.Invoke(ex); } private void OnProjectChanged() { // A read-only project takes what is read again (a workspace pull of a newer Chronos's settings) without a save that // could never be stored and would be retried for ever. if (!IsReadOnly) _saver.Schedule(Project); ProjectChanged?.Invoke(); } private async Task SaveAsync(ProjectSettings project) { if (!_reading.IsCompleted) { // A read under way decides the frames the project's positions name. Once it is taken, the project as it is // then contains this change (projects are whole snapshots), with its positions on those frames. while (!_reading.IsCompleted) await _reading; project = Project; } ProjectSettings stored; for (var attempt = 1; ; attempt++) { try { stored = await Source.SaveProjectAsync(project, _basis, CancellationToken.None); break; } catch (FramesChangedException) when (attempt < FollowAttempts) { // Frames were inserted under the editor and the stored positions moved with them: the frames are read // again (after a read under way, whose move this edit's snapshot missed), the project's positions follow // them, and the project as it is then, which contains this edit, is saved in the new order. var taken = await BeginReadAsync(); try { Follow(await Source.LoadAsync(CancellationToken.None)); } finally { taken.SetResult(); } project = Project; ContentChanged?.Invoke(); } catch (ProjectConflictException ex) { var found = Conflict is null; Conflict = ex; if (found) { Log.Info("editor", $"Settings of {Content.Sequence.DisplayTitle} changed on the server too: {string.Join(", ", ex.Differences.Select(d => d.Path))}"); ConflictFound?.Invoke(ex); } throw; } } Conflict = null; _basis = stored; // Someone else's change was merged in: show it without an undo step (edits made since the save are kept). if (!ProjectMerge.SameValues(stored, project)) History.Replace(Source.Merge(project, Project, stored).Merged); } } /// /// A source whose saved frames are made otherwise than from the project as the editor holds it (as /// for renders): a workspace project would name the frame and its settings as its home reads them. /// public interface IProjectStills { /// The jobs that save frame (photo ) of with . IReadOnlyList StillRequests(Sequence sequence, ProjectSettings project, ExportSettings export, VideoCodec codec, int frameIndex, string? photoSha256, int sourceWidth, int sourceHeight); } /// /// A "Save both" copy made the project (). Its Undo brings back the project from /// before as a new step, and only while the restore is still the last change: after another edit, an undo or a merged /// save it would take that change back instead. /// public sealed class ProjectRestore(EditorSession session, ProjectSettings before, ProjectSettings restored) { public bool CanUndo => ReferenceEquals(session.Project, restored); public bool Undo() => CanUndo && session.Edit(_ => before); }