using System.Collections.ObjectModel;
using System.Windows.Input;
using System.Windows.Shell;
using Titano.App.Infrastructure;
using Titano.App.Sections;
using Titano.Core.Diagnostics;
using Titano.Core.Localization;
using Titano.Ui.Controls;
using Titano.Ui.Mvvm;
namespace Titano.App.Shell;
/// State of the main window: rail, current section, job bar, status strip and first run (BRIEF §12.1).
public sealed class ShellViewModel : LocalizedViewModel
{
private readonly AppSettings _settings;
private SectionViewModel _current;
private bool _isRailCollapsed;
private string? _jobText;
private string? _jobName;
private double _jobProgress;
private bool _jobActive;
private bool _jobIndeterminate;
private long _sequenceCount;
private long _photoCount;
private long _totalBytes;
private string? _serverName;
private int _jobCount;
private int _queuedCount;
private int _unseenFailures;
private WelcomeViewModel? _welcome;
private Guid? _currentSequenceId;
private int _sequenceRequests;
public ShellViewModel(AppServices services)
{
Services = services;
_settings = services.Settings;
_isRailCollapsed = _settings.RailCollapsed;
Library = new LibraryViewModel(this);
Import = new ImportViewModel(this);
Sequence = new SequenceViewModel(this);
Archive = new ArchiveViewModel(this);
Jobs = new JobsViewModel(this);
Server = new ServerViewModel(this);
Settings = new SettingsViewModel(this);
About = new AboutViewModel(this);
TopSections = [Library, Import, Sequence, Archive, Jobs, Server];
BottomSections = [Settings, About];
foreach (var section in AllSections) section.InCollapsedRail = _isRailCollapsed;
_current = Library;
Library.IsSelected = true;
Library.PropertyChanged += OnCurrentChanged;
// The rail and its shortcuts (Ctrl+1…6, Ctrl+,) navigate only while no first-run dialog covers the shell.
NavigateCommand = new RelayCommand(p =>
{
if (p is SectionViewModel s) Navigate(s.Key);
else if (p is SectionKey k) Navigate(k);
else if (p is string name && Enum.TryParse(name, out var key)) Navigate(key);
}, _ => IsShellEnabled);
// Like the shortcuts above, Ctrl+B leaves the shell behind the first-run dialog alone.
ToggleRailCommand = new RelayCommand(() => IsRailCollapsed = !IsRailCollapsed, () => IsShellEnabled);
services.Server.PropertyChanged += (_, _) => SetConnection(services.Server.ServerName);
if (!_settings.FirstRunCompleted) _welcome = new WelcomeViewModel(this);
}
public AppServices Services { get; }
public LibraryViewModel Library { get; }
public ImportViewModel Import { get; }
public SequenceViewModel Sequence { get; }
public ArchiveViewModel Archive { get; }
public JobsViewModel Jobs { get; }
public ServerViewModel Server { get; }
public SettingsViewModel Settings { get; }
public AboutViewModel About { get; }
public IReadOnlyList TopSections { get; }
public IReadOnlyList BottomSections { get; }
public IEnumerable AllSections => TopSections.Concat(BottomSections);
public ICommand NavigateCommand { get; }
public ICommand ToggleRailCommand { get; }
/// In-window notifications; the window binds its here.
public ObservableCollection PendingToasts { get; } = [];
/// First-run choice (Welcome.html); null once made.
public WelcomeViewModel? Welcome
{
get => _welcome;
private set
{
if (!Set(ref _welcome, value)) return;
OnPropertyChanged(nameof(IsWelcomeOpen));
OnPropertyChanged(nameof(IsShellEnabled));
CommandManager.InvalidateRequerySuggested();
}
}
public bool IsWelcomeOpen => _welcome is not null;
/// The rail and the sections take input only while no first-run dialog covers them.
public bool IsShellEnabled => _welcome is null;
public SectionViewModel Current
{
get => _current;
private set
{
var previous = _current;
if (!Set(ref _current, value)) return;
previous.PropertyChanged -= OnCurrentChanged;
value.PropertyChanged += OnCurrentChanged;
OnPropertyChanged(nameof(WindowTitle));
OnPropertyChanged(nameof(IsJobBarVisible));
}
}
public string WindowTitle => Current == Library ? Loc.L("Shell.AppName") : Loc.L("Shell.WindowTitle", Loc.L("Shell.AppName"), Current.Title);
/// The rail shows icons alone (≡ or Ctrl+B); kept at once in the settings (owner review 1).
public bool IsRailCollapsed
{
get => _isRailCollapsed;
set
{
if (!Set(ref _isRailCollapsed, value)) return;
_settings.RailCollapsed = value;
foreach (var section in AllSections) section.InCollapsedRail = value;
Services.SavePreferences();
OnPropertyChanged(nameof(RailToggleToolTip));
OnPropertyChanged(nameof(RailToggleName));
}
}
public string RailToggleToolTip => Loc.L(IsRailCollapsed ? "Tooltips.Shell.ExpandRail" : "Tooltips.Shell.CollapseRail");
/// The rail button's accessible name: two words, the sentence is its tooltip.
public string RailToggleName => Loc.L(IsRailCollapsed ? "Shell.Nav.Expand" : "Shell.Nav.Collapse");
/// The sequence the editor opens (set by the Library and the Jobs screen).
public Guid? CurrentSequenceId
{
get => _currentSequenceId;
private set => Set(ref _currentSequenceId, value);
}
///
/// Counts calls: asking for the open sequence again (the Library, Jobs, a project file) ends a
/// choice of another in Edit, while coming back to Edit alone does not (owner review 1, R7).
///
public int SequenceRequests
{
get => _sequenceRequests;
private set => Set(ref _sequenceRequests, value);
}
/// Loads the data of every screen once the index is open (or failed to open).
public async Task StartAsync()
{
if (Services.OpenError is { } error) ReportError(error);
Jobs.Attach();
await Library.AttachAsync();
// Edit opened before the index did shows its picker empty until now (neither "no sequences" nor Import).
if (Sequence.ShowsPicker && Sequence.IsSelected) _ = Sequence.Picker.ReloadAsync();
Settings.Attach();
About.Attach();
await Server.AttachAsync();
}
/// Opens a sequence in Edit.
public void OpenSequence(Guid sequenceId)
{
CurrentSequenceId = sequenceId;
SequenceRequests++;
Navigate(SectionKey.Edit);
}
///
/// Edit's open sequence (or none) is again the sequence asked for: after Keep editing, a choice cancelled, an open that
/// failed, or the sequence asked for deleted. Coming back to Edit then neither asks once more nor tries again; asking
/// for a sequence again () does.
///
internal void KeepSequence(Guid? sequenceId) => CurrentSequenceId = sequenceId;
/// Closes the first-run overlay for good.
public void CompleteWelcome()
{
_settings.FirstRunCompleted = true;
Services.SaveSettings();
Welcome?.Dispose();
Welcome = null;
}
/// Shows the first-run overlay again (capture, tests).
public void ShowWelcome() => Welcome ??= new WelcomeViewModel(this);
// ---- Job bar ----
public string JobText => _jobActive && _jobText is not null
? _jobText
: _queuedCount > 0 ? Loc.Plural("Shell.JobBar.Ready", _queuedCount) : Loc.L("Shell.JobBar.Idle");
public double JobProgress { get => _jobProgress; private set => Set(ref _jobProgress, value); }
public bool IsJobActive
{
get => _jobActive;
private set
{
if (Set(ref _jobActive, value)) OnPropertyChanged(nameof(IsJobBarVisible));
}
}
/// The job bar shows "Ready" when idle, except in the editor where it gives its 40 px to the preview (DESIGN §4).
public bool IsJobBarVisible => _jobActive || _current != Sequence;
public bool IsJobIndeterminate { get => _jobIndeterminate; private set => Set(ref _jobIndeterminate, value); }
/// Pauses the job the bar shows.
public ICommand? StopJobCommand => Jobs.PauseCurrentCommand;
///
/// What screen readers hear from the job bar: the job when one starts, the idle line when the last one ends; not its
/// progress, speed or time left, which change every second.
///
public string JobAnnouncement => _jobActive && _jobName is not null ? _jobName : JobText;
///
/// The taskbar button mirrors the job bar (BRIEF §11.5): the running job's progress, sliding while its total is
/// unknown; red while no job runs and a failure waits on the Jobs screen; nothing otherwise.
///
public TaskbarItemProgressState TaskbarState =>
_jobActive ? _jobIndeterminate ? TaskbarItemProgressState.Indeterminate : TaskbarItemProgressState.Normal
: _unseenFailures > 0 ? TaskbarItemProgressState.Error
: TaskbarItemProgressState.None;
/// 0…1 for ; a waiting failure fills the button.
public double TaskbarProgress => _jobActive ? _jobProgress : _unseenFailures > 0 ? 1 : 0;
///
/// Updates the global job bar and the taskbar button. says which job it is without its
/// progress ("Render: Harbour sunset"); null reads .
///
public void SetJob(string? text, double progress, bool indeterminate = false, string? name = null)
{
_jobText = text;
_jobName = text is null ? null : name ?? text;
IsJobActive = text is not null;
JobProgress = progress;
IsJobIndeterminate = indeterminate;
OnPropertyChanged(nameof(JobText));
OnPropertyChanged(nameof(JobAnnouncement));
OnPropertyChanged(nameof(TaskbarState));
OnPropertyChanged(nameof(TaskbarProgress));
}
/// Failed jobs not seen on the Jobs screen yet (the taskbar button turns red while no job runs).
public void SetUnseenFailures(int count)
{
if (_unseenFailures == count) return;
_unseenFailures = count;
OnPropertyChanged(nameof(TaskbarState));
OnPropertyChanged(nameof(TaskbarProgress));
}
// ---- Status strip ----
public string SequencesText => Loc.Plural("Shell.Status.Sequences", _sequenceCount);
public string PhotosText => Loc.Plural("Shell.Status.Photos", _photoCount);
public string StorageText => _sequenceCount == 0 && _settings.LastArchivePath is null ? Loc.L("Shell.Status.NoArchive") : Formatting.Bytes(_totalBytes);
public string ConnectionText => _serverName is null ? Loc.L("Shell.Status.NotConnected") : Loc.L("Shell.Status.Connected", _serverName);
public bool IsConnected => _serverName is not null;
public string JobsText => Loc.Plural("Shell.Status.Jobs", _jobCount);
public void SetLibraryTotals(long sequences, long photos, long bytes)
{
_sequenceCount = sequences;
_photoCount = photos;
_totalBytes = bytes;
OnPropertyChanged(nameof(SequencesText));
OnPropertyChanged(nameof(PhotosText));
OnPropertyChanged(nameof(StorageText));
}
public void SetConnection(string? serverName)
{
if (_serverName == serverName) return;
_serverName = serverName;
OnPropertyChanged(nameof(ConnectionText));
OnPropertyChanged(nameof(IsConnected));
}
/// Active jobs (running + queued) for the status strip, queued ones for the idle job bar.
public void SetJobCount(int active, int queued = 0)
{
_jobCount = active;
_queuedCount = queued;
OnPropertyChanged(nameof(JobsText));
OnPropertyChanged(nameof(JobText));
OnPropertyChanged(nameof(JobAnnouncement));
}
public void Navigate(SectionKey key)
{
var target = AllSections.First(s => s.Key == key);
foreach (var s in AllSections) s.IsSelected = ReferenceEquals(s, target);
Current = target;
}
public void ShowToast(Toast toast) => PendingToasts.Add(toast);
/// The section on screen renamed itself (the editor opened a sequence): the window title follows.
private void OnCurrentChanged(object? sender, System.ComponentModel.PropertyChangedEventArgs e)
{
if (e.PropertyName is nameof(SectionViewModel.Title) or "" or null) OnPropertyChanged(nameof(WindowTitle));
}
///
/// A one-line notice with one action (job done, update available). marks something that
/// did not happen or failed: screen readers then say it at once instead of after what they are reading.
/// : a click on its Windows notification also runs the action ().
///
public void Notify(string title, string? message = null, string? actionText = null, string? actionToolTip = null, Action? action = null, bool isError = false,
bool runsFromNotification = false) =>
ShowToast(new Toast
{
Title = title,
Message = message,
ActionText = actionText,
ActionToolTip = actionToolTip,
ActionCommand = action is null ? null : new RelayCommand(action),
IsError = isError,
RunsFromNotification = runsFromNotification,
});
/// Errors are one sentence saying what happened plus one action (BRIEF §0.2 rule 6); the details go to the log.
public void ReportError(Exception ex)
{
Log.Error("ui", "Operation failed", ex);
ShowToast(new Toast
{
Title = ErrorText.For(ex),
IsError = true,
ActionText = Loc.L("Common.OpenLogs"),
ActionToolTip = Loc.L("Tooltips.Common.OpenLogs"),
ActionCommand = new RelayCommand(() => ShellActions.Reveal(Services.Environment.LogDirectory)),
});
}
public override void Dispose()
{
// The editor first: it stops its runners and closes its source before the engine and the index under it go.
Sequence.Dispose();
Jobs.Dispose();
Library.Dispose();
Import.Dispose();
Archive.Dispose();
Server.Dispose();
Settings.Dispose();
About.Dispose();
Welcome?.Dispose();
base.Dispose();
}
}