Files
Chronos/src/Chronos.App/Workspace/WorkspaceDialogs.cs
T
Alby96andClaude Opus 5.5 8027d84f7e fix(workspace): settle only the conflict shown, keep what a choice replaces, desktop gaps of phase 5a
Review 2, phase 5a, fix round 1 (desktop and the engine side of Resolve and Restore).

- Resolve applies Keep mine / Take the library's only to the conflict the dialog listed:
  when the head or what differs moved since, the new conflict is recorded and asked again;
  Sync re-works a pending conflict instead of re-showing a stale list. Take the library's
  first saves uncommitted changes as a version, and the editor takes it as one undo step
  (toast Undo, Ctrl+Z) that brings back only the settings both changed.
- Restore saves unsaved changes as a version also while a conflict waits; a restore that
  changed nothing, or was undone, no longer marks the next version as a Restore.
- The editor's saves and merges of a workspace project merge positions photo by photo
  (portable form) and ask where both sides changed a setting, never deciding for ours.
- Read-only after a pull is signalled, and no save that can never be stored is left behind.
- The chip is read again after edits; a background conflict waits for the open dialog;
  Send first and Delete show the conflict they met; Discard changes needs the typed name.
- Open project... reaches the library's other projects (Save both's sibling, also from
  its toast); copies whose project or sequence is gone read Not in library and can be
  removed from the picker's Workspace rows; a delete whose local copy stays says so.
- A workspace folder inside a library is refused before anything is written.
- Conflict and Compare lines name heroes, exclusions and keyframes; History shows the PC
  name alone, never the program's prefixes.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-03 10:22:17 +01:00

548 lines
21 KiB
C#

