diff --git a/src/Titano.App/Sections/SettingsViewModel.cs b/src/Titano.App/Sections/SettingsViewModel.cs
index f899372e..b041255d 100644
--- a/src/Titano.App/Sections/SettingsViewModel.cs
+++ b/src/Titano.App/Sections/SettingsViewModel.cs
@@ -313,6 +313,9 @@ public sealed class SettingsViewModel : SectionViewModel
/// Where "Start with Windows" is kept (the Run key); screenshots, tests and portable copies keep it in memory.
internal IStartWithWindows Startup { get; set; }
+ /// The latest archive folder change: done once the rows show what the folder holds (tests wait for it).
+ internal Task ArchiveRetarget => _retarget;
+
/// A portable copy leaves nothing in the registry (BRIEF §6.2): it offers no Startup row.
public bool ShowsStartup => !Shell.Services.Environment.IsPortable;
@@ -899,19 +902,28 @@ public sealed class SettingsViewModel : SectionViewModel
/// archive is the one at the archive folder of this PC, never another one of the index: with no folder, or none
/// registered there, the rows edit only this PC's defaults. Returns that archive (null for none).
///
- private async Task LoadArchiveAsync()
+ private Task LoadArchiveAsync() => LoadArchiveAsync(_s.LastArchivePath);
+
+ ///
+ /// for the archive folder , which a folder change may have
+ /// replaced meanwhile: the rows are then left to the folder chosen since, and the archive registered at
+ /// is still returned, so edits made for that folder reach it.
+ ///
+ private async Task LoadArchiveAsync(string? root)
{
if (Shell.Services.Database is not { } db || Shell.Services.Archives is not { } archives) return null;
Archive? archive = null;
try
{
var registered = await db.Archives.ListAsync();
- archive = _s.LastArchivePath is { Length: > 0 } root ? CurrentArchive.At(registered, root) : null;
+ archive = root is { Length: > 0 } ? CurrentArchive.At(registered, root) : null;
+ if (!IsArchiveFolder(root)) return archive;
_archive = archive;
if (archive is null) return null;
var settings = await Task.Run(() => archives.RefreshSettingsAsync(archive.Id))
?? new ArchiveSettings(archive.Name, new LayoutTemplates { Folder = archive.FolderTemplate, File = archive.FileTemplate },
new ProxyPolicy { LongEdge = archive.ProxyLongEdge }, new ThumbnailPolicy { LongEdge = _s.ThumbnailLongEdge });
+ if (!IsArchiveFolder(root)) return archive;
if (!FolderTemplate.IsDirty) FolderTemplate.Load(settings.Templates.Folder);
if (!FileTemplate.IsDirty) FileTemplate.Load(settings.Templates.File);
var changed = _s.FolderTemplate != settings.Templates.Folder || _s.FileTemplate != settings.Templates.File
@@ -935,14 +947,18 @@ public sealed class SettingsViewModel : SectionViewModel
return archive;
}
+ /// Whether is still this PC's archive folder (the one the rows show).
+ private bool IsArchiveFolder(string? root) => string.Equals(root, _s.LastArchivePath, StringComparison.Ordinal);
+
///
/// The archive an Archive row edits, as the folder was when the row was edited (, the
- /// latest folder change then): the open one, or, while the archive at that folder is still opening, the one found
- /// there once it has (null for none), so the edit is neither lost nor sent to a folder chosen later.
+ /// latest folder change then): the open one, or, while the archive at that folder is still opening or once another
+ /// folder has been chosen, the one found there (null for none), so the edit is neither lost nor sent to a folder
+ /// chosen later.
///
private async Task ArchiveAtFolderAsync(Task retarget)
{
- if (retarget.IsCompleted) return _archive;
+ if (retarget.IsCompleted && retarget == _retarget) return _archive;
// Its failures were told already; only the archive it found matters here.
await ((Task)retarget).ConfigureAwait(ConfigureAwaitOptions.ContinueOnCapturedContext | ConfigureAwaitOptions.SuppressThrowing);
return retarget.IsCompletedSuccessfully ? retarget.Result : null;
@@ -952,11 +968,12 @@ public sealed class SettingsViewModel : SectionViewModel
/// Writes one Archive row into the open archive's archive.json and index through the archive engine (BRIEF §7). When
/// that fails (offline, read-only, busy) the user hears why and the rows show the archive's values again. An edit made
/// while the archive at a folder just chosen is opening waits for it, then goes to that archive (or stays this PC's
- /// default when there is none), instead of being lost.
+ /// default when there is none), instead of being lost. is the folder change the edit was
+ /// made after, the latest one by default.
///
- private async Task UpdateArchiveAsync(Func edit)
+ private async Task UpdateArchiveAsync(Func edit, Task? retarget = null)
{
- var retarget = _retarget;
+ retarget ??= _retarget;
var waited = !retarget.IsCompleted;
if (await ArchiveAtFolderAsync(retarget) is not { } archive || Shell.Services.Archives is not { } archives) return;
try
@@ -977,36 +994,42 @@ public sealed class SettingsViewModel : SectionViewModel
}
}
- /// Every archive row into the open archive: Archive › Reset section, after the user confirmed it for that archive.
- private Task PushArchiveSettingsAsync() => UpdateArchiveAsync(a => a with
+ ///
+ /// Every archive row into the archive found after : Archive › Reset section, after the user
+ /// confirmed it for that archive.
+ ///
+ private Task PushArchiveSettingsAsync(Task retarget) => UpdateArchiveAsync(a => a with
{
Templates = a.Templates with { Folder = _s.FolderTemplate, File = _s.FileTemplate },
Proxies = a.Proxies with { LongEdge = _s.ProxyLongEdge },
Thumbnails = a.Thumbnails with { LongEdge = _s.ThumbnailLongEdge },
- });
+ }, retarget);
///
/// The archive folder changed: an archive already there is registered as at start (relinked when it moved) and given
/// its rescan, and the rows show its settings; any other folder leaves them with this PC's defaults for new archives.
- /// Later edits never reach the archive shown before. Returns the archive found there (null for none).
+ /// Later edits never reach the archive shown before. Returns the archive registered at that folder (null for none),
+ /// even when another folder has been chosen since: edits made for this one go there.
///
private async Task RetargetArchiveAsync()
{
_archive = null;
- if (_s.LastArchivePath is { } root && Shell.Services.Archives is { } archives)
+ var root = _s.LastArchivePath;
+ if (root is not null && Shell.Services.Archives is { } archives)
{
try
{
var opened = await Task.Run(async () => File.Exists(new ArchivePaths(root).ManifestPath) ? await archives.OpenAsync(root) : null);
if (opened is not null) await Shell.Services.QueueScanAsync(opened, full: false);
}
- catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or InvalidDataException or DatabaseException)
+ catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or InvalidDataException or NewerFormatException
+ or DatabaseException)
{
Log.Warning("settings", $"The archive at {root} could not be opened", ex);
Shell.Notify(Loc.L("Errors.Archive.Open"), ArchiveActions.Cause(ex), isError: true);
}
}
- return await LoadArchiveAsync();
+ return await LoadArchiveAsync(root);
}
///
@@ -1401,7 +1424,8 @@ public sealed class SettingsViewModel : SectionViewModel
///
private async Task ResetArchiveAsync(AppSettings defaults)
{
- var open = await ArchiveAtFolderAsync(_retarget);
+ var retarget = _retarget;
+ var open = await ArchiveAtFolderAsync(retarget);
if (open is not null && !ConfirmArchiveReset(open)) return;
_s.FolderTemplate = defaults.FolderTemplate;
_s.FileTemplate = defaults.FileTemplate;
@@ -1413,7 +1437,9 @@ public sealed class SettingsViewModel : SectionViewModel
UpdatePreview();
Save();
OnAllPropertiesChanged();
- if (open is not null) await PushArchiveSettingsAsync();
+ if (open is not null) await PushArchiveSettingsAsync(retarget);
+ // Another folder was chosen while this one's archive opened: the rows show what that folder's archive holds again.
+ if (retarget != _retarget) await LoadArchiveAsync();
}
private void LoadImportFields()
diff --git a/tests/Titano.App.Tests/Settings/SettingsScreenSmokeTests.cs b/tests/Titano.App.Tests/Settings/SettingsScreenSmokeTests.cs
index 8d2a3408..7215198c 100644
--- a/tests/Titano.App.Tests/Settings/SettingsScreenSmokeTests.cs
+++ b/tests/Titano.App.Tests/Settings/SettingsScreenSmokeTests.cs
@@ -183,11 +183,14 @@ public sealed class SettingsScreenSmokeTests
shell.Navigate(SectionKey.Settings);
settings.Page = SettingsPage.Archive;
- // No archive folder: a template edit is this PC's default only, never the first archive of the index.
+ // No archive folder: a template edit is this PC's default only, never the first archive of the index. The edit is
+ // made once the rows follow the empty folder, so it cannot wait for anything that would hide a write.
settings.ArchiveRoot.Text = string.Empty;
Assert.True(settings.ArchiveRoot.Commit());
+ await settings.ArchiveRetarget;
settings.FolderTemplate.Text = "{camera}/{date}";
Assert.True(settings.FolderTemplate.Commit());
+ Assert.Equal("{camera}/{date}", shell.Services.Settings.FolderTemplate);
// The archive's folder is chosen and a template edited at once, while that archive is still opening: the edit
// reaches its archive.json instead of being undone when it opens, and the row shows it.
@@ -199,6 +202,28 @@ public sealed class SettingsScreenSmokeTests
await WaitAsync(() => settings.FileTemplate.Text == "{date}_{n:0000}" && shell.Services.Settings.FileTemplate == "{date}_{n:0000}", "the row shows it");
Assert.NotEqual("{camera}/{date}", Read(manifestPath).LayoutTemplates.Folder);
+ // An edit made before a second folder change, while the first folder's archive is still opening, goes to that
+ // archive: never to the archive at the folder chosen after it.
+ var otherRoot = System.IO.Path.Combine(shell.Services.Environment.DataDirectory, "other-archive");
+ await shell.Services.Archives!.CreateAsync(otherRoot, "Other");
+ var otherManifestPath = new Titano.Core.Archiving.ArchivePaths(otherRoot).ManifestPath;
+ settings.ArchiveRoot.Text = otherRoot;
+ Assert.True(settings.ArchiveRoot.Commit());
+ await settings.ArchiveRetarget;
+ settings.ArchiveRoot.Text = archive.RootPath;
+ Assert.True(settings.ArchiveRoot.Commit());
+ settings.FileTemplate.Text = "{date}-{n:0000}";
+ Assert.True(settings.FileTemplate.Commit());
+ settings.ArchiveRoot.Text = otherRoot;
+ Assert.True(settings.ArchiveRoot.Commit());
+ await WaitAsync(() => Read(manifestPath).LayoutTemplates.File == "{date}-{n:0000}", "the edit reached the archive of the folder it was made for");
+ await settings.ArchiveRetarget;
+ Assert.NotEqual("{date}-{n:0000}", Read(otherManifestPath).LayoutTemplates.File);
+ Assert.Equal(Read(otherManifestPath).LayoutTemplates.File, settings.FileTemplate.Text);
+ settings.ArchiveRoot.Text = archive.RootPath;
+ Assert.True(settings.ArchiveRoot.Commit());
+ await settings.ArchiveRetarget;
+
// Offline, only archive.json knows the thumbnail size: this PC's stays instead of becoming the default.
Titano.Core.Archiving.ManifestStore.WriteArchive(manifestPath, Read(manifestPath) with { ThumbnailPolicy = new Titano.Core.Archiving.ThumbnailPolicy { LongEdge = 480 } });
shell.Navigate(SectionKey.Library);