The About entry of the Settings search always listed "Translation" among its keywords, and its tooltip named the translation, but that row shows only outside English. In English a search for "Translation" left About alone in the list and selected a page without such a row. The page's search words are now read at each search, so the keyword follows the language while Settings is open, and the tooltip no longer names a row that may be hidden. Also drop About from the doc comments of the update notice and the diagnostics bundle: since owner review 2, R5 only Settings › Updates and Settings › Advanced offer them. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
1696 lines
74 KiB
C#
1696 lines
74 KiB
C#
using System.Collections.ObjectModel;
|
||
using System.Globalization;
|
||
using System.IO;
|
||
using System.Text.Json;
|
||
using System.Windows.Input;
|
||
using Chronos.App.Archiving;
|
||
using Chronos.App.Infrastructure;
|
||
using Chronos.App.Server;
|
||
using Chronos.App.Settings;
|
||
using Chronos.App.Shell;
|
||
using Chronos.Core.Archiving;
|
||
using Chronos.Core.Diagnostics;
|
||
using Chronos.Core.Import;
|
||
using Chronos.Core.IO;
|
||
using Chronos.Core.Localization;
|
||
using Chronos.Core.Model;
|
||
using Chronos.Core.Naming;
|
||
using Chronos.Data;
|
||
using Chronos.Data.Archiving;
|
||
using Chronos.Data.Jobs;
|
||
using Chronos.Ui.Mvvm;
|
||
using Chronos.Ui.Theming;
|
||
|
||
namespace Chronos.App.Sections;
|
||
|
||
/// <summary>
|
||
/// Settings (BRIEF §12.8, Settings.html): a searchable section list on the left, the controls of one section on
|
||
/// the right, tooltips only. Text fields commit on Enter and revert on Esc; invalid input shows the Error border
|
||
/// with the reason in the tooltip. Everything persists through <see cref="AppSettings"/> (atomic writes). The
|
||
/// Archive rows show and change the open archive's own settings (archive.json, through the archive engine) and are the
|
||
/// defaults of new archives; Import and Analysis feed the defaults of new cards and the analysis jobs; Rendering feeds
|
||
/// the jobs from the next one on; Formats lists the decode tier per format on this PC with the codec extensions to
|
||
/// install; Advanced restores the index from a daily backup at the next start; About, the last page, shows this copy
|
||
/// (<see cref="ShellViewModel.About"/>, whose update notice Updates shows).
|
||
/// </summary>
|
||
public sealed class SettingsViewModel : SectionViewModel
|
||
{
|
||
private readonly AppSettings _s;
|
||
private SettingsPage _page = SettingsPage.General;
|
||
private string _searchText = string.Empty;
|
||
private IReadOnlyList<SettingsPageItem> _visiblePages;
|
||
private IReadOnlyList<string> _previewNames = [];
|
||
private string? _archiveFreeText;
|
||
private string? _cacheUsageText;
|
||
private string? _adapterText;
|
||
private bool _isDetecting;
|
||
private bool _isTesting;
|
||
private CancellationTokenSource? _selfTest;
|
||
private Archive? _archive;
|
||
|
||
/// <summary>
|
||
/// The open of the archive at the folder chosen last (<see cref="RetargetArchiveAsync"/>), with the archive it found
|
||
/// there: edits of the Archive rows made meanwhile wait for it (<see cref="ArchiveAtFolderAsync"/>).
|
||
/// </summary>
|
||
private Task<Archive?> _retarget = Task.FromResult<Archive?>(null);
|
||
|
||
/// <summary>Drops a read of the open archive's settings that may have missed an edit being written meanwhile.</summary>
|
||
private readonly ArchiveReadGate _archiveReads = new();
|
||
private bool _isDetectingFormats;
|
||
private IReadOnlyList<BackupOption> _backups = [];
|
||
private BackupOption? _selectedBackup;
|
||
private bool _isRestoring;
|
||
private InterfacePriority? _interfacePriority;
|
||
|
||
public SettingsViewModel(ShellViewModel shell)
|
||
: base(SectionKey.Settings, "Icon.Settings")
|
||
{
|
||
Shell = shell;
|
||
_s = shell.Services.Settings;
|
||
Startup = shell.Services.Environment is { IsCapture: false, IsPortable: false } ? new RunKeyStartWithWindows() : new MemoryStartWithWindows();
|
||
AllPages =
|
||
[
|
||
new(SettingsPage.General, ["Settings.General.Language", "Settings.General.Theme", .. ShowsStartup ? (string[])["Settings.General.Startup"] : [],
|
||
"Settings.General.Notifications", .. ProductFeatures.AdsEnabled ? (string[])["Settings.General.Usage"] : []]),
|
||
new(SettingsPage.Archive, ["Settings.Archive.Root", "Settings.Archive.Folders", "Settings.Archive.Files", "Settings.Archive.Proxies",
|
||
"Settings.Archive.Thumbnails", "Settings.Archive.Polling"]),
|
||
new(SettingsPage.Import, ["Import.Scan.Sessions", "Import.Label.Scan", "Import.Scan.Subfolders", "Import.Scan.Verify", "Import.Label.Duplicates",
|
||
"Import.Label.After", "Import.After.Eject"]),
|
||
new(SettingsPage.Analysis, ["Settings.Analysis.Width", "Settings.Analysis.Night", "Settings.Analysis.Stars", "Settings.Analysis.Deep"]),
|
||
new(SettingsPage.Rendering, ["Settings.Rendering.Quality", "Settings.Rendering.Memory", "Settings.Rendering.Parallelism", "Settings.Rendering.PriorityQueue",
|
||
"Settings.Rendering.Hardware", "Settings.Rendering.Encoders"]),
|
||
new(SettingsPage.Formats, ["Settings.Formats.Title", "Settings.Formats.Column.Tier", "Settings.Formats.Install"]),
|
||
new(SettingsPage.Storage, ["Settings.Storage.Folder", "Settings.Storage.Thumbnails", "Settings.Storage.Limit"]),
|
||
new(SettingsPage.Server, ["Settings.Server.Default", "Settings.Server.RenderNode", "Settings.Server.Certificates"]),
|
||
new(SettingsPage.Updates, ["Settings.General.CheckOnStart", "Settings.Updates.Latest", "About.Update.Check", "About.Releases"]),
|
||
new(SettingsPage.Advanced, ["Settings.Advanced.DataFolder", "Settings.Advanced.Logs", "Settings.Advanced.Diagnostics", "Settings.Advanced.Backup",
|
||
"Settings.Advanced.Restore", "Settings.Advanced.Reset"]),
|
||
// The translation row shows outside English only, and the language changes while Settings is open.
|
||
new(SettingsPage.About, () => ["Shell.AppName", "About.Build", "About.Runtime", "About.System", "About.Licence", "About.ThirdParty",
|
||
.. Shell.About.IsTranslated ? (string[])["About.Translation"] : []]),
|
||
];
|
||
_visiblePages = AllPages;
|
||
|
||
// ---- Archive ----
|
||
ArchiveRoot = new EditableField(_s.LastArchivePath ?? string.Empty, v => v.Length == 0 ? null : ArchiveLocations.Validate(v), v =>
|
||
{
|
||
_s.LastArchivePath = v.Length == 0 ? null : Path.GetFullPath(v);
|
||
Save();
|
||
UpdateArchiveFree();
|
||
_retarget = RetargetArchiveAsync();
|
||
}, () => Loc.L("Tooltips.Settings.ArchiveRoot"));
|
||
FolderTemplate = new EditableField(_s.FolderTemplate, v => NamingPreview.Validate(v, isFolder: true), v =>
|
||
{
|
||
_s.FolderTemplate = v;
|
||
Save();
|
||
_ = UpdateArchiveAsync(a => a with { Templates = a.Templates with { Folder = v } });
|
||
}, () => Loc.L("Tooltips.Settings.FolderTemplate"));
|
||
FileTemplate = new EditableField(_s.FileTemplate, v => NamingPreview.Validate(v, isFolder: false), v =>
|
||
{
|
||
_s.FileTemplate = v;
|
||
Save();
|
||
_ = UpdateArchiveAsync(a => a with { Templates = a.Templates with { File = v } });
|
||
}, () => Loc.L("Tooltips.Settings.FileTemplate"));
|
||
FolderTemplate.PropertyChanged += (_, e) =>
|
||
{
|
||
if (e.PropertyName == nameof(EditableField.Text)) UpdatePreview();
|
||
};
|
||
FileTemplate.PropertyChanged += (_, e) =>
|
||
{
|
||
if (e.PropertyName == nameof(EditableField.Text)) UpdatePreview();
|
||
};
|
||
|
||
// ---- Import ----
|
||
SessionGap = new EditableField(_s.ImportSessionGapMinutes.ToString(CultureInfo.CurrentCulture), v => ValidateInt(v, 1, 24 * 60), v =>
|
||
{
|
||
_s.ImportSessionGapMinutes = int.Parse(v, NumberStyles.Integer, CultureInfo.CurrentCulture);
|
||
Save();
|
||
}, () => Loc.L("Tooltips.Import.Gap"));
|
||
MinimumFrames = new EditableField(_s.ImportMinimumFrames.ToString(CultureInfo.CurrentCulture), v => ValidateInt(v, 1, 1000), v =>
|
||
{
|
||
_s.ImportMinimumFrames = int.Parse(v, NumberStyles.Integer, CultureInfo.CurrentCulture);
|
||
Save();
|
||
}, () => Loc.L("Tooltips.Import.MinimumFrames"));
|
||
|
||
// ---- Analysis ----
|
||
NightBrightness = new EditableField(_s.NightBrightnessPercent.ToString("0.##", CultureInfo.CurrentCulture), v => ValidateNumber(v, 0.5, 50), v =>
|
||
{
|
||
_s.NightBrightnessPercent = double.Parse(v, NumberStyles.Float, CultureInfo.CurrentCulture);
|
||
Save();
|
||
}, () => Loc.L("Tooltips.Settings.Night"));
|
||
StarDensity = new EditableField(_s.StarFieldDensity.ToString("0.##", CultureInfo.CurrentCulture), v => ValidateNumber(v, 1, 1000), v =>
|
||
{
|
||
_s.StarFieldDensity = double.Parse(v, NumberStyles.Float, CultureInfo.CurrentCulture);
|
||
Save();
|
||
}, () => Loc.L("Tooltips.Settings.Stars"));
|
||
|
||
// ---- Rendering ----
|
||
InstalledGb = Math.Max(2, (int)Math.Round(GC.GetGCMemoryInfo().TotalAvailableMemoryBytes / 1e9));
|
||
Parallelism = new EditableField(EffectiveParallelism.ToString(CultureInfo.CurrentCulture), ValidateParallelism, v =>
|
||
{
|
||
var n = int.Parse(v, NumberStyles.Integer, CultureInfo.CurrentCulture);
|
||
_s.Parallelism = n == ParallelismAuto ? null : n;
|
||
// Saving applies it: the job engine takes the new number of workers at once.
|
||
Save();
|
||
OnPropertyChanged(nameof(IsParallelismAuto));
|
||
}, () => Loc.L("Tooltips.Settings.Parallelism"));
|
||
JobPriorities = [.. PriorityKinds.Select(k => new JobPriorityRow(k, kind => Shell.Services.PriorityQueue.LevelOf(kind), SetJobPriority))];
|
||
|
||
// ---- Storage ----
|
||
CacheFolder = new EditableField(CacheStore.Folder(shell.Services.Environment, _s), v => ArchiveLocations.Validate(v), v =>
|
||
{
|
||
var full = Path.GetFullPath(v);
|
||
_s.CacheFolder = full.Equals(Shell.Services.Environment.CacheDirectory, StringComparison.OrdinalIgnoreCase) ? null : full;
|
||
Save();
|
||
_ = UpdateCacheUsageAsync();
|
||
}, () => Loc.L("Tooltips.Settings.CacheFolder"));
|
||
ThumbnailMemory = new EditableField(_s.ThumbnailMemoryItems.ToString(CultureInfo.CurrentCulture), v => ValidateInt(v, 100, 100_000), v =>
|
||
{
|
||
_s.ThumbnailMemoryItems = int.Parse(v, NumberStyles.Integer, CultureInfo.CurrentCulture);
|
||
Save();
|
||
if (Shell.Services.Thumbnails is { } thumbs) thumbs.Capacity = _s.ThumbnailMemoryItems;
|
||
}, () => Loc.L("Tooltips.Settings.ThumbnailMemory"));
|
||
CacheLimit = new EditableField(_s.CacheLimitGb.ToString(CultureInfo.CurrentCulture), v => ValidateInt(v, 1, 100_000), v =>
|
||
{
|
||
_s.CacheLimitGb = int.Parse(v, NumberStyles.Integer, CultureInfo.CurrentCulture);
|
||
Save();
|
||
}, () => Loc.L("Tooltips.Settings.CacheLimit"));
|
||
|
||
// ---- Server ----
|
||
DefaultServer = new EditableField(ServerAddress.Display(_s.ServerUrl), v => v.Trim().Length == 0 || ServerAddress.TryParse(v, out _) ? null : Loc.L("Errors.Server.Address"), v =>
|
||
{
|
||
var display = v.Trim().Length == 0 ? null : ServerAddress.TryParse(v, out var uri) ? ServerAddress.Display(uri) : null;
|
||
if (!string.Equals(display, ServerAddress.Display(_s.ServerUrl), StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
// A saved token belongs to the old server: never send it elsewhere.
|
||
_s.ProtectedToken = null;
|
||
}
|
||
_s.ServerUrl = display;
|
||
Save();
|
||
}, () => Loc.L("Tooltips.Settings.DefaultServer"));
|
||
|
||
SelectPageCommand = new RelayCommand(p =>
|
||
{
|
||
if (p is SettingsPageItem item) Page = item.Page;
|
||
else if (p is SettingsPage page) Page = page;
|
||
});
|
||
BrowseArchiveCommand = new RelayCommand(() => Browse(ArchiveRoot, "Settings.Archive.PickTitle"));
|
||
BrowseCacheCommand = new RelayCommand(() => Browse(CacheFolder, "Settings.Storage.PickTitle"));
|
||
ResetMemoryCommand = new RelayCommand(() => MemoryBudget = MemoryAuto, () => !IsMemoryAuto);
|
||
ResetParallelismCommand = new RelayCommand(() =>
|
||
{
|
||
_s.Parallelism = null;
|
||
Save();
|
||
Parallelism.Load(ParallelismAuto.ToString(CultureInfo.CurrentCulture));
|
||
OnPropertyChanged(nameof(IsParallelismAuto));
|
||
}, () => !IsParallelismAuto);
|
||
RedetectCommand = new AsyncRelayCommand(DetectEncodersAsync, () => !_isDetecting && !_isTesting);
|
||
SelfTestCommand = new AsyncRelayCommand(SelfTestAsync, () => !_isDetecting && !_isTesting && Encoders.Any(e => e.Row.CanSelfTest));
|
||
ClearCacheCommand = new AsyncRelayCommand(ClearCacheAsync);
|
||
OpenDataFolderCommand = new RelayCommand(() => ShellActions.Reveal(DataFolder));
|
||
OpenLogsCommand = new RelayCommand(() => ShellActions.Reveal(LogsFolder));
|
||
ExportDiagnosticsCommand = new AsyncRelayCommand(ExportDiagnosticsAsync);
|
||
BackupDatabaseCommand = new AsyncRelayCommand(BackupDatabaseAsync, () => Shell.Services.Database is not null);
|
||
RedetectFormatsCommand = new AsyncRelayCommand(() => DetectFormatsAsync(refresh: true), () => !_isDetectingFormats);
|
||
RestoreDatabaseCommand = new AsyncRelayCommand(RestoreDatabaseAsync, () => CanRestore);
|
||
CancelRestoreCommand = new RelayCommand(CancelRestore, () => IsRestoreStaged);
|
||
ResetAllCommand = new RelayCommand(ResetAll);
|
||
ResetSectionCommand = new RelayCommand(ResetSection, () => CanResetSection);
|
||
ExportSettingsCommand = new AsyncRelayCommand(ExportSettingsAsync);
|
||
ImportSettingsCommand = new AsyncRelayCommand(ImportSettingsAsync);
|
||
Loc.CultureChanged += OnCultureChanged;
|
||
UpdatePreview();
|
||
UpdateArchiveFree();
|
||
}
|
||
|
||
public ShellViewModel Shell { get; }
|
||
|
||
public IReadOnlyList<SettingsPageItem> AllPages { get; }
|
||
|
||
// ---------------- Navigation ----------------
|
||
|
||
public ICommand SelectPageCommand { get; }
|
||
|
||
public SettingsPage Page
|
||
{
|
||
get => _page;
|
||
set
|
||
{
|
||
if (!Set(ref _page, value)) return;
|
||
OnPropertyChanged(nameof(SelectedPageItem));
|
||
OnPropertyChanged(nameof(PageTitle));
|
||
OnPropertyChanged(nameof(CanResetSection));
|
||
if (value == SettingsPage.Rendering && Encoders.Count == 0 && !_isDetecting) _ = DetectEncodersAsync();
|
||
if (value == SettingsPage.Formats && Formats.Count == 0 && !_isDetectingFormats) _ = DetectFormatsAsync(refresh: false);
|
||
if (value == SettingsPage.Storage) _ = UpdateCacheUsageAsync();
|
||
if (value == SettingsPage.Advanced) LoadBackups();
|
||
}
|
||
}
|
||
|
||
public SettingsPageItem? SelectedPageItem
|
||
{
|
||
get => AllPages.First(p => p.Page == _page);
|
||
set
|
||
{
|
||
if (value is not null) Page = value.Page;
|
||
}
|
||
}
|
||
|
||
public string PageTitle => Loc.L("Settings.Page." + _page);
|
||
|
||
/// <summary>Filters the section list.</summary>
|
||
public string SearchText
|
||
{
|
||
get => _searchText;
|
||
set
|
||
{
|
||
if (!Set(ref _searchText, value ?? string.Empty)) return;
|
||
var text = _searchText.Trim();
|
||
VisiblePages = text.Length == 0 ? AllPages : [.. AllPages.Where(p => p.Matches(text))];
|
||
if (VisiblePages.Count > 0 && VisiblePages.All(p => p.Page != _page)) Page = VisiblePages[0].Page;
|
||
}
|
||
}
|
||
|
||
public IReadOnlyList<SettingsPageItem> VisiblePages
|
||
{
|
||
get => _visiblePages;
|
||
private set => Set(ref _visiblePages, value);
|
||
}
|
||
|
||
// ---------------- General ----------------
|
||
|
||
public IReadOnlyList<LanguageOption> Languages => LanguageCatalog.Available;
|
||
|
||
public LanguageOption SelectedLanguage
|
||
{
|
||
get => LanguageCatalog.Match(Loc.Culture);
|
||
set
|
||
{
|
||
if (value is null || value == SelectedLanguage) return;
|
||
_s.Language = value.Code;
|
||
UiLanguage.Apply(value.Code);
|
||
Save();
|
||
}
|
||
}
|
||
|
||
public bool IsDarkTheme
|
||
{
|
||
get => _s.Theme == AppTheme.Dark;
|
||
set
|
||
{
|
||
if (value) ApplyTheme(AppTheme.Dark);
|
||
}
|
||
}
|
||
|
||
public bool IsLightTheme
|
||
{
|
||
get => _s.Theme == AppTheme.Light;
|
||
set
|
||
{
|
||
if (value) ApplyTheme(AppTheme.Light);
|
||
}
|
||
}
|
||
|
||
public bool IsSystemTheme
|
||
{
|
||
get => _s.Theme == AppTheme.System;
|
||
set
|
||
{
|
||
if (value) ApplyTheme(AppTheme.System);
|
||
}
|
||
}
|
||
|
||
/// <summary>Where "Start with Windows" is kept (the Run key); screenshots, tests and portable copies keep it in memory.</summary>
|
||
internal IStartWithWindows Startup { get; set; }
|
||
|
||
/// <summary>The latest archive folder change: done once the rows show what the folder holds (tests wait for it).</summary>
|
||
internal Task ArchiveRetarget => _retarget;
|
||
|
||
/// <summary>The read of the open archive's settings when Settings was last shown: done once the rows show them (tests wait for it).</summary>
|
||
internal Task ArchiveReload { get; private set; } = Task.CompletedTask;
|
||
|
||
/// <summary>A portable copy leaves nothing in the registry (BRIEF §6.2): it offers no Startup row.</summary>
|
||
public bool ShowsStartup => !Shell.Services.Environment.IsPortable;
|
||
|
||
/// <summary>Chronos starts minimised when the user signs in to Windows.</summary>
|
||
public bool StartWithWindows
|
||
{
|
||
get => Startup.IsEnabled;
|
||
set
|
||
{
|
||
if (Startup.IsEnabled == value) return;
|
||
Startup.SetEnabled(value);
|
||
OnPropertyChanged();
|
||
}
|
||
}
|
||
|
||
/// <summary>Toasts also appear as Windows notifications while the window is minimised or in the background.</summary>
|
||
public bool OsNotifications
|
||
{
|
||
get => _s.OsNotifications;
|
||
set
|
||
{
|
||
if (_s.OsNotifications == value) return;
|
||
_s.OsNotifications = value;
|
||
Save();
|
||
OnPropertyChanged();
|
||
}
|
||
}
|
||
|
||
/// <summary>The usage counts consent belongs to monetization (BRIEF §21): only builds with it enabled offer it.</summary>
|
||
public bool ShowsUsageCounts => ProductFeatures.AdsEnabled;
|
||
|
||
public bool UsageCounts
|
||
{
|
||
get => _s.AnonymousUsageCounts;
|
||
set
|
||
{
|
||
if (_s.AnonymousUsageCounts == value) return;
|
||
_s.AnonymousUsageCounts = value;
|
||
Save();
|
||
OnPropertyChanged();
|
||
}
|
||
}
|
||
|
||
// ---------------- Archive ----------------
|
||
|
||
public EditableField ArchiveRoot { get; }
|
||
public EditableField FolderTemplate { get; }
|
||
public EditableField FileTemplate { get; }
|
||
public ICommand BrowseArchiveCommand { get; }
|
||
|
||
/// <summary>"1.8 TB free".</summary>
|
||
public string? ArchiveFreeText
|
||
{
|
||
get => _archiveFreeText;
|
||
private set => Set(ref _archiveFreeText, value);
|
||
}
|
||
|
||
/// <summary>The first three names the templates produce (live while typing).</summary>
|
||
public IReadOnlyList<string> PreviewNames
|
||
{
|
||
get => _previewNames;
|
||
private set => Set(ref _previewNames, value);
|
||
}
|
||
|
||
/// <summary>
|
||
/// BRIEF §8.5: 1280, 1920 (default), 2560 or full size; no proxies is what a server admin may also choose. A size the
|
||
/// archive got elsewhere (the admin panel also offers 3840) is listed with its number, never shown as another size.
|
||
/// </summary>
|
||
public IReadOnlyList<SettingsOption<int>> ProxySizes =>
|
||
[
|
||
.. Sizes([1280, 1920, 2560], _s.ProxyLongEdge is ProxyPolicy.FullSize or ProxyPolicy.Disabled ? null : _s.ProxyLongEdge),
|
||
new(ProxyPolicy.FullSize, Loc.L("Settings.Archive.FullSize")),
|
||
new(ProxyPolicy.Disabled, Loc.L("Settings.Archive.NoProxies")),
|
||
];
|
||
|
||
/// <summary>The open archive's proxy size (archive.json), and the one of new archives.</summary>
|
||
public SettingsOption<int> SelectedProxySize
|
||
{
|
||
get => ProxySizes.First(p => p.Value == _s.ProxyLongEdge);
|
||
set
|
||
{
|
||
if (value is null || value.Value == _s.ProxyLongEdge) return;
|
||
_s.ProxyLongEdge = value.Value;
|
||
Save();
|
||
OnPropertyChanged();
|
||
_ = UpdateArchiveAsync(a => a with { Proxies = a.Proxies with { LongEdge = value.Value } });
|
||
}
|
||
}
|
||
|
||
/// <summary>240, 320 (default), 480 or 640; another size of the archive (160 to 1024 are valid) is listed with its number.</summary>
|
||
public IReadOnlyList<SettingsOption<int>> ThumbnailSizes => Sizes([240, 320, 480, 640], _s.ThumbnailLongEdge);
|
||
|
||
/// <summary>The open archive's thumbnail size (archive.json), and the one of new archives.</summary>
|
||
public SettingsOption<int> SelectedThumbnailSize
|
||
{
|
||
get => ThumbnailSizes.First(p => p.Value == _s.ThumbnailLongEdge);
|
||
set
|
||
{
|
||
if (value is null || value.Value == _s.ThumbnailLongEdge) return;
|
||
_s.ThumbnailLongEdge = value.Value;
|
||
Save();
|
||
OnPropertyChanged();
|
||
_ = UpdateArchiveAsync(a => a with { Thumbnails = a.Thumbnails with { LongEdge = value.Value } });
|
||
}
|
||
}
|
||
|
||
public IReadOnlyList<SettingsOption<int>> ScanIntervals =>
|
||
[.. new[] { 5, 10, 15, 30, 60 }.Select(m => new SettingsOption<int>(m, Formatting.Duration(TimeSpan.FromMinutes(m))))];
|
||
|
||
/// <summary>How often this PC rescans the open archive for changes made elsewhere (BRIEF §7: polling).</summary>
|
||
public SettingsOption<int> SelectedScanInterval
|
||
{
|
||
get => ScanIntervals.FirstOrDefault(p => p.Value == _s.ScanIntervalMinutes) ?? ScanIntervals[1];
|
||
set
|
||
{
|
||
if (value is null || value.Value == _s.ScanIntervalMinutes) return;
|
||
_s.ScanIntervalMinutes = value.Value;
|
||
// Saving applies it: the running rescan timer takes the new period.
|
||
Save();
|
||
OnPropertyChanged();
|
||
}
|
||
}
|
||
|
||
// ---------------- Import ----------------
|
||
|
||
public EditableField SessionGap { get; }
|
||
public EditableField MinimumFrames { get; }
|
||
|
||
public bool ImportSubfolders
|
||
{
|
||
get => _s.ImportSubfolders;
|
||
set => SetSetting(_s.ImportSubfolders, value, v => _s.ImportSubfolders = v);
|
||
}
|
||
|
||
public bool ImportVerify
|
||
{
|
||
get => _s.ImportVerify;
|
||
set => SetSetting(_s.ImportVerify, value, v => _s.ImportVerify = v);
|
||
}
|
||
|
||
public bool IsSkipDuplicates
|
||
{
|
||
get => _s.ImportDuplicates == DuplicatePolicy.Skip;
|
||
set
|
||
{
|
||
if (value) SetDuplicates(DuplicatePolicy.Skip);
|
||
}
|
||
}
|
||
|
||
public bool IsImportDuplicates
|
||
{
|
||
get => _s.ImportDuplicates == DuplicatePolicy.ImportAgain;
|
||
set
|
||
{
|
||
if (value) SetDuplicates(DuplicatePolicy.ImportAgain);
|
||
}
|
||
}
|
||
|
||
public bool IsKeepCard
|
||
{
|
||
get => _s.ImportAfter == AfterImport.Keep;
|
||
set
|
||
{
|
||
if (value) SetAfterImport(AfterImport.Keep);
|
||
}
|
||
}
|
||
|
||
public bool IsDeleteImported
|
||
{
|
||
get => _s.ImportAfter == AfterImport.DeleteImported;
|
||
set
|
||
{
|
||
if (value) SetAfterImport(AfterImport.DeleteImported);
|
||
}
|
||
}
|
||
|
||
public bool IsFormatCard
|
||
{
|
||
get => _s.ImportAfter == AfterImport.FormatCard;
|
||
set
|
||
{
|
||
if (value) SetAfterImport(AfterImport.FormatCard);
|
||
}
|
||
}
|
||
|
||
public bool ImportEject
|
||
{
|
||
get => _s.ImportEject;
|
||
set => SetSetting(_s.ImportEject, value, v => _s.ImportEject = v);
|
||
}
|
||
|
||
// ---------------- Analysis ----------------
|
||
|
||
/// <summary>BRIEF §10.2: half native, capped at 2048 by default.</summary>
|
||
public IReadOnlyList<SettingsOption<int>> AnalysisWidths =>
|
||
[.. new[] { 1024, 2048, 3072, 4096 }.Select(n => new SettingsOption<int>(n, n.ToString(CultureInfo.InvariantCulture)))];
|
||
|
||
public SettingsOption<int> SelectedAnalysisWidth
|
||
{
|
||
get => AnalysisWidths.FirstOrDefault(p => p.Value == _s.AnalysisLongEdge) ?? AnalysisWidths[1];
|
||
set
|
||
{
|
||
if (value is null || value.Value == _s.AnalysisLongEdge) return;
|
||
_s.AnalysisLongEdge = value.Value;
|
||
Save();
|
||
OnPropertyChanged();
|
||
}
|
||
}
|
||
|
||
public EditableField NightBrightness { get; }
|
||
public EditableField StarDensity { get; }
|
||
|
||
public bool DeepAnalysisAfterImport
|
||
{
|
||
get => _s.DeepAnalysisAfterImport;
|
||
set => SetSetting(_s.DeepAnalysisAfterImport, value, v => _s.DeepAnalysisAfterImport = v);
|
||
}
|
||
|
||
public bool DeepAnalysisAfterScan
|
||
{
|
||
get => _s.DeepAnalysisAfterScan;
|
||
set => SetSetting(_s.DeepAnalysisAfterScan, value, v => _s.DeepAnalysisAfterScan = v);
|
||
}
|
||
|
||
// ---------------- Rendering ----------------
|
||
|
||
public IReadOnlyList<SettingsOption<QualityProfile>> Qualities =>
|
||
[.. Enum.GetValues<QualityProfile>().Select(q => new SettingsOption<QualityProfile>(q, Loc.L("Settings.Rendering.Quality." + q)))];
|
||
|
||
public SettingsOption<QualityProfile> SelectedQuality
|
||
{
|
||
get => Qualities.First(q => q.Value == _s.Quality);
|
||
set
|
||
{
|
||
if (value is null || value.Value == _s.Quality) return;
|
||
_s.Quality = value.Value;
|
||
Save();
|
||
OnPropertyChanged();
|
||
}
|
||
}
|
||
|
||
/// <summary>Installed memory in GB (rounded).</summary>
|
||
public int InstalledGb { get; }
|
||
|
||
public int MemoryMinimum => 2;
|
||
|
||
public int MemoryMaximum => Math.Max(MemoryMinimum, InstalledGb - 2);
|
||
|
||
/// <summary>Auto: a quarter of installed memory.</summary>
|
||
public int MemoryAuto => Math.Clamp(InstalledGb / 4, MemoryMinimum, MemoryMaximum);
|
||
|
||
public double MemoryBudget
|
||
{
|
||
get => _s.MemoryBudgetGb ?? MemoryAuto;
|
||
set
|
||
{
|
||
var gb = (int)Math.Round(Math.Clamp(value, MemoryMinimum, MemoryMaximum));
|
||
int? stored = gb == MemoryAuto ? null : gb;
|
||
if (stored == _s.MemoryBudgetGb) return;
|
||
_s.MemoryBudgetGb = stored;
|
||
Save();
|
||
OnPropertyChanged();
|
||
OnPropertyChanged(nameof(MemoryText));
|
||
OnPropertyChanged(nameof(IsMemoryAuto));
|
||
}
|
||
}
|
||
|
||
public bool IsMemoryAuto => _s.MemoryBudgetGb is null;
|
||
|
||
public string MemoryText => Loc.L("Settings.Rendering.Gb", (int)MemoryBudget);
|
||
|
||
public string InstalledText => Loc.L("Settings.Rendering.Installed", InstalledGb);
|
||
|
||
public string MemoryAutoText => Loc.L("Settings.Rendering.AutoValue", MemoryAuto);
|
||
|
||
public ICommand ResetMemoryCommand { get; }
|
||
|
||
public EditableField Parallelism { get; }
|
||
|
||
public int LogicalCores => Environment.ProcessorCount;
|
||
|
||
/// <summary>Auto: half the logical cores (photos the running job processes at once, owner review 1).</summary>
|
||
public int ParallelismAuto => ProcessingTuning.ParallelismAuto(LogicalCores);
|
||
|
||
private int EffectiveParallelism => _s.Parallelism ?? ParallelismAuto;
|
||
|
||
public bool IsParallelismAuto => _s.Parallelism is null;
|
||
|
||
public string CoresText => Loc.Plural("Settings.Rendering.Cores", LogicalCores);
|
||
|
||
public string ParallelismAutoText => Loc.L("Settings.Rendering.AutoValue", ParallelismAuto);
|
||
|
||
public ICommand ResetParallelismCommand { get; }
|
||
|
||
/// <summary>
|
||
/// The priority queue (owner review 1): on, a job of a higher level pauses the running one without asking, and that one
|
||
/// resumes by itself afterwards; off, jobs wait their turn.
|
||
/// </summary>
|
||
public bool PriorityQueue
|
||
{
|
||
get => _s.PriorityQueue;
|
||
set => SetSetting(_s.PriorityQueue, value, v => _s.PriorityQueue = v);
|
||
}
|
||
|
||
/// <summary>The kinds of job this PC runs with their levels in the priority queue, the ones the user waits for first.</summary>
|
||
public IReadOnlyList<JobPriorityRow> JobPriorities { get; }
|
||
|
||
public bool BackgroundPriority
|
||
{
|
||
get => _s.BackgroundPriority;
|
||
set
|
||
{
|
||
if (_s.BackgroundPriority == value) return;
|
||
_s.BackgroundPriority = value;
|
||
Save();
|
||
OnPropertyChanged();
|
||
_interfacePriority?.Update();
|
||
}
|
||
}
|
||
|
||
public bool IsPreferHardware
|
||
{
|
||
get => _s.HardwareEncoding == HardwarePreference.PreferHardware;
|
||
set => SetHardware(value, HardwarePreference.PreferHardware);
|
||
}
|
||
|
||
public bool IsSoftwareOnly
|
||
{
|
||
get => _s.HardwareEncoding == HardwarePreference.SoftwareOnly;
|
||
set => SetHardware(value, HardwarePreference.SoftwareOnly);
|
||
}
|
||
|
||
public bool IsHardwareForPreviews
|
||
{
|
||
get => _s.HardwareEncoding == HardwarePreference.HardwareForPreviews;
|
||
set => SetHardware(value, HardwarePreference.HardwareForPreviews);
|
||
}
|
||
|
||
public ObservableCollection<EncoderRowViewModel> Encoders { get; } = [];
|
||
|
||
/// <summary>"NVIDIA GeForce RTX 4070 · 3 encoders".</summary>
|
||
public string? AdapterText
|
||
{
|
||
get => _adapterText;
|
||
private set
|
||
{
|
||
if (Set(ref _adapterText, value)) OnPropertyChanged(nameof(AdapterToolTip));
|
||
}
|
||
}
|
||
|
||
/// <summary>The adapter and its encoders whole (the row may cut them at the minimum width), then what they are.</summary>
|
||
public string AdapterToolTip => AdapterText is { Length: > 0 } adapter
|
||
? string.Join(Loc.Separator, adapter, Loc.L("Tooltips.Settings.Adapter"))
|
||
: Loc.L("Tooltips.Settings.Adapter");
|
||
|
||
public bool IsDetecting
|
||
{
|
||
get => _isDetecting;
|
||
private set => Set(ref _isDetecting, value);
|
||
}
|
||
|
||
public ICommand RedetectCommand { get; }
|
||
public ICommand SelfTestCommand { get; }
|
||
|
||
// ---------------- Formats ----------------
|
||
|
||
public ObservableCollection<FormatRowViewModel> Formats { get; } = [];
|
||
|
||
/// <summary>The one-line notices of BRIEF §8.1: each missing codec extension with its Install button.</summary>
|
||
public ObservableCollection<MissingExtensionViewModel> MissingExtensions { get; } = [];
|
||
|
||
public bool HasMissingExtensions => MissingExtensions.Count > 0;
|
||
|
||
public bool IsDetectingFormats
|
||
{
|
||
get => _isDetectingFormats;
|
||
private set => Set(ref _isDetectingFormats, value);
|
||
}
|
||
|
||
public ICommand RedetectFormatsCommand { get; }
|
||
|
||
// ---------------- Storage ----------------
|
||
|
||
public EditableField CacheFolder { get; }
|
||
public EditableField ThumbnailMemory { get; }
|
||
public EditableField CacheLimit { get; }
|
||
public ICommand BrowseCacheCommand { get; }
|
||
public ICommand ClearCacheCommand { get; }
|
||
|
||
/// <summary>"1.4 GB used · 612 GB free".</summary>
|
||
public string? CacheUsageText
|
||
{
|
||
get => _cacheUsageText;
|
||
private set => Set(ref _cacheUsageText, value);
|
||
}
|
||
|
||
// ---------------- Server ----------------
|
||
|
||
public EditableField DefaultServer { get; }
|
||
|
||
public bool RenderNodeOptIn
|
||
{
|
||
get => _s.RenderNodeOptIn;
|
||
set
|
||
{
|
||
if (_s.RenderNodeOptIn == value) return;
|
||
_s.RenderNodeOptIn = value;
|
||
Save();
|
||
OnPropertyChanged();
|
||
Shell.Server.Refresh();
|
||
}
|
||
}
|
||
|
||
public ObservableCollection<TrustedCertificateRow> Certificates { get; } = [];
|
||
|
||
public bool HasCertificates => Certificates.Count > 0;
|
||
|
||
// ---------------- Updates ----------------
|
||
|
||
public bool CheckForUpdates
|
||
{
|
||
get => _s.CheckForUpdates;
|
||
set
|
||
{
|
||
if (_s.CheckForUpdates == value) return;
|
||
_s.CheckForUpdates = value;
|
||
Save();
|
||
OnPropertyChanged();
|
||
}
|
||
}
|
||
|
||
// ---------------- Advanced ----------------
|
||
|
||
public string DataFolder => Shell.Services.Environment.DataDirectory;
|
||
public string LogsFolder => Shell.Services.Environment.LogDirectory;
|
||
public string PortableText => Loc.L(Shell.Services.Environment.IsPortable ? "Settings.Advanced.PortableOn" : "Settings.Advanced.PortableOff");
|
||
public ICommand OpenDataFolderCommand { get; }
|
||
public ICommand OpenLogsCommand { get; }
|
||
public ICommand ExportDiagnosticsCommand { get; }
|
||
public ICommand BackupDatabaseCommand { get; }
|
||
|
||
/// <summary>The daily copies of the index, newest first (Restore).</summary>
|
||
public IReadOnlyList<BackupOption> Backups
|
||
{
|
||
get => _backups;
|
||
private set
|
||
{
|
||
if (!Set(ref _backups, value)) return;
|
||
OnPropertyChanged(nameof(HasBackups));
|
||
}
|
||
}
|
||
|
||
public bool HasBackups => _backups.Count > 0;
|
||
|
||
public BackupOption? SelectedBackup
|
||
{
|
||
get => _selectedBackup;
|
||
set
|
||
{
|
||
if (Set(ref _selectedBackup, value)) CommandManager.InvalidateRequerySuggested();
|
||
}
|
||
}
|
||
|
||
/// <summary>A restore waits for the next start of Chronos.</summary>
|
||
public bool IsRestoreStaged => DatabaseBackups.HasStagedRestore(Shell.Services.Environment.DatabasePath);
|
||
|
||
/// <summary>Also while the index cannot be opened: that is the case a restore exists for (BRIEF §6.2).</summary>
|
||
private bool CanRestore => !_isRestoring && _selectedBackup is not null && !IsRestoreStaged;
|
||
|
||
public ICommand RestoreDatabaseCommand { get; }
|
||
public ICommand CancelRestoreCommand { get; }
|
||
public ICommand ResetAllCommand { get; }
|
||
|
||
// ---------------- Footer ----------------
|
||
|
||
public ICommand ResetSectionCommand { get; }
|
||
|
||
/// <summary>
|
||
/// Advanced holds no setting with a default (paths and actions only), Formats only shows this PC and About only this
|
||
/// copy: they have no Reset section.
|
||
/// </summary>
|
||
public bool CanResetSection => _page is not (SettingsPage.Advanced or SettingsPage.Formats or SettingsPage.About);
|
||
public ICommand ExportSettingsCommand { get; }
|
||
public ICommand ImportSettingsCommand { get; }
|
||
|
||
/// <summary>
|
||
/// Loads what needs the services (certificates, cache usage, the open archive's settings), follows the server session,
|
||
/// applies "Background priority" while Chronos is in front and says how a restore staged before this start went, and
|
||
/// where the data of a portable copy in a OneDrive folder went.
|
||
/// </summary>
|
||
public void Attach()
|
||
{
|
||
try
|
||
{
|
||
CacheStore.Prepare(Shell.Services.Environment.CacheDirectory);
|
||
}
|
||
catch (IOException ex)
|
||
{
|
||
Log.Warning("settings", "Cache folder not prepared", ex);
|
||
}
|
||
LoadCertificates();
|
||
Shell.Services.Server.PropertyChanged += OnServerChanged;
|
||
if (System.Windows.Application.Current is { } app) _interfacePriority = new InterfacePriority(app, () => _s.BackgroundPriority);
|
||
_ = LoadArchiveAsync();
|
||
switch (Shell.Services.StagedRestore)
|
||
{
|
||
case StagedRestoreResult.Restored:
|
||
Shell.Notify(Loc.L("Settings.Advanced.Restored"));
|
||
break;
|
||
case StagedRestoreResult.Unreadable:
|
||
Shell.Notify(Loc.L("Settings.Advanced.RestoreFailed"), Loc.L("Errors.Backup.Unreadable"), isError: true);
|
||
break;
|
||
case StagedRestoreResult.Deferred:
|
||
Shell.Notify(Loc.L("Settings.Advanced.RestoreFailed"), Loc.L("Errors.Backup.Deferred"), isError: true);
|
||
break;
|
||
}
|
||
// BRIEF §6.2: a portable copy in a folder OneDrive synchronises keeps its data in this user's folder instead, and
|
||
// leaves the data it kept beside it before where it is. Only a user folder that is itself synchronised is unsafe.
|
||
var environment = Shell.Services.Environment;
|
||
if (environment.SyncedFolder is not null)
|
||
Shell.Notify(Loc.L("Settings.Advanced.DataInOneDrive"), Formatting.LeftToRight(DataFolder), Loc.L("Common.Open"),
|
||
Loc.L("Tooltips.Settings.DataInOneDrive"), () => ShellActions.Reveal(DataFolder), isError: true);
|
||
else if (environment.PortableSyncRoot is not null)
|
||
Shell.Notify(Loc.L("Settings.Advanced.DataOutsideOneDrive"), Formatting.LeftToRight(DataFolder), Loc.L("Common.Open"),
|
||
Loc.L("Tooltips.Settings.OpenDataFolder"), () => ShellActions.Reveal(DataFolder));
|
||
if (environment.EarlierPortableData is { } earlier)
|
||
Shell.Notify(Loc.L("Settings.Advanced.EarlierData"), Formatting.LeftToRight(earlier), Loc.L("Common.Open"),
|
||
Loc.L("Tooltips.Settings.EarlierData"), () => ShellActions.Reveal(earlier));
|
||
Startup.Refresh();
|
||
}
|
||
|
||
public override void Dispose()
|
||
{
|
||
Loc.CultureChanged -= OnCultureChanged;
|
||
Shell.Services.Server.PropertyChanged -= OnServerChanged;
|
||
_selfTest?.Cancel();
|
||
_interfacePriority?.Dispose();
|
||
base.Dispose();
|
||
}
|
||
|
||
/// <summary>Other screens change the archive and the server in use: Settings shows them when it opens.</summary>
|
||
protected override void OnActivated() => ReloadShared();
|
||
|
||
// ---------------- Implementation ----------------
|
||
|
||
private void Save() => Shell.Services.SaveSettings();
|
||
|
||
private void ApplyTheme(AppTheme theme)
|
||
{
|
||
_s.Theme = theme;
|
||
ThemeManager.Apply(theme);
|
||
Save();
|
||
OnPropertyChanged(nameof(IsDarkTheme));
|
||
OnPropertyChanged(nameof(IsLightTheme));
|
||
OnPropertyChanged(nameof(IsSystemTheme));
|
||
}
|
||
|
||
private void SetHardware(bool value, HardwarePreference preference)
|
||
{
|
||
if (!value || _s.HardwareEncoding == preference) return;
|
||
_s.HardwareEncoding = preference;
|
||
Save();
|
||
OnPropertyChanged(nameof(IsPreferHardware));
|
||
OnPropertyChanged(nameof(IsSoftwareOnly));
|
||
OnPropertyChanged(nameof(IsHardwareForPreviews));
|
||
Shell.Server.Refresh();
|
||
}
|
||
|
||
/// <summary>Stores a switch of Settings and tells the view (the caller's property).</summary>
|
||
private void SetSetting(bool current, bool value, Action<bool> store, [System.Runtime.CompilerServices.CallerMemberName] string? property = null)
|
||
{
|
||
if (current == value) return;
|
||
store(value);
|
||
Save();
|
||
OnPropertyChanged(property);
|
||
}
|
||
|
||
private void SetDuplicates(DuplicatePolicy policy)
|
||
{
|
||
if (_s.ImportDuplicates == policy) return;
|
||
_s.ImportDuplicates = policy;
|
||
Save();
|
||
OnPropertyChanged(nameof(IsSkipDuplicates));
|
||
OnPropertyChanged(nameof(IsImportDuplicates));
|
||
}
|
||
|
||
private void SetAfterImport(AfterImport after)
|
||
{
|
||
if (_s.ImportAfter == after) return;
|
||
_s.ImportAfter = after;
|
||
Save();
|
||
OnPropertyChanged(nameof(IsKeepCard));
|
||
OnPropertyChanged(nameof(IsDeleteImported));
|
||
OnPropertyChanged(nameof(IsFormatCard));
|
||
}
|
||
|
||
/// <summary>
|
||
/// Takes the archive and server values other screens set (opening an archive, connecting), unless the field holds an
|
||
/// edit not committed yet, and the sign-in entry as Task Manager may have left it.
|
||
/// </summary>
|
||
private void ReloadShared()
|
||
{
|
||
if (!ArchiveRoot.IsDirty) ArchiveRoot.Load(_s.LastArchivePath ?? string.Empty);
|
||
if (!DefaultServer.IsDirty) DefaultServer.Load(ServerAddress.Display(_s.ServerUrl));
|
||
OnPropertyChanged(nameof(StartWithWindows));
|
||
UpdateArchiveFree();
|
||
ArchiveReload = LoadArchiveAsync();
|
||
if (_page == SettingsPage.Advanced) LoadBackups();
|
||
}
|
||
|
||
/// <summary>
|
||
/// Shows the open archive's own templates, proxy size and thumbnail size unless a field holds an edit; they also become
|
||
/// the defaults of new archives. They come from its archive.json, which also brings the index up to a change another
|
||
/// process sharing the archive made, so imports follow it too. While the file cannot be read (offline), the templates
|
||
/// and proxy size are the index's and the thumbnail size stays this PC's: only the file knows the archive's. The open
|
||
/// 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).
|
||
/// </summary>
|
||
private Task<Archive?> LoadArchiveAsync() => LoadArchiveAsync(_s.LastArchivePath);
|
||
|
||
/// <summary>
|
||
/// <see cref="LoadArchiveAsync()"/> for the archive folder <paramref name="root"/>, which a folder change may have
|
||
/// replaced meanwhile: the rows are then left to the folder chosen since, and the archive registered at
|
||
/// <paramref name="root"/> is still returned, so edits made for that folder reach it.
|
||
/// </summary>
|
||
private async Task<Archive?> LoadArchiveAsync(string? root)
|
||
{
|
||
if (Shell.Services.Database is not { } db || Shell.Services.Archives is not { } archives) return null;
|
||
Archive? archive = null;
|
||
try
|
||
{
|
||
ArchiveSettings settings;
|
||
while (true)
|
||
{
|
||
var read = _archiveReads.BeginRead();
|
||
var registered = await db.Archives.ListAsync();
|
||
archive = root is { Length: > 0 } ? CurrentArchive.At(registered, root) : null;
|
||
if (!IsArchiveFolder(root)) return archive;
|
||
_archive = archive;
|
||
if (archive is null) return null;
|
||
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;
|
||
// A read that overlapped an edit being written may have missed it: it is not shown, and the rows are read
|
||
// again once no edit is being written (ArchiveReadGate), so this is done only when they show the archive.
|
||
if (_archiveReads.IsCurrent(read)) break;
|
||
await _archiveReads.WrittenAsync();
|
||
}
|
||
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
|
||
|| _s.ProxyLongEdge != settings.Proxies.LongEdge || _s.ThumbnailLongEdge != settings.Thumbnails.LongEdge;
|
||
_s.FolderTemplate = settings.Templates.Folder;
|
||
_s.FileTemplate = settings.Templates.File;
|
||
_s.ProxyLongEdge = settings.Proxies.LongEdge;
|
||
_s.ThumbnailLongEdge = settings.Thumbnails.LongEdge;
|
||
if (changed) Save();
|
||
// The lists first: a size the archive got elsewhere joins them before it is selected.
|
||
OnPropertyChanged(nameof(ProxySizes));
|
||
OnPropertyChanged(nameof(ThumbnailSizes));
|
||
OnPropertyChanged(nameof(SelectedProxySize));
|
||
OnPropertyChanged(nameof(SelectedThumbnailSize));
|
||
UpdatePreview();
|
||
}
|
||
catch (Exception ex) when (ex is DatabaseException or ArgumentException)
|
||
{
|
||
Log.Warning("settings", "The open archive's settings could not be read", ex);
|
||
}
|
||
return archive;
|
||
}
|
||
|
||
/// <summary>Whether <paramref name="root"/> is still this PC's archive folder (the one the rows show).</summary>
|
||
private bool IsArchiveFolder(string? root) => string.Equals(root, _s.LastArchivePath, StringComparison.Ordinal);
|
||
|
||
/// <summary>
|
||
/// The archive an Archive row edits, as the folder was when the row was edited (<paramref name="retarget"/>, the
|
||
/// 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.
|
||
/// </summary>
|
||
private async Task<Archive?> ArchiveAtFolderAsync(Task<Archive?> retarget)
|
||
{
|
||
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;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 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. <paramref name="retarget"/> is the folder change the edit was
|
||
/// made after, the latest one by default.
|
||
/// </summary>
|
||
private async Task UpdateArchiveAsync(Func<ArchiveSettings, ArchiveSettings> edit, Task<Archive?>? retarget = null)
|
||
{
|
||
retarget ??= _retarget;
|
||
var waited = !retarget.IsCompleted;
|
||
if (await ArchiveAtFolderAsync(retarget) is not { } archive || Shell.Services.Archives is not { } archives) return;
|
||
bool reload;
|
||
_archiveReads.BeginWrite();
|
||
try
|
||
{
|
||
var updated = await Task.Run(() => archives.UpdateSettingsAsync(archive.Id, edit));
|
||
// The archive folder may have changed meanwhile: the rows then belong to another archive.
|
||
if (_archive?.Id == updated.Id) _archive = updated;
|
||
// The open showed the archive's values over the edit: unless another folder was chosen since, the rows (and
|
||
// this PC's defaults) take what it holds now.
|
||
reload = waited && _retarget == retarget;
|
||
}
|
||
catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or ArgumentException or InvalidDataException or NewerFormatException
|
||
or DatabaseException)
|
||
{
|
||
Log.Warning("settings", "The archive settings were not saved", ex);
|
||
Shell.Notify(Loc.L("Settings.Archive.NotSaved"), ArchiveActions.Cause(ex), isError: true);
|
||
reload = true;
|
||
}
|
||
finally
|
||
{
|
||
// A read of the archive's settings this write overlapped was not shown: it reads again once no edit is written.
|
||
_archiveReads.EndWrite();
|
||
}
|
||
// Only once the write ended: a read begun while it is written waits for that end.
|
||
if (reload) await LoadArchiveAsync();
|
||
}
|
||
|
||
/// <summary>
|
||
/// Every archive row into the archive found after <paramref name="retarget"/>: Archive › Reset section, after the user
|
||
/// confirmed it for that archive.
|
||
/// </summary>
|
||
private Task PushArchiveSettingsAsync(Task<Archive?> 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);
|
||
|
||
/// <summary>
|
||
/// 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 registered at that folder (null for none),
|
||
/// even when another folder has been chosen since: edits made for this one go there.
|
||
/// </summary>
|
||
private async Task<Archive?> RetargetArchiveAsync()
|
||
{
|
||
_archive = null;
|
||
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 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(root);
|
||
}
|
||
|
||
/// <summary>
|
||
/// Archive › Reset section with an archive open writes the defaults into that archive's archive.json, which the server
|
||
/// and the other PCs share: the user confirms it for that archive by name first.
|
||
/// </summary>
|
||
private bool ConfirmArchiveReset(Archive archive) => Shell.Services.Dialogs.Confirm(new ConfirmRequest
|
||
{
|
||
Heading = Loc.L("Settings.Archive.ResetTitle", archive.Name),
|
||
Message = Loc.L("Settings.Archive.ResetMessage"),
|
||
SafeText = Loc.L("Settings.Storage.Keep"),
|
||
SafeToolTip = Loc.L("Tooltips.Settings.KeepArchiveSettings"),
|
||
ActionText = Loc.L("Settings.Archive.ResetAction"),
|
||
ActionToolTip = Loc.L("Tooltips.Settings.ResetArchiveConfirm"),
|
||
IsDestructive = true,
|
||
});
|
||
|
||
private void OnServerChanged(object? sender, System.ComponentModel.PropertyChangedEventArgs e)
|
||
{
|
||
LoadCertificates();
|
||
if (!DefaultServer.IsDirty) DefaultServer.Load(ServerAddress.Display(_s.ServerUrl));
|
||
}
|
||
|
||
private void UpdatePreview() => PreviewNames = NamingPreview.FirstNames(FolderTemplate.Text, FileTemplate.Text);
|
||
|
||
private void UpdateArchiveFree()
|
||
{
|
||
var path = _s.LastArchivePath;
|
||
ArchiveFreeText = ArchiveLocations.FreeSpace(path) is { } free ? Loc.L("Settings.Archive.Free", Formatting.Bytes(free)) : null;
|
||
}
|
||
|
||
/// <summary>The preset sizes in order, with <paramref name="current"/> among them when it is none of them.</summary>
|
||
private static IReadOnlyList<SettingsOption<int>> Sizes(int[] presets, int? current)
|
||
{
|
||
var values = current is { } size && !presets.Contains(size) ? presets.Append(size) : presets;
|
||
return [.. values.Order().Select(n => new SettingsOption<int>(n, n.ToString(CultureInfo.InvariantCulture)))];
|
||
}
|
||
|
||
private string? ValidateParallelism(string text) => ValidateInt(text, 1, Math.Max(1, LogicalCores * 2));
|
||
|
||
/// <summary>The kinds the priority queue lists, in the order of the Jobs screen's kinds the user starts most.</summary>
|
||
private static readonly JobKind[] PriorityKinds =
|
||
[
|
||
JobKind.Render, JobKind.Import, JobKind.Download, JobKind.UploadCommit, JobKind.Scan, JobKind.Rebuild, JobKind.Verify, JobKind.LightAnalyse,
|
||
JobKind.DeepAnalyse, JobKind.Thumbs, JobKind.Proxies, JobKind.Maintenance, JobKind.Duplicates, JobKind.Orphans, JobKind.Adopt, JobKind.Move,
|
||
];
|
||
|
||
/// <summary>Stores <paramref name="level"/> for <paramref name="kind"/>, keeping only the levels that differ from the defaults.</summary>
|
||
private void SetJobPriority(JobKind kind, JobKindPriority level)
|
||
{
|
||
var queue = Shell.Services.PriorityQueue;
|
||
var levels = Enum.GetValues<JobKind>().ToDictionary(k => k, queue.LevelOf);
|
||
levels[kind] = level;
|
||
_s.JobPriorities = JobPriorityQueue.Changed(levels);
|
||
Save();
|
||
}
|
||
|
||
private static string? ValidateInt(string text, int min, int max) =>
|
||
int.TryParse(text.Trim(), NumberStyles.Integer, CultureInfo.CurrentCulture, out var n) && n >= min && n <= max
|
||
? null
|
||
: Loc.L("Errors.Number.Range", min.ToString("N0", Loc.Culture), max.ToString("N0", Loc.Culture));
|
||
|
||
private static string? ValidateNumber(string text, double min, double max) =>
|
||
double.TryParse(text.Trim(), NumberStyles.Float, CultureInfo.CurrentCulture, out var n) && double.IsFinite(n) && n >= min && n <= max
|
||
? null
|
||
: Loc.L("Errors.Number.DecimalRange", min.ToString("0.##", Loc.Culture), max.ToString("0.##", Loc.Culture));
|
||
|
||
private void Browse(EditableField field, string titleKey)
|
||
{
|
||
var folder = Shell.Services.Dialogs.PickFolder(Loc.L(titleKey), field.Value.Length > 0 ? field.Value : null);
|
||
if (folder is null) return;
|
||
field.Text = folder;
|
||
field.Commit();
|
||
}
|
||
|
||
/// <summary>Lists the encoders again (Re-detect).</summary>
|
||
public async Task DetectEncodersAsync()
|
||
{
|
||
IsDetecting = true;
|
||
try
|
||
{
|
||
var inventory = Shell.Services.Encoders;
|
||
var (adapter, rows) = await Task.Run(() => (inventory.Adapter(), inventory.Detect()));
|
||
Encoders.Clear();
|
||
foreach (var row in rows) Encoders.Add(new EncoderRowViewModel(row));
|
||
var hardware = rows.Count(r => r.Hardware);
|
||
AdapterText = string.Join(Loc.Separator, new[] { adapter, Loc.Plural("Settings.Rendering.EncoderCount", rows.Count(r => r.Source == EncoderSource.MediaFoundation)) }
|
||
.Where(s => !string.IsNullOrEmpty(s)));
|
||
Log.Info("settings", $"{rows.Count} encoder(s), {hardware} hardware");
|
||
}
|
||
catch (Exception ex) when (ex is System.Runtime.InteropServices.COMException or PlatformNotSupportedException or DllNotFoundException)
|
||
{
|
||
Log.Warning("settings", "Encoders could not be detected", ex);
|
||
}
|
||
finally
|
||
{
|
||
IsDetecting = false;
|
||
CommandManager.InvalidateRequerySuggested();
|
||
}
|
||
}
|
||
|
||
/// <summary>Encodes the synthetic test clip with every encoder in turn (Run self-test).</summary>
|
||
public async Task SelfTestAsync()
|
||
{
|
||
_isTesting = true;
|
||
_selfTest = new CancellationTokenSource();
|
||
try
|
||
{
|
||
foreach (var row in Encoders.Where(r => r.Row.CanSelfTest).ToList())
|
||
{
|
||
row.IsTesting = true;
|
||
try
|
||
{
|
||
row.Result = await Shell.Services.Encoders.SelfTestAsync(row.Row, _selfTest.Token);
|
||
}
|
||
finally
|
||
{
|
||
row.IsTesting = false;
|
||
}
|
||
}
|
||
}
|
||
finally
|
||
{
|
||
_isTesting = false;
|
||
_selfTest.Dispose();
|
||
_selfTest = null;
|
||
CommandManager.InvalidateRequerySuggested();
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Lists the decode tier of every format on this PC (Settings › Formats); with <paramref name="refresh"/> the codecs are
|
||
/// detected again first (after installing an extension), and the next jobs decode with them.
|
||
/// </summary>
|
||
public async Task DetectFormatsAsync(bool refresh)
|
||
{
|
||
IsDetectingFormats = true;
|
||
try
|
||
{
|
||
var inventory = Shell.Services.Formats;
|
||
var report = await Task.Run(() => inventory.Detect(refresh));
|
||
Formats.Clear();
|
||
foreach (var row in report.Formats) Formats.Add(new FormatRowViewModel(row));
|
||
MissingExtensions.Clear();
|
||
foreach (var extension in report.Missing)
|
||
MissingExtensions.Add(new MissingExtensionViewModel(extension, new RelayCommand(() => inventory.OpenStore(extension))));
|
||
OnPropertyChanged(nameof(HasMissingExtensions));
|
||
Log.Info("settings", $"{report.Formats.Count(f => f.Tier == Core.Imaging.DecodeTier.Native)} format(s) decode fully; missing extensions: {string.Join(", ", report.Missing.Select(m => m.ProductName))}");
|
||
}
|
||
catch (Exception ex) when (ex is System.Runtime.InteropServices.COMException or PlatformNotSupportedException or DllNotFoundException or EntryPointNotFoundException)
|
||
{
|
||
Log.Warning("settings", "Image codecs could not be detected", ex);
|
||
}
|
||
finally
|
||
{
|
||
IsDetectingFormats = false;
|
||
CommandManager.InvalidateRequerySuggested();
|
||
}
|
||
}
|
||
|
||
private async Task UpdateCacheUsageAsync()
|
||
{
|
||
var folder = CacheStore.Folder(Shell.Services.Environment, _s);
|
||
var (used, free) = await Task.Run(() => (CacheStore.Size(folder), ArchiveLocations.FreeSpace(folder)));
|
||
CacheUsageText = free is { } f
|
||
? Loc.L("Settings.Storage.Usage", Formatting.Bytes(used), Formatting.Bytes(f))
|
||
: Loc.L("Settings.Storage.Used", Formatting.Bytes(used));
|
||
}
|
||
|
||
private async Task ClearCacheAsync()
|
||
{
|
||
var folder = CacheStore.Folder(Shell.Services.Environment, _s);
|
||
var confirmed = Shell.Services.Dialogs.Confirm(new ConfirmRequest
|
||
{
|
||
Heading = Loc.L("Settings.Storage.ClearTitle"),
|
||
Message = Loc.L("Settings.Storage.ClearMessage"),
|
||
Detail = Formatting.LeftToRight(folder),
|
||
DetailToolTip = Loc.L("Tooltips.Settings.CacheFolder"),
|
||
SafeText = Loc.L("Settings.Storage.Keep"),
|
||
SafeToolTip = Loc.L("Tooltips.Settings.KeepCache"),
|
||
ActionText = Loc.L("Settings.Storage.Clear"),
|
||
ActionToolTip = Loc.L("Tooltips.Settings.ClearCache"),
|
||
IsDestructive = true,
|
||
});
|
||
if (!confirmed) return;
|
||
Shell.Services.Thumbnails?.Clear();
|
||
if (!CacheStore.IsOwned(folder))
|
||
{
|
||
Shell.Notify(Loc.L("Settings.Storage.NotOwned"), isError: true);
|
||
return;
|
||
}
|
||
var freed = await Task.Run(() => CacheStore.Clear(folder));
|
||
Shell.Notify(Loc.L("Settings.Storage.Cleared", Formatting.Bytes(freed)));
|
||
await UpdateCacheUsageAsync();
|
||
}
|
||
|
||
private async Task ExportDiagnosticsAsync()
|
||
{
|
||
var folder = Shell.Services.Dialogs.PickFolder(Loc.L("Settings.Advanced.DiagnosticsTitle"));
|
||
if (folder is null) return;
|
||
var selfTests = Encoders.Where(e => e.HasResult).Select(e => $"Self-test {e.Codec} {e.Row.DisplayName}: {e.ResultText}").ToList();
|
||
try
|
||
{
|
||
var path = await DiagnosticsBundle.CreateAsync(Shell.Services, folder, selfTests);
|
||
Shell.Notify(Loc.L("Settings.Advanced.DiagnosticsDone"), Path.GetFileName(path), Loc.L("Library.Export.Show"), Loc.L("Tooltips.Library.ShowExport"), () => ShellActions.Reveal(path));
|
||
}
|
||
catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or DatabaseException)
|
||
{
|
||
Shell.ReportError(ex);
|
||
}
|
||
}
|
||
|
||
private async Task BackupDatabaseAsync()
|
||
{
|
||
if (Shell.Services.Database is not { } db) return;
|
||
try
|
||
{
|
||
var path = await db.BackupAsync(Shell.Services.Environment.BackupDirectory, DatabaseBackups.Keep);
|
||
Shell.Notify(Loc.L("Settings.Advanced.BackupDone"), Path.GetFileName(path), Loc.L("Library.Export.Show"), Loc.L("Tooltips.Library.ShowExport"), () => ShellActions.Reveal(path));
|
||
}
|
||
catch (Exception ex) when (ex is DatabaseException or IOException or NotSupportedException)
|
||
{
|
||
Shell.ReportError(ex);
|
||
}
|
||
LoadBackups();
|
||
}
|
||
|
||
/// <summary>The copies in the backups folder, newest first; the newest is chosen.</summary>
|
||
private void LoadBackups()
|
||
{
|
||
var environment = Shell.Services.Environment;
|
||
IReadOnlyList<DatabaseBackup> found;
|
||
try
|
||
{
|
||
found = DatabaseBackups.List(environment.BackupDirectory, environment.DatabasePath);
|
||
}
|
||
catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
|
||
{
|
||
Log.Warning("settings", "The backups folder could not be listed", ex);
|
||
found = [];
|
||
}
|
||
var selected = _selectedBackup?.Backup.Path;
|
||
Backups = [.. found.Select(b => new BackupOption(b))];
|
||
SelectedBackup = Backups.FirstOrDefault(b => b.Backup.Path == selected) ?? Backups.FirstOrDefault();
|
||
OnPropertyChanged(nameof(IsRestoreStaged));
|
||
}
|
||
|
||
/// <summary>
|
||
/// Restore (BRIEF §6.2, §12.8): a dry run reads what the chosen copy holds against the index now (shown as unreadable
|
||
/// when the index did not open, the case a restore exists for); after the user's destructive confirmation the copy is
|
||
/// staged beside the index for the next start, where the index as it is then is kept first and replaced before it is
|
||
/// opened (<see cref="DatabaseBackups.RestoreStagedAsync"/>; the staged copy is out of reach of the pruning to three
|
||
/// copies). Nothing replaces the index while Chronos runs.
|
||
/// </summary>
|
||
private async Task RestoreDatabaseAsync()
|
||
{
|
||
if (_selectedBackup is not { } option) return;
|
||
var backup = option.Backup;
|
||
var environment = Shell.Services.Environment;
|
||
_isRestoring = true;
|
||
CommandManager.InvalidateRequerySuggested();
|
||
try
|
||
{
|
||
DatabaseSummary restored;
|
||
try
|
||
{
|
||
restored = await Task.Run(() => DatabaseBackups.SummarizeBackupAsync(backup.Path, environment.DataDirectory));
|
||
}
|
||
catch (Exception ex) when (ex is InvalidDataException or IOException or UnauthorizedAccessException or DatabaseException)
|
||
{
|
||
Log.Warning("settings", $"The backup {backup.Path} cannot be restored", ex);
|
||
Shell.Notify(Loc.L("Errors.Backup.Unreadable"), isError: true);
|
||
return;
|
||
}
|
||
DatabaseSummary? current = null;
|
||
if (Shell.Services.Database is { } db)
|
||
{
|
||
try
|
||
{
|
||
current = await DatabaseBackups.SummarizeAsync(db);
|
||
}
|
||
catch (DatabaseException ex)
|
||
{
|
||
// A damaged index may open and still fail to count: it is shown as unreadable, and the restore remains possible.
|
||
Log.Warning("settings", "The current index could not be summarized", ex);
|
||
}
|
||
}
|
||
var currentLine = current is { } now
|
||
? Loc.L("Settings.Advanced.RestoreCurrent", Formatting.Count(now.Sequences), Formatting.Count(now.Photos))
|
||
: Loc.L("Settings.Advanced.RestoreUnreadable");
|
||
var confirmed = Shell.Services.Dialogs.Confirm(new ConfirmRequest
|
||
{
|
||
Heading = Loc.L("Settings.Advanced.RestoreTitle", option.Label),
|
||
Message = Loc.L("Settings.Advanced.RestoreMessage"),
|
||
Detail = string.Join(Environment.NewLine,
|
||
Loc.L("Settings.Advanced.RestoreBackup", Formatting.Count(restored.Sequences), Formatting.Count(restored.Photos)), currentLine),
|
||
IsDetailMonospaced = false,
|
||
DetailToolTip = Formatting.LeftToRight(backup.Path),
|
||
SafeText = Loc.L("Settings.Storage.Keep"),
|
||
SafeToolTip = Loc.L("Tooltips.Settings.KeepIndex"),
|
||
ActionText = Loc.L("Settings.Advanced.RestoreAction"),
|
||
ActionToolTip = Loc.L("Tooltips.Settings.RestoreConfirm"),
|
||
IsDestructive = true,
|
||
});
|
||
if (!confirmed) return;
|
||
try
|
||
{
|
||
await Task.Run(() => DatabaseBackups.StageRestoreAsync(backup.Path, environment.DatabasePath));
|
||
}
|
||
catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
|
||
{
|
||
Log.Error("settings", "The restore was not staged", ex);
|
||
Shell.ReportError(ex);
|
||
return;
|
||
}
|
||
Log.Info("settings", $"Restore of {backup.Path} staged ({restored.Sequences} sequences, {restored.Photos} photos)");
|
||
Shell.Notify(Loc.L("Settings.Advanced.RestoreStaged"), Loc.L("Settings.Advanced.RestartToRestore"));
|
||
}
|
||
finally
|
||
{
|
||
_isRestoring = false;
|
||
LoadBackups();
|
||
CommandManager.InvalidateRequerySuggested();
|
||
}
|
||
}
|
||
|
||
private void CancelRestore()
|
||
{
|
||
try
|
||
{
|
||
DatabaseBackups.CancelStagedRestore(Shell.Services.Environment.DatabasePath);
|
||
}
|
||
catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
|
||
{
|
||
Shell.ReportError(ex);
|
||
}
|
||
OnPropertyChanged(nameof(IsRestoreStaged));
|
||
CommandManager.InvalidateRequerySuggested();
|
||
}
|
||
|
||
private void ResetSection()
|
||
{
|
||
var defaults = new AppSettings();
|
||
switch (_page)
|
||
{
|
||
case SettingsPage.General:
|
||
_s.AnonymousUsageCounts = defaults.AnonymousUsageCounts;
|
||
_s.OsNotifications = defaults.OsNotifications;
|
||
Startup.SetEnabled(false);
|
||
ApplyTheme(defaults.Theme);
|
||
_s.Language = null;
|
||
UiLanguage.Apply(null);
|
||
break;
|
||
case SettingsPage.Archive:
|
||
_ = ResetArchiveAsync(defaults);
|
||
return;
|
||
case SettingsPage.Import:
|
||
_s.ImportSessionGapMinutes = defaults.ImportSessionGapMinutes;
|
||
_s.ImportMinimumFrames = defaults.ImportMinimumFrames;
|
||
_s.ImportSubfolders = defaults.ImportSubfolders;
|
||
_s.ImportVerify = defaults.ImportVerify;
|
||
_s.ImportDuplicates = defaults.ImportDuplicates;
|
||
_s.ImportAfter = defaults.ImportAfter;
|
||
_s.ImportEject = defaults.ImportEject;
|
||
LoadImportFields();
|
||
break;
|
||
case SettingsPage.Analysis:
|
||
_s.AnalysisLongEdge = defaults.AnalysisLongEdge;
|
||
_s.NightBrightnessPercent = defaults.NightBrightnessPercent;
|
||
_s.StarFieldDensity = defaults.StarFieldDensity;
|
||
_s.DeepAnalysisAfterImport = defaults.DeepAnalysisAfterImport;
|
||
_s.DeepAnalysisAfterScan = defaults.DeepAnalysisAfterScan;
|
||
LoadAnalysisFields();
|
||
break;
|
||
case SettingsPage.Rendering:
|
||
_s.Quality = defaults.Quality;
|
||
_s.MemoryBudgetGb = null;
|
||
_s.Parallelism = null;
|
||
_s.BackgroundPriority = defaults.BackgroundPriority;
|
||
_s.HardwareEncoding = defaults.HardwareEncoding;
|
||
_s.PriorityQueue = defaults.PriorityQueue;
|
||
_s.JobPriorities = [];
|
||
foreach (var row in JobPriorities) row.Refresh();
|
||
Parallelism.Load(ParallelismAuto.ToString(CultureInfo.CurrentCulture));
|
||
_interfacePriority?.Update();
|
||
break;
|
||
case SettingsPage.Storage:
|
||
_s.CacheFolder = null;
|
||
_s.ThumbnailMemoryItems = defaults.ThumbnailMemoryItems;
|
||
_s.CacheLimitGb = defaults.CacheLimitGb;
|
||
CacheFolder.Load(CacheStore.Folder(Shell.Services.Environment, _s));
|
||
ThumbnailMemory.Load(_s.ThumbnailMemoryItems.ToString(CultureInfo.CurrentCulture));
|
||
CacheLimit.Load(_s.CacheLimitGb.ToString(CultureInfo.CurrentCulture));
|
||
if (Shell.Services.Thumbnails is { } thumbs) thumbs.Capacity = _s.ThumbnailMemoryItems;
|
||
break;
|
||
case SettingsPage.Server:
|
||
_s.RenderNodeOptIn = defaults.RenderNodeOptIn;
|
||
break;
|
||
case SettingsPage.Updates:
|
||
_s.CheckForUpdates = defaults.CheckForUpdates;
|
||
break;
|
||
}
|
||
Save();
|
||
OnAllPropertiesChanged();
|
||
Shell.Server.Refresh();
|
||
}
|
||
|
||
/// <summary>
|
||
/// Archive › Reset section. The rows are the open archive's own: resetting them changes it for everyone sharing it, so
|
||
/// only when confirmed. The archive at a folder just chosen is opened first, so the question names it and the reset
|
||
/// reaches it instead of being undone when it opens.
|
||
/// </summary>
|
||
private async Task ResetArchiveAsync(AppSettings defaults)
|
||
{
|
||
var retarget = _retarget;
|
||
var open = await ArchiveAtFolderAsync(retarget);
|
||
if (open is not null && !ConfirmArchiveReset(open)) return;
|
||
_s.FolderTemplate = defaults.FolderTemplate;
|
||
_s.FileTemplate = defaults.FileTemplate;
|
||
_s.ProxyLongEdge = defaults.ProxyLongEdge;
|
||
_s.ThumbnailLongEdge = defaults.ThumbnailLongEdge;
|
||
_s.ScanIntervalMinutes = defaults.ScanIntervalMinutes;
|
||
FolderTemplate.Load(_s.FolderTemplate);
|
||
FileTemplate.Load(_s.FileTemplate);
|
||
UpdatePreview();
|
||
Save();
|
||
OnAllPropertiesChanged();
|
||
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()
|
||
{
|
||
SessionGap.Load(_s.ImportSessionGapMinutes.ToString(CultureInfo.CurrentCulture));
|
||
MinimumFrames.Load(_s.ImportMinimumFrames.ToString(CultureInfo.CurrentCulture));
|
||
}
|
||
|
||
private void LoadAnalysisFields()
|
||
{
|
||
NightBrightness.Load(_s.NightBrightnessPercent.ToString("0.##", CultureInfo.CurrentCulture));
|
||
StarDensity.Load(_s.StarFieldDensity.ToString("0.##", CultureInfo.CurrentCulture));
|
||
}
|
||
|
||
/// <summary>
|
||
/// Advanced › Reset: every preference of this PC back to its default after a destructive confirmation. What identifies
|
||
/// this PC's data and session stays: the archive folder, the server, its session and trusted certificates, the window
|
||
/// and the first-run choice. The open archive's own settings (archive.json, shared with the server and other PCs) are
|
||
/// not touched: the Archive rows show them again (with no archive open, they show the reset defaults of new archives).
|
||
/// </summary>
|
||
private void ResetAll()
|
||
{
|
||
var confirmed = Shell.Services.Dialogs.Confirm(new ConfirmRequest
|
||
{
|
||
Heading = Loc.L("Settings.Advanced.ResetTitle"),
|
||
Message = Loc.L("Settings.Advanced.ResetMessage"),
|
||
SafeText = Loc.L("Settings.Storage.Keep"),
|
||
SafeToolTip = Loc.L("Tooltips.Settings.KeepSettings"),
|
||
ActionText = Loc.L("Settings.Advanced.ResetAction"),
|
||
ActionToolTip = Loc.L("Tooltips.Settings.ResetConfirm"),
|
||
IsDestructive = true,
|
||
});
|
||
if (!confirmed) return;
|
||
var defaults = new AppSettings
|
||
{
|
||
LastArchivePath = _s.LastArchivePath,
|
||
ServerUrl = _s.ServerUrl,
|
||
ServerUsername = _s.ServerUsername,
|
||
ProtectedToken = _s.ProtectedToken,
|
||
TrustedCertificates = _s.TrustedCertificates,
|
||
RecentServers = _s.RecentServers,
|
||
Window = _s.Window,
|
||
RailCollapsed = _s.RailCollapsed,
|
||
LastEditedSequence = _s.LastEditedSequence,
|
||
FirstRunCompleted = _s.FirstRunCompleted,
|
||
JobsClearedAt = _s.JobsClearedAt,
|
||
};
|
||
// Start with Windows lives in the registry, not in the settings file: its default is off.
|
||
Startup.SetEnabled(false);
|
||
ApplyAll(defaults);
|
||
_ = LoadArchiveAsync();
|
||
Log.Info("settings", "Every setting reset to its default");
|
||
Shell.Notify(Loc.L("Settings.Advanced.ResetDone"));
|
||
}
|
||
|
||
/// <summary>Takes every value of <paramref name="source"/> and shows it everywhere (reset, import).</summary>
|
||
private void ApplyAll(AppSettings source)
|
||
{
|
||
foreach (var property in typeof(AppSettings).GetProperties().Where(p => p.CanRead && p.CanWrite))
|
||
property.SetValue(_s, property.GetValue(source));
|
||
Save();
|
||
ThemeManager.Apply(_s.Theme);
|
||
UiLanguage.Apply(_s.Language);
|
||
ArchiveRoot.Load(_s.LastArchivePath ?? string.Empty);
|
||
FolderTemplate.Load(_s.FolderTemplate);
|
||
FileTemplate.Load(_s.FileTemplate);
|
||
LoadImportFields();
|
||
LoadAnalysisFields();
|
||
Parallelism.Load(EffectiveParallelism.ToString(CultureInfo.CurrentCulture));
|
||
CacheFolder.Load(CacheStore.Folder(Shell.Services.Environment, _s));
|
||
ThumbnailMemory.Load(_s.ThumbnailMemoryItems.ToString(CultureInfo.CurrentCulture));
|
||
CacheLimit.Load(_s.CacheLimitGb.ToString(CultureInfo.CurrentCulture));
|
||
if (Shell.Services.Thumbnails is { } thumbs) thumbs.Capacity = _s.ThumbnailMemoryItems;
|
||
DefaultServer.Load(ServerAddress.Display(_s.ServerUrl));
|
||
_interfacePriority?.Update();
|
||
foreach (var row in JobPriorities) row.Refresh();
|
||
UpdatePreview();
|
||
LoadCertificates();
|
||
OnAllPropertiesChanged();
|
||
Shell.Server.Refresh();
|
||
}
|
||
|
||
private async Task ExportSettingsAsync()
|
||
{
|
||
var folder = Shell.Services.Dialogs.PickFolder(Loc.L("Settings.Export.Title"));
|
||
if (folder is null) return;
|
||
var copy = _s.Clone();
|
||
// Secrets and machine-bound values stay on this PC.
|
||
copy.ProtectedToken = null;
|
||
copy.Window = null;
|
||
var path = Path.Combine(folder, $"Chronos settings {DateTime.Now.ToString("yyyy-MM-dd", CultureInfo.InvariantCulture)}.json");
|
||
await Task.Run(() => AtomicFile.WriteAllText(path, copy.ToJson()));
|
||
Shell.Notify(Loc.L("Settings.Export.Done"), Path.GetFileName(path), Loc.L("Library.Export.Show"), Loc.L("Tooltips.Library.ShowExport"), () => ShellActions.Reveal(path));
|
||
}
|
||
|
||
private async Task ImportSettingsAsync()
|
||
{
|
||
var file = Shell.Services.Dialogs.PickJsonFile(Loc.L("Settings.Import.Title"));
|
||
if (file is null) return;
|
||
AppSettings? imported;
|
||
try
|
||
{
|
||
imported = AppSettings.Parse(await File.ReadAllTextAsync(file));
|
||
}
|
||
catch (Exception ex) when (ex is JsonException or IOException or UnauthorizedAccessException)
|
||
{
|
||
Log.Warning("settings", $"Settings file {file} not imported", ex);
|
||
imported = null;
|
||
}
|
||
if (imported is null)
|
||
{
|
||
Shell.Notify(Loc.L("Errors.Settings.Import"), isError: true);
|
||
return;
|
||
}
|
||
// Everything but the session, the window and its rail, the sequence edited last (another PC's ids mean nothing here)
|
||
// and the first-run flag.
|
||
imported.ProtectedToken = _s.ProtectedToken;
|
||
imported.ServerUrl = _s.ServerUrl;
|
||
imported.Window = _s.Window;
|
||
imported.RailCollapsed = _s.RailCollapsed;
|
||
imported.LastEditedSequence = _s.LastEditedSequence;
|
||
imported.FirstRunCompleted = _s.FirstRunCompleted;
|
||
ApplyAll(imported);
|
||
// Settings of a PC never rewrite the shared archive.json: the imported templates and sizes are the defaults of new
|
||
// archives, and the rows show the own settings of the archive at the (possibly imported) archive folder.
|
||
_retarget = RetargetArchiveAsync();
|
||
Shell.Notify(Loc.L("Settings.Import.Done"));
|
||
}
|
||
|
||
private void LoadCertificates()
|
||
{
|
||
Certificates.Clear();
|
||
foreach (var certificate in _s.TrustedCertificates.OrderByDescending(c => c.TrustedAt))
|
||
{
|
||
// The same question as on the Server screen; the session on that certificate is closed first.
|
||
Certificates.Add(new TrustedCertificateRow(certificate, new RelayCommand(() =>
|
||
{
|
||
if (Shell.Services.Server.ConfirmForget(certificate.Fingerprint, Shell.Services.Dialogs)) LoadCertificates();
|
||
})));
|
||
}
|
||
OnPropertyChanged(nameof(HasCertificates));
|
||
}
|
||
|
||
private void OnCultureChanged(object? sender, EventArgs e)
|
||
{
|
||
foreach (var page in AllPages) page.Refresh();
|
||
foreach (var row in Encoders) row.Refresh();
|
||
foreach (var row in JobPriorities) row.Refresh();
|
||
foreach (var row in Formats) row.Refresh();
|
||
foreach (var row in MissingExtensions) row.Refresh();
|
||
ArchiveRoot.Refresh();
|
||
FolderTemplate.Refresh();
|
||
FileTemplate.Refresh();
|
||
SessionGap.Refresh();
|
||
MinimumFrames.Refresh();
|
||
// Decimals are written in the language's own way ("6.25", "6,25").
|
||
if (!NightBrightness.IsDirty && !StarDensity.IsDirty) LoadAnalysisFields();
|
||
NightBrightness.Refresh();
|
||
StarDensity.Refresh();
|
||
Parallelism.Refresh();
|
||
CacheFolder.Refresh();
|
||
ThumbnailMemory.Refresh();
|
||
CacheLimit.Refresh();
|
||
DefaultServer.Refresh();
|
||
UpdateArchiveFree();
|
||
UpdatePreview();
|
||
LoadCertificates();
|
||
if (_backups.Count > 0) LoadBackups();
|
||
}
|
||
}
|