CI / Build and test (push) Successful in 9m43s
CI / Windows tests and installer (push) Skipped
CI / YAML check (push) Successful in 27s
CI / PostgreSQL 16 integration (push) Failing after 8m41s
CI / PostgreSQL 17 integration (push) Successful in 12m37s
CI / Docker image (push) Successful in 56s
Release / Build, test and publish (push) Successful in 14m59s
Release / Server image (push) Successful in 1m51s
Edit opens a sequence as a project of a workspace folder outside the library. Projects have linear version histories kept as sidecars in .chronos/projects/, Main mirrors the sequence's settings, and sync merges setting by setting. Migration 0009, JobKind.WorkspaceCopy = 20, Settings › Workspace, and 241 new strings in 38 languages. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Co-authored-by: Alberto Balbo <alberto.balbo.96@gmail.com>
112 lines
6.6 KiB
C#
112 lines
6.6 KiB
C#
using System.IO;
|
|
using Chronos.App.Archiving;
|
|
using Chronos.App.Infrastructure;
|
|
using Chronos.App.Server;
|
|
using Chronos.Core.Archiving;
|
|
using Chronos.Core.Localization;
|
|
using Chronos.Core.Model;
|
|
using Chronos.Data.Projects;
|
|
using Chronos.Data.Sync;
|
|
using Chronos.Data.Workspaces;
|
|
using Chronos.Ui.Controls;
|
|
|
|
namespace Chronos.App.Workspace;
|
|
|
|
/// <summary>How the workspace's states, projects, versions and failures read in the UI (owner review 2, R8). WPF-free.</summary>
|
|
public static class WorkspaceText
|
|
{
|
|
/// <summary>The project's name; the Main project in the UI language.</summary>
|
|
public static string ProjectName(string name, bool isMain) =>
|
|
isMain && string.Equals(name, ProjectService.MainName, StringComparison.Ordinal) ? Loc.L("Editor.Project.Main") : name;
|
|
|
|
/// <summary>The state chip: "In sync", "Not sent", "Conflict"…; "Syncing" while a sync runs.</summary>
|
|
public static string State(WorkspaceStatus? status, bool syncing = false) =>
|
|
syncing ? Loc.L("Editor.Workspace.State.Syncing") : status is null ? Loc.L("Editor.Workspace.State.Reading") : Loc.L("Editor.Workspace.State." + status.State);
|
|
|
|
public static StatusKind Kind(WorkspaceStatus? status, bool syncing = false) => syncing ? StatusKind.Running : status?.State switch
|
|
{
|
|
WorkspaceState.InSync => StatusKind.Synced,
|
|
WorkspaceState.Modified or WorkspaceState.Ahead => StatusKind.Queued,
|
|
WorkspaceState.Behind => StatusKind.Remote,
|
|
WorkspaceState.Conflict => StatusKind.Error,
|
|
WorkspaceState.Offline => StatusKind.Offline,
|
|
WorkspaceState.MediaRemoved => StatusKind.NoProxies,
|
|
WorkspaceState.Gone => StatusKind.Warning,
|
|
WorkspaceState.Damaged => StatusKind.Error,
|
|
_ => StatusKind.Queued,
|
|
};
|
|
|
|
/// <summary>What the state means and what to do, with the counts behind it.</summary>
|
|
public static string StateToolTip(WorkspaceStatus? status, bool syncing = false) => syncing ? Loc.L("Tooltips.Editor.Workspace.State.Syncing")
|
|
: status is null ? Loc.L("Tooltips.Editor.Workspace.State.Reading")
|
|
: status.State switch
|
|
{
|
|
WorkspaceState.Ahead => Loc.L("Tooltips.Editor.Workspace.State.Ahead", Formatting.Count(status.Ahead)),
|
|
WorkspaceState.Behind => Loc.L("Tooltips.Editor.Workspace.State.Behind", Formatting.Count(status.Behind)),
|
|
WorkspaceState.Offline when status.Ahead > 0 => Loc.L("Tooltips.Editor.Workspace.State.OfflineAhead", Formatting.Count(status.Ahead)),
|
|
var state => Loc.L("Tooltips.Editor.Workspace.State." + state),
|
|
};
|
|
|
|
/// <summary>"Saved", "Merged", "Restored", "Imported", "Outside change".</summary>
|
|
public static string VersionKind(ProjectVersionKind kind) => Loc.L("Editor.History.Kind." + kind);
|
|
|
|
/// <summary>
|
|
/// Who made a version: its author, else the PC it was made on ("STUDIO-PC"), however the program that made it named
|
|
/// itself ("chronos@STUDIO-PC" for the archive's own versions, "Chronos on STUDIO-PC" for those of test builds).
|
|
/// </summary>
|
|
public static string Author(ProjectVersion version)
|
|
{
|
|
ArgumentNullException.ThrowIfNull(version);
|
|
if (version.Author is { Length: > 0 } author) return author;
|
|
var client = version.ClientName?.Trim() ?? string.Empty;
|
|
foreach (var prefix in ClientPrefixes)
|
|
{
|
|
if (client.Length > prefix.Length && client.StartsWith(prefix, StringComparison.OrdinalIgnoreCase)) return client[prefix.Length..];
|
|
}
|
|
return client;
|
|
}
|
|
|
|
/// <summary>What programs put before the PC's name in a version's client name (not words of the UI: the PC alone is shown).</summary>
|
|
private static readonly string[] ClientPrefixes = ["chronos@", "server@", "workspace@", "Chronos on "];
|
|
|
|
/// <summary>"28/10/2026 18:02".</summary>
|
|
public static string When(DateTimeOffset at) => $"{Formatting.Date(at)} {Formatting.TimeOfDay(at)}";
|
|
|
|
/// <summary>
|
|
/// One line per setting both sides changed ("Deflicker window 41 here, 33 in the library"), at most <paramref name="max"/>.
|
|
/// A conflict of format (<see cref="ProjectMerge.FormatPath"/>) reads as its cause, never as the format's numbers.
|
|
/// </summary>
|
|
public static IReadOnlyList<string> ConflictLines(IEnumerable<SettingsDifference> differences, int max)
|
|
{
|
|
ArgumentNullException.ThrowIfNull(differences);
|
|
var list = differences.ToList();
|
|
if (list.Any(d => d.Path == ProjectMerge.FormatPath)) return [Loc.L("Editor.Workspace.Conflict.NewerFormat")];
|
|
return SyncText.Differences(list, max, (label, mine, theirs) => Loc.L("Editor.Workspace.Difference", label, mine, theirs));
|
|
}
|
|
|
|
/// <summary>One line per setting that differs between now and a version ("Deflicker window 41 now, 33 in that version").</summary>
|
|
public static IReadOnlyList<string> CompareLines(IEnumerable<SettingsDifference> differences, int max) =>
|
|
SyncText.Differences(differences, max, (label, now, then) => Loc.L("Editor.History.Difference", label, now, then));
|
|
|
|
/// <summary>Why a workspace operation stopped, as one localized sentence chosen by cause; the exception's own text goes to the log.</summary>
|
|
public static string Failure(Exception ex) => ex switch
|
|
{
|
|
WorkspaceException or LeaseUnavailableException => ex.Message,
|
|
// A library that can be read but not written (a read-only share, a write-protected disk): the work waits here as offline.
|
|
HomeUnavailableException { InnerException: ArchiveOfflineException { Availability: ArchiveAvailability.ReadOnly } }
|
|
or ArchiveOfflineException { Availability: ArchiveAvailability.ReadOnly } => Loc.L("Errors.Workspace.ReadOnlyHome"),
|
|
HomeUnavailableException or ArchiveOfflineException => Loc.L("Errors.Workspace.Offline"),
|
|
ProjectException { Reason: ProjectError.NameTaken } => Loc.L("Errors.Workspace.NameTaken"),
|
|
ProjectException { Reason: ProjectError.InvalidName } => Loc.L("Errors.Workspace.InvalidName"),
|
|
ProjectException { Reason: ProjectError.MainCannotBeDeleted } => Loc.L("Errors.Workspace.MainKept"),
|
|
ProjectException => Loc.L("Errors.Workspace.ProjectGone"),
|
|
// A version over the size one may be: saved here (refused before anything was written) or sent (the home stored nothing).
|
|
ProjectVersionTooLargeException or WorkspaceSyncException { Outcome: PushOutcome.TooLarge } =>
|
|
Loc.L("Errors.Workspace.VersionTooLarge", ProjectSidecars.MaxVersionBytes >> 20),
|
|
WorkspaceSyncException => Loc.L("Errors.Workspace.Refused"),
|
|
InvalidDataException => Loc.L("Errors.Workspace.Damaged"),
|
|
Editor.EditorException => ex.Message,
|
|
_ => ArchiveFailures.Cause(ex),
|
|
};
|
|
}
|