diff --git a/src/Titano.Uploader/App.xaml b/src/Titano.Uploader/App.xaml index 6e70f617..ec3359f9 100644 --- a/src/Titano.Uploader/App.xaml +++ b/src/Titano.Uploader/App.xaml @@ -1,4 +1,5 @@ + xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" + ShutdownMode="OnExplicitShutdown"> diff --git a/src/Titano.Uploader/App.xaml.cs b/src/Titano.Uploader/App.xaml.cs index 67a0cc99..8fe2c3da 100644 --- a/src/Titano.Uploader/App.xaml.cs +++ b/src/Titano.Uploader/App.xaml.cs @@ -1,7 +1,345 @@ +using System.ComponentModel; +using System.Globalization; +using System.IO; using System.Windows; +using System.Windows.Threading; +using Titano.Core.Diagnostics; +using Titano.Core.Localization; +using Titano.Ui.Mvvm; +using Titano.Ui.Theming; +using Titano.Uploader.DesignTime; +using Titano.Uploader.Infrastructure; +using Titano.Uploader.Interop; +using Titano.Uploader.Server; +using Titano.Uploader.Shell; +using Titano.Uploader.Uploads; +using Titano.Uploader.Watching; namespace Titano.Uploader; +/// +/// Titano Uploader (BRIEF §15): one instance per session, logging, language and theme, the persisted queue, the +/// server session, watch folders and the tray icon. --capture <dir> renders screenshots and exits. +/// public partial class App : Application { + private const int TrayShow = 1; + private const int TrayPause = 2; + private const int TrayExit = 3; + + private readonly CoalescingWriter _writer = new(); + private FileLogSink? _log; + private SingleInstance? _instance; + private UploaderEnvironment? _environment; + private UploaderSettings? _settings; + private UploadQueue? _queue; + private ProcessedFileMemory? _memory; + private ServerSession? _session; + private UploadEngine? _engine; + private WatchFolderService? _watch; + private DiscoveryListener? _discovery; + private MainViewModel? _vm; + private Shell.MainWindow? _window; + private TrayIcon? _tray; + private DispatcherTimer? _persist; + private bool _queueDirty; + private bool _exiting; + + protected override void OnStartup(StartupEventArgs e) + { + base.OnStartup(e); + var command = CommandLine.Parse(e.Args); + _environment = UploaderEnvironment.Detect(); + _log = new FileLogSink(_environment.LogDirectory, "uploader"); + Log.SetSink(_log); + Log.Info("app", $"Titano Uploader {typeof(App).Assembly.GetName().Version} starting; data at {_environment.DataDirectory}"); + HookUnhandledExceptions(); + + if (command.CaptureDirectory is { } captureDirectory) + { + RunCapture(captureDirectory); + return; + } + + _instance = SingleInstance.TryAcquire(); + if (_instance is null) + { + SingleInstance.TrySend([.. command.Paths.Select(Absolute).OfType()]); + Log.Info("app", "Another uploader runs in this session; arguments handed over"); + Shutdown(); + return; + } + + _settings = UploaderSettings.Load(_environment.SettingsPath); + ApplyLanguage(_settings.Language); + ThemeManager.Initialize(this, _settings.Theme); + BuildServices(_environment, _settings); + + _instance.Listen(args => Dispatcher.BeginInvoke(() => OnHandOver(args))); + _session!.Start(); + _engine!.Start(); + _vm!.Start(); + _vm.StartWatching(); + UpdateTray(); + UpdateDiscovery(); + if (command.Paths.Count > 0) _ = _vm.EnqueueAsync(command.Paths); + + if (command.StartInTray && _settings.MinimizeToTray) return; + if (command.StartInTray) _window!.WindowState = WindowState.Minimized; + _window!.Show(); + } + + protected override void OnExit(ExitEventArgs e) + { + _persist?.Stop(); + _vm?.Dispose(); + // Cancels transfers; interrupted items are written as queued and resume from the server's chunks. + _engine?.Dispose(); + if (_queue is not null && _environment is not null) + { + Persist(); + _writer.Flush(TimeSpan.FromSeconds(10)); + } + if (_window is not null && _settings is not null) _window.SavePlacement(); + SaveSettings(); + _watch?.Dispose(); + _discovery?.Dispose(); + _session?.Dispose(); + _tray?.Dispose(); + _instance?.Dispose(); + Log.Info("app", "Titano Uploader exiting"); + _log?.Dispose(); + base.OnExit(e); + } + + private void BuildServices(UploaderEnvironment environment, UploaderSettings settings) + { + _queue = new UploadQueue(); + QueueStore.Load(environment.QueuePath, _queue); + _memory = ProcessedFileMemory.Load(environment.WatchMemoryPath); + _session = new ServerSession(settings, SaveSettings); + _engine = new UploadEngine(_queue, _session, () => settings.DeleteAfterUpload); + _watch = new WatchFolderService(_memory, _queue.ContainsPath); + var startup = new RunKeyStartupRegistration(); + startup.Refresh(); + var dialogs = new UploaderDialogs(); + _vm = new MainViewModel(new UploaderServices(settings, SaveSettings, _session, _queue, _engine, startup, dialogs, _watch, _memory, environment.LogDirectory)); + _window = new Shell.MainWindow(_vm, settings); + dialogs.Owner = _window; + MainWindow = _window; + + AsyncRelayCommand.Failed += _vm.ReportError; + _engine.ItemConfirmed += (_, item) => + { + if (item.WatchRoot is { } root) _memory.Add(root, item.Path, item.Size, item.ModifiedUtc); + }; + _watch.FilesReady += _vm.OnWatchFilesReady; + _watch.AvailabilityChanged += _vm.OnWatchAvailabilityChanged; + _queue.Changed += (_, _) => _queueDirty = true; + _vm.UploadsCompleted += OnUploadsCompleted; + _vm.PropertyChanged += OnViewModelChanged; + _window.Closing += OnWindowClosing; + _window.Closed += (_, _) => ExitApplication(); + _window.StateChanged += OnWindowStateChanged; + _persist = new DispatcherTimer(DispatcherPriority.Background) { Interval = TimeSpan.FromSeconds(2) }; + _persist.Tick += (_, _) => Persist(); + _persist.Start(); + } + + /// Switches the UI language (BRIEF §16); an unknown code falls back to the OS language. + private static void ApplyLanguage(string? code) + { + CultureInfo requested; + try + { + requested = code is null ? CultureInfo.CurrentUICulture : CultureInfo.GetCultureInfo(code); + } + catch (CultureNotFoundException) + { + requested = CultureInfo.CurrentUICulture; + } + var culture = Languages.BestMatch(requested); + CultureInfo.DefaultThreadCurrentUICulture = culture; + CultureInfo.CurrentUICulture = culture; + Loc.SetCulture(culture); + } + + /// Writes the queue and the watch memory when they changed (every 2 s and at exit). + private void Persist() + { + if (_queue is null || _memory is null || _environment is null) return; + if (_queueDirty) + { + _queueDirty = false; + _writer.Write(_environment.QueuePath, QueueStore.Serialize(_queue)); + } + if (_memory.IsDirty) _writer.Write(_environment.WatchMemoryPath, _memory.Serialize()); + } + + private void SaveSettings() + { + if (_settings is null || _environment is null) return; + try + { + _settings.Save(_environment.SettingsPath); + } + catch (Exception ex) when (ex is IOException or UnauthorizedAccessException) + { + Log.Warning("app", "Settings not saved", ex); + } + } + + private void OnHandOver(IReadOnlyList paths) + { + ShowWindow(); + if (paths.Count > 0) _ = _vm!.EnqueueAsync(paths); + } + + private void OnViewModelChanged(object? sender, PropertyChangedEventArgs e) + { + switch (e.PropertyName) + { + case nameof(MainViewModel.MinimizeToTray): + UpdateTray(); + break; + case nameof(MainViewModel.IsConnectVisible): + UpdateDiscovery(); + break; + case nameof(MainViewModel.TrayText): + _tray?.SetToolTip(_vm!.TrayText); + break; + } + } + + /// The tray icon exists while "Minimise to tray" is on. + private void UpdateTray() + { + if (_settings!.MinimizeToTray && _tray is null) + { + _tray = new TrayIcon(_vm!.TrayText, TrayMenu, OnTrayCommand, ShowWindow); + } + else if (!_settings.MinimizeToTray && _tray is not null) + { + _tray.Dispose(); + _tray = null; + if (_window is { IsVisible: false }) ShowWindow(); + } + } + + private IReadOnlyList TrayMenu() => + [ + new(TrayShow, Loc.L("Uploader.Tray.Show")), + new(TrayPause, _vm!.PauseLabel), + new(0, null), + new(TrayExit, Loc.L("Uploader.Tray.Exit")), + ]; + + private void OnTrayCommand(int id) + { + switch (id) + { + case TrayShow: + ShowWindow(); + break; + case TrayPause: + _vm!.TogglePause(); + break; + case TrayExit: + ExitApplication(); + break; + } + } + + /// Listens for server beacons only while the sign-in form is shown. + private void UpdateDiscovery() + { + if (_vm!.IsConnectVisible) + { + if (_discovery is not null) return; + _discovery = new DiscoveryListener(); + _discovery.Found += _vm.Connect.AddDiscovered; + _discovery.Start(); + } + else if (_discovery is not null) + { + _discovery.Dispose(); + _discovery = null; + } + } + + private void OnUploadsCompleted(int count) + { + if (_window is { IsVisible: true, WindowState: not WindowState.Minimized }) return; + _tray?.ShowBalloon(Loc.L("Uploader.Tray.Done.Title"), Loc.Plural("Uploader.Tray.Done.Message", count)); + } + + /// Closing keeps the uploader running in the tray when "Minimise to tray" is on. + private void OnWindowClosing(object? sender, CancelEventArgs e) + { + if (_exiting || !_settings!.MinimizeToTray) return; + e.Cancel = true; + _window!.SavePlacement(); + _window.Hide(); + } + + private void OnWindowStateChanged(object? sender, EventArgs e) + { + if (_window is { WindowState: WindowState.Minimized } && _settings!.MinimizeToTray) _window.Hide(); + } + + private void ShowWindow() + { + if (_window is null) return; + _window.Show(); + if (_window.WindowState == WindowState.Minimized) _window.WindowState = WindowState.Normal; + _window.Activate(); + } + + private void ExitApplication() + { + if (_exiting) return; + _exiting = true; + Shutdown(); + } + + private void RunCapture(string directory) + { + ApplyLanguage(null); + ThemeManager.Initialize(this, AppTheme.Dark); + var sample = new SampleData(); + var vm = sample.CreateViewModel(); + var window = new Shell.MainWindow(vm, sample.Settings); + MainWindow = window; + ScreenCapture.Run(window, vm, sample, directory); + } + + private void HookUnhandledExceptions() + { + DispatcherUnhandledException += (_, e) => + { + Log.Error("app", "Unhandled UI exception", e.Exception); + if (_vm is null) return; + _vm.ReportError(e.Exception); + e.Handled = true; + }; + AppDomain.CurrentDomain.UnhandledException += (_, e) => Log.Error("app", "Unhandled exception", e.ExceptionObject as Exception); + TaskScheduler.UnobservedTaskException += (_, e) => + { + Log.Error("app", "Unobserved task exception", e.Exception); + e.SetObserved(); + }; + } + + /// Paths handed to the running instance must not depend on this process's working directory. + private static string? Absolute(string path) + { + try + { + return Path.GetFullPath(path); + } + catch (Exception ex) when (ex is ArgumentException or NotSupportedException or PathTooLongException) + { + return null; + } + } } diff --git a/src/Titano.Uploader/DesignTime/SampleData.cs b/src/Titano.Uploader/DesignTime/SampleData.cs new file mode 100644 index 00000000..62dc5a99 --- /dev/null +++ b/src/Titano.Uploader/DesignTime/SampleData.cs @@ -0,0 +1,171 @@ +using System.ComponentModel; +using System.Globalization; +using System.Runtime.CompilerServices; +using Titano.Protocol; +using Titano.Uploader.Infrastructure; +using Titano.Uploader.Server; +using Titano.Uploader.Shell; +using Titano.Uploader.Uploads; +using Titano.Uploader.Watching; + +namespace Titano.Uploader.DesignTime; + +/// +/// Sample content for --capture screenshots ONLY: a fake signed-in session, a running queue of 4,812 files +/// and two watch folders. Nothing here touches the network, the registry or the user's data files. +/// +public sealed class SampleData +{ + private const int FileCount = 4_812; + private const long FileSize = 20_000_000; + + private readonly SampleSession _session = new(); + private readonly UploadQueue _queue = new(); + private MainViewModel? _vm; + + public UploaderSettings Settings { get; } = new() + { + ServerUrl = "https://nas.local:8443/", + Username = "alberto", + BandwidthLimit = 50, + MinimizeToTray = true, + WatchFolders = + [ + new UploaderSettings.WatchFolderSettings { Path = @"D:\Cam\Roof", IntervalSeconds = 60 }, + new UploaderSettings.WatchFolderSettings { Path = @"\\garage-pi\cam", IntervalSeconds = 300 }, + ], + }; + + /// A view model over in-memory sample services; settings changes are discarded. + public MainViewModel CreateViewModel() + { + var memory = new ProcessedFileMemory(); + _session.BandwidthLimit = Settings.BandwidthLimit; + _vm = new MainViewModel(new UploaderServices( + Settings, () => { }, _session, _queue, new SampleEngine(_queue), new SampleStartup(), new UploaderDialogs(), + new WatchFolderService(memory, _queue.ContainsPath), memory, string.Empty)); + foreach (var w in _vm.WatchFolders) w.IsAvailable = true; + return _vm; + } + + /// First run: no server yet, one server found on the LAN. + public void ShowConnect() + { + _session.SetState(ConnectionState.NotConfigured); + _vm!.Connect.Address = string.Empty; + _vm.Connect.Username = string.Empty; + _vm.Connect.Discovered.Clear(); + _vm.Connect.Discovered.Add(new DiscoveredServer("Studio NAS", "https://192.168.1.20:8443")); + } + + /// Signed in, a card being uploaded at 38 MB/s. + public void ShowQueue() + { + _session.SetState(ConnectionState.Connected); + if (_queue.Items.Count == 0) FillQueue(); + _vm!.Sequences.Clear(); + _vm.Sequences.Add(new SequenceOption(Guid.Empty, "Harbour sunset")); + _vm.SelectedSequence = _vm.Sequences[0]; + _vm.RefreshQueue(); + } + + private void FillQueue() + { + var batch = new UploadBatch { Id = Guid.CreateVersion7(), Mode = UploadTargetMode.Sessions }; + var start = new DateTime(2026, 9, 28, 15, 22, 0); + _queue.Add(batch, Enumerable.Range(0, FileCount).Select(i => + { + var shot = start.AddSeconds(i * 5); + var name = shot.ToString("yyyy-MM-dd_HH-mm-ss", CultureInfo.InvariantCulture) + "_" + (i + 1).ToString("0000", CultureInfo.InvariantCulture) + ".CR2"; + return new QueueEntry(@"E:\DCIM\100CANON\" + name, FileSize, shot.ToUniversalTime(), shot, "1a2b3c4d-20260928-152200", null); + })); + for (var i = 0; i < 2_201; i++) _queue.Items[i].State = i % 200 == 7 ? UploadItemState.Skipped : UploadItemState.Verified; + _queue.Items[1_640].Retries = 1; + _queue.Items[2_201].State = UploadItemState.Uploading; + _queue.Items[2_201].BytesSent = FileSize * 46 / 100; + _queue.Items[2_202].State = UploadItemState.Hashing; + _queue.Fail(_queue.Items[2_203], UploadFailure.FileUnreadable, null, DateTime.UtcNow); + } + + private sealed class SampleSession : IServerSession + { + private ConnectionState _state = ConnectionState.Connected; + + public event PropertyChangedEventHandler? PropertyChanged; + + public event EventHandler? SessionEnded + { + add { } + remove { } + } + + public ConnectionState State => _state; + public string? Address => "https://nas.local:8443/"; + public string? Username => "alberto"; + public long QuotaBytes => 5_000_000_000_000; + public long UsedBytes => 3_100_000_000_000; + public int BandwidthLimit { get; set; } + + public void SetState(ConnectionState state) + { + _state = state; + Raise(nameof(State)); + } + + public Task<(SignInResult Result, string? Fingerprint)> SignInAsync(string address, string username, string password, CancellationToken ct) => + Task.FromResult<(SignInResult, string?)>((SignInResult.Failed, null)); + + public void Trust(string fingerprint) + { + } + + public Task SignOutAsync() => Task.CompletedTask; + + public Task RefreshAsync() => Task.CompletedTask; + + public Task> ListSequencesAsync(CancellationToken ct) => Task.FromResult>([]); + + private void Raise([CallerMemberName] string? name = null) => PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(name)); + } + + private sealed class SampleEngine(UploadQueue queue) : IUploadEngine + { + public event PropertyChangedEventHandler? PropertyChanged + { + add { } + remove { } + } + + public event EventHandler? Drained + { + add { } + remove { } + } + + public EngineStatus Status => queue.IsPaused ? EngineStatus.Paused : EngineStatus.Running; + public double BytesPerSecond => 38_000_000; + + public void Pump() + { + } + + public void Pause() => queue.IsPaused = true; + + public void Resume() => queue.IsPaused = false; + + public void StopAndClear() + { + } + + public void Retry(UploadItem item) + { + } + } + + private sealed class SampleStartup : IStartupRegistration + { + public bool IsEnabled { get; private set; } = true; + + public void SetEnabled(bool enabled) => IsEnabled = enabled; + } +} diff --git a/src/Titano.Uploader/Interop/FileDialogs.cs b/src/Titano.Uploader/Interop/FileDialogs.cs new file mode 100644 index 00000000..39160398 --- /dev/null +++ b/src/Titano.Uploader/Interop/FileDialogs.cs @@ -0,0 +1,187 @@ +using System.Runtime.InteropServices; + +namespace Titano.Uploader.Interop; + +/// A filter of the Open dialog: display name and patterns such as *.jpg;*.cr2. +public readonly record struct FileFilter(string Name, string Patterns); + +/// +/// The shell's Open dialog through IFileOpenDialog COM (no WinForms): several files at once, or one folder +/// (which also picks a card root such as E:\). +/// +public static class FileDialogs +{ + private const uint FosPickFolders = 0x20; + private const uint FosForceFileSystem = 0x40; + private const uint FosAllowMultiSelect = 0x200; + private const uint FosPathMustExist = 0x800; + private const uint FosFileMustExist = 0x1000; + private const uint SigdnFileSysPath = 0x80058000; + private const int ErrorCancelled = unchecked((int)0x800704C7); + + /// Selected files; empty when cancelled. + public static IReadOnlyList PickFiles(IntPtr owner, string title, IReadOnlyList filters) => + Show(owner, title, FosAllowMultiSelect | FosFileMustExist, filters); + + /// Selected folder; null when cancelled. + public static string? PickFolder(IntPtr owner, string title) => Show(owner, title, FosPickFolders, []).FirstOrDefault(); + + private static List Show(IntPtr owner, string title, uint options, IReadOnlyList filters) + { + var dialog = (IFileOpenDialog)new FileOpenDialogClass(); + try + { + dialog.GetOptions(out var current); + dialog.SetOptions(current | options | FosForceFileSystem | FosPathMustExist); + dialog.SetTitle(title); + if (filters.Count > 0) + { + var specs = filters.Select(f => new FilterSpec { Name = f.Name, Spec = f.Patterns }).ToArray(); + dialog.SetFileTypes((uint)specs.Length, specs); + dialog.SetFileTypeIndex(1); + } + var hr = dialog.Show(owner); + if (hr == ErrorCancelled) return []; + Marshal.ThrowExceptionForHR(hr); + + dialog.GetResults(out var items); + try + { + items.GetCount(out var count); + var paths = new List((int)count); + for (uint i = 0; i < count; i++) + { + items.GetItemAt(i, out var item); + try + { + item.GetDisplayName(SigdnFileSysPath, out var path); + paths.Add(path); + } + finally + { + Marshal.ReleaseComObject(item); + } + } + return paths; + } + finally + { + Marshal.ReleaseComObject(items); + } + } + finally + { + Marshal.ReleaseComObject(dialog); + } + } + + [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)] + private struct FilterSpec + { + [MarshalAs(UnmanagedType.LPWStr)] + public string Name; + + [MarshalAs(UnmanagedType.LPWStr)] + public string Spec; + } + + [ComImport] + [Guid("DC1C5A9C-E88A-4dde-A5A1-60F82A20AEF7")] + private class FileOpenDialogClass; + + // Classic COM interop does not inherit vtables: IModalWindow and IFileDialog members are repeated in order. + [ComImport] + [Guid("d57c7288-d4ad-4768-be02-9d969532d960")] + [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + private interface IFileOpenDialog + { + [PreserveSig] + int Show(IntPtr owner); + + void SetFileTypes(uint count, [In, MarshalAs(UnmanagedType.LPArray)] FilterSpec[] filters); + + void SetFileTypeIndex(uint index); + + void GetFileTypeIndex(out uint index); + + void Advise(IntPtr events, out uint cookie); + + void Unadvise(uint cookie); + + void SetOptions(uint options); + + void GetOptions(out uint options); + + void SetDefaultFolder(IShellItem item); + + void SetFolder(IShellItem item); + + void GetFolder(out IShellItem item); + + void GetCurrentSelection(out IShellItem item); + + void SetFileName([MarshalAs(UnmanagedType.LPWStr)] string name); + + void GetFileName([MarshalAs(UnmanagedType.LPWStr)] out string name); + + void SetTitle([MarshalAs(UnmanagedType.LPWStr)] string title); + + void SetOkButtonLabel([MarshalAs(UnmanagedType.LPWStr)] string text); + + void SetFileNameLabel([MarshalAs(UnmanagedType.LPWStr)] string label); + + void GetResult(out IShellItem item); + + void AddPlace(IShellItem item, int placement); + + void SetDefaultExtension([MarshalAs(UnmanagedType.LPWStr)] string extension); + + void Close(int hr); + + void SetClientGuid(ref Guid guid); + + void ClearClientData(); + + void SetFilter(IntPtr filter); + + void GetResults(out IShellItemArray items); + + void GetSelectedItems(out IShellItemArray items); + } + + [ComImport] + [Guid("43826d1e-e718-42ee-bc55-a1e261c37bfe")] + [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + private interface IShellItem + { + void BindToHandler(IntPtr bindContext, ref Guid handler, ref Guid iid, out IntPtr result); + + void GetParent(out IShellItem parent); + + void GetDisplayName(uint form, [MarshalAs(UnmanagedType.LPWStr)] out string name); + + void GetAttributes(uint mask, out uint attributes); + + void Compare(IShellItem other, uint hint, out int order); + } + + [ComImport] + [Guid("b63ea76d-1f85-456f-a19c-48159efa858b")] + [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + private interface IShellItemArray + { + void BindToHandler(IntPtr bindContext, ref Guid handler, ref Guid iid, out IntPtr result); + + void GetPropertyStore(int flags, ref Guid iid, out IntPtr store); + + void GetPropertyDescriptionList(IntPtr keyType, ref Guid iid, out IntPtr list); + + void GetAttributes(int flags, uint mask, out uint attributes); + + void GetCount(out uint count); + + void GetItemAt(uint index, out IShellItem item); + + void EnumItems(out IntPtr items); + } +} diff --git a/src/Titano.Uploader/Interop/TrayIcon.cs b/src/Titano.Uploader/Interop/TrayIcon.cs new file mode 100644 index 00000000..e6c52ec6 --- /dev/null +++ b/src/Titano.Uploader/Interop/TrayIcon.cs @@ -0,0 +1,251 @@ +using System.Runtime.InteropServices; +using System.Windows.Interop; +using Titano.Core.Diagnostics; + +namespace Titano.Uploader.Interop; + +/// One entry of the tray menu; an id of 0 is a separator. +public readonly record struct TrayMenuItem(int Id, string? Text); + +/// +/// Notification-area icon through Shell_NotifyIconW: the program icon from the executable's resources, a tooltip, +/// a native context menu and balloons. A hidden window receives the callbacks and re-adds the icon after Explorer restarts. +/// +public sealed unsafe partial class TrayIcon : IDisposable +{ + private const uint NimAdd = 0; + private const uint NimModify = 1; + private const uint NimDelete = 2; + private const uint NifMessage = 0x1; + private const uint NifIcon = 0x2; + private const uint NifTip = 0x4; + private const uint NifInfo = 0x10; + private const uint NiifUser = 0x4; + private const int CallbackMessage = 0x8000 + 1; // WM_APP + 1 + private const int WmContextMenu = 0x007B; + private const int WmLButtonUp = 0x0202; + private const int WmLButtonDblClk = 0x0203; + private const int WmRButtonUp = 0x0205; + private const int NinBalloonUserClick = 0x0405; + private const uint MfString = 0x0; + private const uint MfSeparator = 0x800; + private const uint TpmRightButton = 0x2; + private const uint TpmNoNotify = 0x80; + private const uint TpmReturnCmd = 0x100; + + private readonly HwndSource _window; + private readonly IntPtr _icon; + private readonly bool _ownsIcon; + private readonly uint _taskbarCreated; + private readonly Func> _menu; + private readonly Action _command; + private readonly Action _show; + private string _toolTip; + private bool _added; + + /// Hover text (up to 127 characters). + /// Builds the context menu when it opens. + /// Runs a chosen menu id. + /// Left click or balloon click. + public TrayIcon(string toolTip, Func> menu, Action command, Action show) + { + _toolTip = toolTip; + _menu = menu; + _command = command; + _show = show; + // A hidden top-level window: message-only windows miss the TaskbarCreated broadcast. + _window = new HwndSource(new HwndSourceParameters("TitanoUploaderTray") { Width = 0, Height = 0, WindowStyle = 0 }); + _window.AddHook(WndProc); + _taskbarCreated = RegisterWindowMessageW("TaskbarCreated"); + (_icon, _ownsIcon) = LoadProgramIcon(); + Add(); + } + + public void SetToolTip(string text) + { + _toolTip = text; + var data = NewData(NifTip); + Copy(_toolTip, data.Tip, 128); + Notify(NimModify, &data); + } + + /// Shows a balloon (a toast on Windows 10/11) with the program icon. + public void ShowBalloon(string title, string text) + { + var data = NewData(NifInfo); + Copy(title, data.InfoTitle, 64); + Copy(text, data.Info, 256); + data.InfoFlags = NiifUser; + Notify(NimModify, &data); + } + + public void Dispose() + { + if (_added) + { + var data = NewData(0); + Notify(NimDelete, &data); + _added = false; + } + if (_ownsIcon) DestroyIcon(_icon); + _window.Dispose(); + } + + private void Add() + { + var data = NewData(NifMessage | NifIcon | NifTip); + data.CallbackMessage = CallbackMessage; + data.Icon = _icon; + Copy(_toolTip, data.Tip, 128); + _added = Notify(NimAdd, &data); + } + + private IntPtr WndProc(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam, ref bool handled) + { + if (msg == CallbackMessage) + { + switch ((int)(lParam.ToInt64() & 0xFFFF)) + { + case WmLButtonUp or WmLButtonDblClk or NinBalloonUserClick: + _show(); + break; + case WmRButtonUp or WmContextMenu: + ShowMenu(); + break; + } + handled = true; + } + else if (_taskbarCreated != 0 && msg == (int)_taskbarCreated) + { + Add(); + } + return IntPtr.Zero; + } + + private void ShowMenu() + { + var menu = CreatePopupMenu(); + if (menu == IntPtr.Zero) return; + try + { + foreach (var item in _menu()) + { + if (item.Id == 0 || item.Text is null) AppendMenuW(menu, MfSeparator, 0, null); + else AppendMenuW(menu, MfString, (nuint)item.Id, item.Text); + } + GetCursorPos(out var point); + // Without foreground the menu would not close when the user clicks elsewhere. + SetForegroundWindow(_window.Handle); + var chosen = TrackPopupMenuEx(menu, TpmReturnCmd | TpmRightButton | TpmNoNotify, point.X, point.Y, _window.Handle, IntPtr.Zero); + PostMessageW(_window.Handle, 0, IntPtr.Zero, IntPtr.Zero); + if (chosen != 0) _command(chosen); + } + finally + { + DestroyMenu(menu); + } + } + + private NotifyIconData NewData(uint flags) => new() + { + Size = (uint)sizeof(NotifyIconData), + Window = _window.Handle, + Id = 1, + Flags = flags, + }; + + private static bool Notify(uint message, NotifyIconData* data) + { + if (Shell_NotifyIconW(message, data)) return true; + Log.Info("tray", $"Shell_NotifyIcon({message}) failed"); + return false; + } + + private static void Copy(string text, char* destination, int capacity) + { + var length = Math.Min(text.Length, capacity - 1); + text.AsSpan(0, length).CopyTo(new Span(destination, capacity)); + destination[length] = '\0'; + } + + /// The generated titano-uploader icon embedded in the executable; the stock icon if it cannot be read. + private static (IntPtr Icon, bool Owned) LoadProgramIcon() + { + if (Environment.ProcessPath is { } exe) + { + IntPtr small; + if (ExtractIconExW(exe, 0, null, &small, 1) > 0 && small != IntPtr.Zero) return (small, true); + } + return (LoadIconW(IntPtr.Zero, 32512), false); // IDI_APPLICATION + } + + [StructLayout(LayoutKind.Sequential)] + private struct NotifyIconData + { + public uint Size; + public IntPtr Window; + public uint Id; + public uint Flags; + public uint CallbackMessage; + public IntPtr Icon; + public fixed char Tip[128]; + public uint State; + public uint StateMask; + public fixed char Info[256]; + public uint TimeoutOrVersion; + public fixed char InfoTitle[64]; + public uint InfoFlags; + public Guid Item; + public IntPtr BalloonIcon; + } + + [StructLayout(LayoutKind.Sequential)] + private struct Point + { + public int X; + public int Y; + } + + [LibraryImport("shell32.dll")] + [return: MarshalAs(UnmanagedType.Bool)] + private static partial bool Shell_NotifyIconW(uint message, NotifyIconData* data); + + [LibraryImport("shell32.dll", StringMarshalling = StringMarshalling.Utf16)] + private static partial uint ExtractIconExW(string file, int index, IntPtr* large, IntPtr* small, uint count); + + [LibraryImport("user32.dll")] + private static partial IntPtr LoadIconW(IntPtr instance, nint name); + + [LibraryImport("user32.dll")] + [return: MarshalAs(UnmanagedType.Bool)] + private static partial bool DestroyIcon(IntPtr icon); + + [LibraryImport("user32.dll", StringMarshalling = StringMarshalling.Utf16)] + private static partial uint RegisterWindowMessageW(string name); + + [LibraryImport("user32.dll")] + private static partial IntPtr CreatePopupMenu(); + + [LibraryImport("user32.dll", StringMarshalling = StringMarshalling.Utf16)] + [return: MarshalAs(UnmanagedType.Bool)] + private static partial bool AppendMenuW(IntPtr menu, uint flags, nuint id, string? text); + + [LibraryImport("user32.dll")] + private static partial int TrackPopupMenuEx(IntPtr menu, uint flags, int x, int y, IntPtr window, IntPtr parameters); + + [LibraryImport("user32.dll")] + [return: MarshalAs(UnmanagedType.Bool)] + private static partial bool DestroyMenu(IntPtr menu); + + [LibraryImport("user32.dll")] + [return: MarshalAs(UnmanagedType.Bool)] + private static partial bool GetCursorPos(out Point point); + + [LibraryImport("user32.dll")] + [return: MarshalAs(UnmanagedType.Bool)] + private static partial bool SetForegroundWindow(IntPtr window); + + [LibraryImport("user32.dll")] + [return: MarshalAs(UnmanagedType.Bool)] + private static partial bool PostMessageW(IntPtr window, int message, IntPtr wParam, IntPtr lParam); +} diff --git a/src/Titano.Uploader/Shell/ConfirmDialog.xaml b/src/Titano.Uploader/Shell/ConfirmDialog.xaml new file mode 100644 index 00000000..d3eab487 --- /dev/null +++ b/src/Titano.Uploader/Shell/ConfirmDialog.xaml @@ -0,0 +1,22 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +