feat(app): library, jobs, settings, server, welcome and about screens

Local-mode composition root (SQLite index, one JobEngine fed by a single
handler registration list), keyset-paged library with thumbnail cache and
hover scrub, live job list with throttled updates and the shell job bar,
settings with live template validation and encoder self-test, server
connection with trust-on-first-use and DPAPI token, first-run welcome,
About with update check, and --capture screenshots with synthetic data.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
This commit is contained in:
Claude committed 2026-10-02 12:26:58 +00:00
1 parent 446daeae2b
commit ffbea7cb74
94 files changed
+10130 -374

No files matched your search

+231
View File
@@ -0,0 +1,231 @@
using System.Collections.Specialized;
using System.Windows.Input;
using Titano.App.Infrastructure;
using Titano.App.Server;
using Titano.App.Settings;
using Titano.App.Shell;
using Titano.Core.Diagnostics;
using Titano.Core.Localization;
using Titano.Ui.Mvvm;
namespace Titano.App.Sections;
/// <summary>Where the time-lapses live (first run).</summary>
public enum WelcomeChoice
{
LocalArchive,
AdoptFolder,
Server,
}
/// <summary>
/// First run (BRIEF §12.1, Welcome.html): create a local archive, adopt an existing folder or connect to a server,
/// plus the language and the anonymous-usage consent. Shown once; the archive actions go through
/// <see cref="IArchiveSetup"/>.
/// </summary>
public sealed class WelcomeViewModel : LocalizedViewModel
{
private readonly ShellViewModel _shell;
private WelcomeChoice _choice = WelcomeChoice.LocalArchive;
private string _localRoot;
private string? _adoptFolder;
private bool _isBusy;
public WelcomeViewModel(ShellViewModel shell)
{
_shell = shell;
_localRoot = shell.Services.Settings.LastArchivePath ?? ArchiveLocations.SuggestRoot();
ChooseCommand = new RelayCommand(p =>
{
if (p is WelcomeChoice choice) Choice = choice;
else if (p is string name && Enum.TryParse<WelcomeChoice>(name, out var parsed)) Choice = parsed;
});
ChangeRootCommand = new RelayCommand(ChangeRoot);
ChooseAdoptCommand = new RelayCommand(() => PickAdoptFolder());
ContinueCommand = new AsyncRelayCommand(ContinueAsync, () => !_isBusy);
shell.Services.Server.Discovered.CollectionChanged += OnDiscovered;
if (!shell.Services.Environment.IsCapture) shell.Services.Server.StartDiscovery();
}
public ICommand ChooseCommand { get; }
public ICommand ChangeRootCommand { get; }
public ICommand ChooseAdoptCommand { get; }
public ICommand ContinueCommand { get; }
public WelcomeChoice Choice
{
get => _choice;
set
{
if (!Set(ref _choice, value)) return;
OnPropertyChanged(nameof(IsLocal));
OnPropertyChanged(nameof(IsAdopt));
OnPropertyChanged(nameof(IsServer));
}
}
public bool IsLocal
{
get => _choice == WelcomeChoice.LocalArchive;
set
{
if (value) Choice = WelcomeChoice.LocalArchive;
}
}
public bool IsAdopt
{
get => _choice == WelcomeChoice.AdoptFolder;
set
{
if (value) Choice = WelcomeChoice.AdoptFolder;
}
}
public bool IsServer
{
get => _choice == WelcomeChoice.Server;
set
{
if (value) Choice = WelcomeChoice.Server;
}
}
public string LocalRoot
{
get => _localRoot;
private set
{
if (Set(ref _localRoot, value)) OnPropertyChanged(nameof(LocalDetail));
}
}
/// <summary>"D:\TitanoArchive · 1.8 TB free".</summary>
public string LocalDetail => ArchiveLocations.FreeSpace(_localRoot) is { } free
? Loc.L("Shell.Welcome.Local.Detail", _localRoot, Formatting.Bytes(free))
: _localRoot;
/// <summary>The chosen folder to adopt; null until picked.</summary>
public string? AdoptDetail => _adoptFolder;
public bool HasAdoptDetail => _adoptFolder is not null;
/// <summary>The first server announced on the LAN (or the saved one).</summary>
public DiscoveredServer? FoundServer =>
_shell.Services.Server.Discovered.FirstOrDefault()
?? (_shell.Services.Settings.ServerUrl is { } saved ? new DiscoveredServer(saved, saved) : null);
/// <summary>"Studio NAS on this network · https://nas.local:8443".</summary>
public string? ServerDetail => FoundServer is { } s
? s.Name == s.Address ? s.Address : Loc.L("Shell.Welcome.Server.Found", s.Name, s.Address)
: null;
public bool HasServerDetail => ServerDetail is not null;
/// <summary>A server was heard on the LAN (the green dot).</summary>
public bool IsServerDiscovered => _shell.Services.Server.Discovered.Count > 0;
public IReadOnlyList<LanguageOption> Languages => LanguageCatalog.Available;
public LanguageOption SelectedLanguage
{
get => LanguageCatalog.Match(Loc.Culture);
set
{
if (value is null || value == SelectedLanguage) return;
_shell.Services.Settings.Language = value.Code;
UiLanguage.Apply(value.Code);
_shell.Services.SaveSettings();
}
}
public bool UsageCounts
{
get => _shell.Services.Settings.AnonymousUsageCounts;
set
{
_shell.Services.Settings.AnonymousUsageCounts = value;
OnPropertyChanged();
}
}
public bool IsBusy
{
get => _isBusy;
private set => Set(ref _isBusy, value);
}
/// <summary>Sample state for screenshots: a server heard on the LAN.</summary>
internal void ShowDiscovered(DiscoveredServer server)
{
if (!_shell.Services.Server.Discovered.Contains(server)) _shell.Services.Server.Discovered.Add(server);
}
public override void Dispose()
{
_shell.Services.Server.Discovered.CollectionChanged -= OnDiscovered;
base.Dispose();
}
private void OnDiscovered(object? sender, NotifyCollectionChangedEventArgs e)
{
OnPropertyChanged(nameof(FoundServer));
OnPropertyChanged(nameof(ServerDetail));
OnPropertyChanged(nameof(HasServerDetail));
OnPropertyChanged(nameof(IsServerDiscovered));
}
private void ChangeRoot()
{
var folder = _shell.Services.Dialogs.PickFolder(Loc.L("Shell.Welcome.Local.PickTitle"), LocalRoot);
if (folder is null) return;
LocalRoot = folder;
Choice = WelcomeChoice.LocalArchive;
}
private bool PickAdoptFolder()
{
var folder = _shell.Services.Dialogs.PickFolder(Loc.L("Library.Adopt.Title"));
if (folder is null) return false;
_adoptFolder = folder;
OnPropertyChanged(nameof(AdoptDetail));
OnPropertyChanged(nameof(HasAdoptDetail));
Choice = WelcomeChoice.AdoptFolder;
return true;
}
private async Task ContinueAsync()
{
IsBusy = true;
try
{
switch (_choice)
{
case WelcomeChoice.LocalArchive:
if (ArchiveLocations.Validate(LocalRoot) is { } problem)
{
_shell.Notify(problem);
return;
}
await _shell.Services.ArchiveSetup.CreateAsync(LocalRoot);
break;
case WelcomeChoice.AdoptFolder:
if (_adoptFolder is null && !PickAdoptFolder()) return;
await _shell.Services.ArchiveSetup.AdoptAsync(_adoptFolder!);
break;
case WelcomeChoice.Server:
if (FoundServer is { } server) _shell.Server.Address = server.Address;
break;
}
_shell.Services.SaveSettings();
_shell.CompleteWelcome();
Log.Info("app", $"First run completed: {_choice}");
if (_choice == WelcomeChoice.Server) _shell.Navigate(SectionKey.Server);
else await _shell.Library.RefreshAsync();
}
finally
{
IsBusy = false;
}
}
}