using System.Collections.ObjectModel;
using System.Windows.Input;
using Chronos.App.Archiving;
using Chronos.App.Infrastructure;
using Chronos.App.Settings;
using Chronos.Core.Diagnostics;
using Chronos.Core.Localization;
using Chronos.Core.Model;
using Chronos.Core.Project;
using Chronos.Data.Projects;
using Chronos.Data.Workspaces;
using Chronos.Ui.Mvvm;
namespace Chronos.App.Workspace;
/// <summary>What "Open in workspace" chose: an existing project of the home (<see cref="ProjectId"/>) or a new one (<see cref="NewName"/>), and the media.</summary>
public sealed record OpenChoice(Guid? ProjectId, string? NewName, string Media);
/// <summary>A project of the home offered by "Open in workspace" (Main in the UI language).</summary>
public sealed record ProjectOption(SequenceProject Project)
{
public string Label => WorkspaceText.ProjectName(Project.Name, Project.IsMain);
public override string ToString() => Label;
}
/// <summary>Project names as the home takes them: 1 to 60 characters, no control character, each once per sequence (case does not count).</summary>
public static class ProjectNames
{
/// <summary>The problem of <paramref name="name"/>, or null when the home takes it.</summary>
public static string? Validate(string name, IEnumerable<string> others)
{
var trimmed = name?.Trim() ?? string.Empty;
if (trimmed.Length is 0 or > ProjectService.MaxNameLength || trimmed.Any(char.IsControl)) return Loc.L("Errors.Workspace.InvalidName");
return others.Any(o => string.Equals(o, trimmed, StringComparison.OrdinalIgnoreCase)) ? Loc.L("Errors.Workspace.NameTaken") : null;
}
}
/// <summary>
/// "Open in workspace" (owner review 2, R8), asked when a sequence has no project in the workspace yet, and by the project
/// menu's Open project: which project of its home (Main, made from the sequence's settings as they are, or another) or a
/// new one with its name, and the media to copy (proxies; the originals come in phase 5c). Open queues the copy; the
/// sequence opens once it is done.
/// </summary>
public sealed class OpenInWorkspaceDialogViewModel : ArchiveDialogViewModel
{
private readonly TaskCompletionSource<OpenChoice?> _choice = new(TaskCreationOptions.RunContinuationsAsynchronously);
private ProjectOption? _selected;
private bool _isNew;
/// <param name="taken">The names a new project cannot take (default: those of <paramref name="projects"/>).</param>
public OpenInWorkspaceDialogViewModel(string sequenceTitle, IReadOnlyList<SequenceProject> projects, Action<ArchiveDialogViewModel> close,
IReadOnlyList<string>? taken = null)
: base(close)
{
SequenceTitle = sequenceTitle;
Projects = [.. projects.OrderByDescending(p => p.IsMain).Select(p => new ProjectOption(p))];
_selected = Projects.FirstOrDefault();
_isNew = Projects.Count == 0;
var names = taken ?? [.. projects.Select(p => p.Name)];
NewName = new EditableField(string.Empty, n => ProjectNames.Validate(n, names), _ => { }, () => Loc.L("Tooltips.Editor.OpenWorkspace.Name"));
NewName.PropertyChanged += (_, _) => Refresh();
OpenCommand = new RelayCommand(Open, () => CanOpen);
}
/// <summary>Completes with the user's choice, or null when the dialog was closed without one.</summary>
public Task<OpenChoice?> Choice => _choice.Task;
public string SequenceTitle { get; }
public string Heading => Loc.L("Editor.OpenWorkspace.Title");
public IReadOnlyList<ProjectOption> Projects { get; }
public bool HasProjects => Projects.Count > 0;
public ProjectOption? SelectedProject
{
get => _selected;
set
{
if (Set(ref _selected, value) && value is not null) IsExisting = true;
}
}
/// <summary>A project the home has.</summary>
public bool IsExisting
{
get => !_isNew;
set
{
if (value) IsNew = false;
}
}
/// <summary>A new project, named in <see cref="NewName"/>.</summary>
public bool IsNew
{
get => _isNew;
set
{
if (!Set(ref _isNew, value || !HasProjects)) return;
OnPropertyChanged(nameof(IsExisting));
Refresh();
}
}
public EditableField NewName { get; }
/// <summary>The proxies, the only media this phase copies.</summary>
public bool IsProxies => true;
/// <summary>The originals: offered from phase 5c, to render on this PC.</summary>
public bool CanCopyOriginals => false;
public ICommand OpenCommand { get; }
public bool CanOpen => _isNew ? !NewName.HasErrors : _selected is not null;
public string OpenToolTip => _isNew && NewName.Error is { } error ? error : Loc.L("Tooltips.Editor.OpenWorkspace.Open");
public override void Dispose()
{
// Closed without a choice (Cancel, Esc, another sequence asked for).
_choice.TrySetResult(null);
base.Dispose();
}
private void Open()
{
if (!CanOpen) return;
_choice.TrySetResult(_isNew ? new OpenChoice(null, NewName.Text.Trim(), BundleMedia.Proxies) : new OpenChoice(_selected!.Project.Id, null, BundleMedia.Proxies));
Close();
}
private void Refresh()
{
OnPropertyChanged(nameof(CanOpen));
OnPropertyChanged(nameof(OpenToolTip));
CommandManager.InvalidateRequerySuggested();
}
}
/// <summary>Names a project: "New project" (made from the open project's last version at the home) or "Rename".</summary>
public sealed class ProjectNameDialogViewModel : ArchiveDialogViewModel
{
private readonly Func<string, Task> _save;
/// <param name="others">The names of the sequence's other projects (each name is used once).</param>
public ProjectNameDialogViewModel(bool rename, string name, IEnumerable<string> others, Func<string, Task> save, Action<ArchiveDialogViewModel> close)
: base(close)
{
IsRename = rename;
_save = save;
var taken = others.ToList();
Name = new EditableField(name, n => ProjectNames.Validate(n, taken), _ => { }, () => Loc.L("Tooltips.Editor.ProjectName.Name"));
Name.PropertyChanged += (_, _) =>
{
OnPropertyChanged(nameof(SaveToolTip));
CommandManager.InvalidateRequerySuggested();
};
SaveCommand = new AsyncRelayCommand(SaveAsync, () => !IsBusy && !Name.HasErrors);
}
public bool IsRename { get; }
public string Heading => Loc.L(IsRename ? "Editor.ProjectName.Rename" : "Editor.ProjectName.New");
public string SaveText => Loc.L(IsRename ? "Editor.ProjectName.Apply" : "Editor.ProjectName.Create");
public EditableField Name { get; }
public ICommand SaveCommand { get; }
public string SaveToolTip => Name.Error ?? Loc.L(IsRename ? "Tooltips.Editor.ProjectName.Apply" : "Tooltips.Editor.ProjectName.Create");
private async Task SaveAsync()
{
ClearError();
IsBusy = true;
try
{
await _save(Name.Text.Trim());
Close();
}
catch (Exception ex) when (ex is not OutOfMemoryException)
{
Log.Warning("workspace", "Naming a project failed", ex);
ShowMessage(WorkspaceText.Failure(ex), ex.Message);
}
finally
{
IsBusy = false;
}
}
}
/// <summary>"Save version" (Ctrl+S): an optional note, then the version is saved (and sent when Sync automatically is on).</summary>
public sealed class SaveVersionDialogViewModel : ArchiveDialogViewModel
{
/// <summary>A note is a line of the history: longer text is cut there.</summary>
public const int MaxNoteLength = 200;
private readonly Func<string?, Task> _save;
private string _note = string.Empty;
public SaveVersionDialogViewModel(string projectName, Func<string?, Task> save, Action<ArchiveDialogViewModel> close)
: base(close)
{
ProjectName = projectName;
_save = save;
SaveCommand = new AsyncRelayCommand(SaveAsync, () => !IsBusy);
}
public string ProjectName { get; }
public string Heading => Loc.L("Editor.SaveVersion.Title", ProjectName);
public string Note
{
get => _note;
set => Set(ref _note, (value ?? string.Empty).Length > MaxNoteLength ? value![..MaxNoteLength] : value ?? string.Empty);
}
public ICommand SaveCommand { get; }
private async Task SaveAsync()
{
ClearError();
IsBusy = true;
try
{
await _save(string.IsNullOrWhiteSpace(_note) ? null : _note.Trim());
Close();
}
catch (Exception ex) when (ex is not OutOfMemoryException)
{
Log.Warning("workspace", "Saving a version failed", ex);
ShowMessage(WorkspaceText.Failure(ex), ex.Message);
}
finally
{
IsBusy = false;
}
}
}
/// <summary>A version in the History flyout: number, author, time, note, what made it, and Compare and Restore.</summary>
public sealed class HistoryRowViewModel(ProjectVersion version, bool unsent, bool isCurrent, ICommand compare, ICommand restore) : ObservableObject
{
public ProjectVersion Version { get; } = version;
public string Number => Formatting.Count(Version.Number);
public string Author => WorkspaceText.Author(Version);
public string When => WorkspaceText.When(Version.CreatedAt);
public string Note => Version.Note ?? string.Empty;
public string KindText => WorkspaceText.VersionKind(Version.Kind);
/// <summary>Saved here, waiting to be sent.</summary>
public bool IsUnsent { get; } = unsent;
/// <summary>The version the working state was last saved as (nothing differs).</summary>
public bool IsCurrent { get; } = isCurrent;
/// <summary>"Version 3 · Saved · STUDIO-PC · 28/10/2026 18:02 · note": the row for screen readers and its tooltip.</summary>
public string Description => string.Join(Loc.Separator, new[] { Loc.L("Editor.History.Version", Number), KindText, Author, When, Note }.Where(s => s.Length > 0));
public ICommand CompareCommand { get; } = compare;
public ICommand RestoreCommand { get; } = restore;
public string CompareToolTip => Loc.L("Tooltips.Editor.History.Compare", Number);
public string RestoreToolTip => Loc.L("Tooltips.Editor.History.Restore", Number);
}
/// <summary>
/// The History flyout of a workspace project: its versions newest first (those not sent yet marked), Compare (the
/// settings that differ from the project now) and Restore (the version as the project again, one undo step).
/// </summary>
public sealed class HistoryDialogViewModel : ArchiveDialogViewModel
{
private readonly Func<ProjectVersion, Task<IReadOnlyList<string>>> _compare;
private readonly Func<ProjectVersion, Task> _restore;
private string? _comparedTitle;
private IReadOnlyList<string> _compared = [];
private bool _isLoaded;
public HistoryDialogViewModel(string projectName, Func<ProjectVersion, Task<IReadOnlyList<string>>> compare, Func<ProjectVersion, Task> restore,
Action<ArchiveDialogViewModel> close)
: base(close)
{
ProjectName = projectName;
_compare = compare;
_restore = restore;
}
public string ProjectName { get; }
public string Heading => Loc.L("Editor.History.Title", ProjectName);
public ObservableCollection<HistoryRowViewModel> Rows { get; } = [];
/// <summary>The home could not be asked: only this PC's versions are listed.</summary>
public bool IsOffline { get; private set; }
public bool IsEmpty => _isLoaded && Rows.Count == 0;
/// <summary>"Version 3 → now" over the comparison; null before one.</summary>
public string? ComparedTitle { get => _comparedTitle; private set => Set(ref _comparedTitle, value); }
public IReadOnlyList<string> Compared { get => _compared; private set => Set(ref _compared, value); }
/// <summary>Lists <paramref name="history"/>; <paramref name="currentHash"/> marks the version the project is now.</summary>
public void Show(WorkspaceHistory history, string? currentHash)
{
ArgumentNullException.ThrowIfNull(history);
Rows.Clear();
foreach (var version in history.Versions)
{
var current = currentHash is not null && string.Equals(version.ContentHash, currentHash, StringComparison.OrdinalIgnoreCase);
Rows.Add(new HistoryRowViewModel(version, history.Unsent.Contains(version.Id), current,
new AsyncRelayCommand(() => CompareAsync(version), () => !IsBusy), new AsyncRelayCommand(() => RestoreAsync(version), () => !IsBusy)));
}
IsOffline = history.Offline;
_isLoaded = true;
OnPropertyChanged(nameof(IsOffline));
OnPropertyChanged(nameof(IsEmpty));
}
/// <summary>A failure of the read that lists the versions, shown in the flyout.</summary>
public void ShowFailure(Exception ex)
{
ArgumentNullException.ThrowIfNull(ex);
_isLoaded = true;
OnPropertyChanged(nameof(IsEmpty));
ShowMessage(WorkspaceText.Failure(ex), ex.Message);
}
public async Task CompareAsync(ProjectVersion version)
{
ArgumentNullException.ThrowIfNull(version);
ClearError();
try
{
var lines = await _compare(version);
ComparedTitle = Loc.L("Editor.History.Compared", Formatting.Count(version.Number));
Compared = lines.Count == 0 ? [Loc.L("Editor.History.Same")] : lines;
}
catch (Exception ex) when (ex is not OutOfMemoryException)
{
Log.Warning("workspace", $"Version {version.Number} could not be compared", ex);
ShowMessage(WorkspaceText.Failure(ex), ex.Message);
}
}
public async Task RestoreAsync(ProjectVersion version)
{
ArgumentNullException.ThrowIfNull(version);
ClearError();
IsBusy = true;
try
{
await _restore(version);
IsBusy = false;
Close();
}
catch (Exception ex) when (ex is not OutOfMemoryException)
{
Log.Warning("workspace", $"Version {version.Number} could not be restored", ex);
ShowMessage(WorkspaceText.Failure(ex), ex.Message);
IsBusy = false;
}
}
}
/// <summary>
/// A sync that met settings both sides changed (owner review 2, R8: asked only on real conflicts): what differs, then
/// Keep mine, Take the library's, or Save both (this workspace's versions go to a sibling project). Later leaves the
/// conflict for the next Sync; editing goes on meanwhile.
/// </summary>
public sealed class ConflictDialogViewModel : ArchiveDialogViewModel
{
private readonly Func<ConflictChoice, Task> _resolve;
public ConflictDialogViewModel(string projectName, string siblingName, IReadOnlyList<string> differences, Func<ConflictChoice, Task> resolve,
Action<ArchiveDialogViewModel> close)
: base(close)
{
ProjectName = projectName;
SiblingName = siblingName;
Differences = differences;
_resolve = resolve;
KeepMineCommand = new AsyncRelayCommand(() => ResolveAsync(ConflictChoice.KeepMine), () => !IsBusy);
TakeHomeCommand = new AsyncRelayCommand(() => ResolveAsync(ConflictChoice.TakeServer), () => !IsBusy);
SaveBothCommand = new AsyncRelayCommand(() => ResolveAsync(ConflictChoice.SaveBoth), () => !IsBusy);
}
public string ProjectName { get; }
/// <summary>The project Save both makes for this workspace's versions.</summary>
public string SiblingName { get; }
public string Heading => Loc.L("Editor.Workspace.Conflict.Title");
public string Message => Loc.L("Editor.Workspace.Conflict.Message", ProjectName);
public IReadOnlyList<string> Differences { get; }
public ICommand KeepMineCommand { get; }
public ICommand TakeHomeCommand { get; }
public ICommand SaveBothCommand { get; }
public string SaveBothToolTip => Loc.L("Tooltips.Editor.Workspace.SaveBoth", SiblingName);
private async Task ResolveAsync(ConflictChoice choice)
{
ClearError();
IsBusy = true;
try
{
await _resolve(choice);
IsBusy = false;
Close();
}
catch (Exception ex) when (ex is not OutOfMemoryException)
{
Log.Warning("workspace", $"The conflict of '{ProjectName}' could not be settled ({choice})", ex);
ShowMessage(WorkspaceText.Failure(ex), ex.Message);
IsBusy = false;
}
}
}
/// <summary>
/// "Remove local copy": the plan (files and size of the copy; versions not sent and changes not saved), then Remove
/// (only when everything is at the library), Send first (sends, then removes), or Discard changes (removes once the
/// user typed the project's name; the unsent work is kept aside in the workspace's trash). A project the library no
/// longer has (<see cref="WorkspaceRemovalPlan.Gone"/>) can only be discarded that way.
/// </summary>
public sealed class RemoveCopyDialogViewModel : ArchiveDialogViewModel
{
private readonly Func<bool, Task> _remove;
private readonly Func<Task> _sendFirst;
private readonly Func<bool> _confirmDiscard;
/// <param name="confirmDiscard">The typed confirmation Discard changes asks first (<see cref="ConfirmDiscard"/>); true when the user confirmed.</param>
public RemoveCopyDialogViewModel(WorkspaceRemovalPlan plan, Func<bool, Task> remove, Func<Task> sendFirst, Func<bool> confirmDiscard, Action<ArchiveDialogViewModel> close)
: base(close)
{
Plan = plan;
_remove = remove;
_sendFirst = sendFirst;
_confirmDiscard = confirmDiscard;
Facts =
[
new DialogFact(Loc.L("Editor.RemoveCopy.Files"), Formatting.Count(plan.Files)),
new DialogFact(Loc.L("Editor.RemoveCopy.Size"), Formatting.Bytes(plan.Bytes)),
new DialogFact(Loc.L("Editor.RemoveCopy.Unsent"), Formatting.Count(plan.Unsent)),
new DialogFact(Loc.L("Editor.RemoveCopy.Changed"), Loc.L(plan.Modified ? "Editor.RemoveCopy.Yes" : "Editor.RemoveCopy.No")),
];
RemoveCommand = new AsyncRelayCommand(() => RunAsync(() => _remove(false)), () => !IsBusy && plan.IsSafe && !plan.Offline && !plan.Gone);
SendFirstCommand = new AsyncRelayCommand(() => RunAsync(_sendFirst), () => !IsBusy && !plan.IsSafe && !plan.Conflict && !plan.Offline && !plan.Gone);
DiscardCommand = new AsyncRelayCommand(DiscardAsync, () => !IsBusy && HasUnsent);
}
public WorkspaceRemovalPlan Plan { get; }
public string Heading => Loc.L("Editor.RemoveCopy.Title", WorkspaceText.ProjectName(Plan.Name, false));
public IReadOnlyList<DialogFact> Facts { get; }
/// <summary>Something would not be at the library after the removal (or the library no longer has the project): Discard changes shows.</summary>
public bool HasUnsent => !Plan.IsSafe || Plan.Gone;
public ICommand RemoveCommand { get; }
public ICommand SendFirstCommand { get; }
public ICommand DiscardCommand { get; }
public string RemoveToolTip => Plan.Gone ? Loc.L("Errors.Workspace.ProjectGone")
: !Plan.IsSafe ? Loc.L("Errors.Workspace.Unsent")
: Plan.Offline ? Loc.L("Errors.Workspace.Offline")
: Loc.L("Tooltips.Editor.RemoveCopy.Remove");
public string SendFirstToolTip => Plan.Gone ? Loc.L("Errors.Workspace.ProjectGone")
: Plan.Conflict ? Loc.L("Errors.Workspace.Conflict")
: Plan.Offline ? Loc.L("Errors.Workspace.Offline")
: Loc.L("Tooltips.Editor.RemoveCopy.SendFirst");
public string DiscardToolTip => Loc.L("Tooltips.Editor.RemoveCopy.Discard");
/// <summary>
/// The typed confirmation of Discard changes (the plan's cross-cutting rule for what Chronos cannot bring back): the
/// project's name, as shown, typed before Discard enables.
/// </summary>
public static ConfirmRequest DiscardRequest(string projectName) => new()
{
Heading = Loc.L("Editor.RemoveCopy.DiscardTitle", projectName),
Message = Loc.L("Editor.RemoveCopy.DiscardMessage"),
SafeText = Loc.L("Editor.Project.Keep"),
SafeToolTip = Loc.L("Tooltips.Editor.RemoveCopy.Keep"),
ActionText = Loc.L("Editor.RemoveCopy.Discard"),
ActionToolTip = Loc.L("Tooltips.Editor.RemoveCopy.Discard"),
IsDestructive = true,
TypedConfirmation = projectName,
TypedPrompt = Loc.L("Editor.RemoveCopy.TypeName"),
};
/// <summary>Asks <see cref="DiscardRequest"/> through <paramref name="ui"/>: true when the user typed the name and confirmed.</summary>
public static bool ConfirmDiscard(IWorkspaceUi ui, string projectName)
{
ArgumentNullException.ThrowIfNull(ui);
return ui.Confirm(DiscardRequest(projectName));
}
private async Task DiscardAsync()
{
if (!_confirmDiscard()) return;
await RunAsync(() => _remove(true));
}
private async Task RunAsync(Func<Task> action)
{
ClearError();
IsBusy = true;
try
{
await action();
IsBusy = false;
Close();
}
catch (Exception ex) when (ex is not OutOfMemoryException)
{
Log.Warning("workspace", $"The local copy of project {Plan.ProjectId} was not removed", ex);
ShowMessage(WorkspaceText.Failure(ex), ex.Message);
IsBusy = false;
}
}
}