Add direct dialog results, nav shutdown, system nav/closed window event hooks

Author: mikernet

IconPackBuilder/IconPackBuilder/AppWindow.cs

@@ -36,13 +36,10 @@ public AppWindow()
         };
 
         Content = rootNav;
-        _navigator = CreateNavigator(rootNav, services.BuildServiceProvider());
 
-#if !WINDOWS
-        var navManager = Windows.UI.Core.SystemNavigationManager.GetForCurrentView();
-        navManager.AppViewBackButtonVisibility = Windows.UI.Core.AppViewBackButtonVisibility.Visible;
-        navManager.BackRequested += (s, e) => e.Handled = _navigator.HandleSystemBackRequest();
-#endif
+        _navigator = CreateNavigator(rootNav, services.BuildServiceProvider());
+        _navigator.HookWindowClosedEvents(this);
+        _navigator.HookSystemNavigationRequests();
     }
 
     public async void BeginNavigation()

Playground/Playground.ViewModels/Home/HomeViewModel.cs

@@ -8,10 +8,23 @@ public partial class HomeViewModel : ObservableObject, IRoutedViewModel
     [ObservableProperty]
     public partial string Messages { get; private set; }
 
+    [ObservableProperty]
+    public partial bool AllowNavigatingAway { get; set; }
+
     public HomeViewModel(IMessageProvider messageProvider, MessageContainer messageContainer, MessageContainer2 messageContainer2)
     {
         Messages = $"IMessageProvider: {messageProvider.GetMessage()}\r\n\r\n" +
             $"MessageContainer: {messageContainer.Message}\r\n\r\n" +
             $"MessageContainer2: {messageContainer2.Message}";
     }
+
+    public async Task OnNavigatingAwayAsync(NavigatingArgs args)
+    {
+        if (!AllowNavigatingAway)
+        {
+            await Task.Delay(1000); // Simulate some async work
+            await this.Navigator.ShowMessageDialogAsync("Navigation cancelled (AllowNavigatingAway is false).");
+            args.Cancel = true;
+        }
+    }
 }

Playground/Playground.ViewModels/MainViewModel.cs

@@ -20,28 +20,34 @@ public partial class MainViewModel : ObservableObject, IRoutedViewModel, IMessag
     [ObservableProperty]
     public partial MenuItem SelectedMenuItem { get; set; } = new("", null);
 
-    partial void OnSelectedMenuItemChanged(MenuItem value)
+    partial void OnSelectedMenuItemChanged(MenuItem oldValue, MenuItem newValue)
     {
-        if (Navigator.IsNavigating || Navigator.CurrentRoute.Parts.Last() == value.ChildRoutePart)
+        if (Navigator.IsNavigating || Navigator.CurrentRoute.Parts.Contains(newValue.ChildRoutePart))
             return;
 
         this.TaskRunner.RunAndForget(async () => {
-            if (value.ChildRoutePart is not null)
+            NavigationResult result;
+
+            if (newValue.ChildRoutePart is not null)
+            {
+                result = await Navigator.NavigatePartialAsync(newValue.ChildRoutePart);
+            }
+            else
             {
-                await Navigator.NavigatePartialAsync(value.ChildRoutePart);
-                return;
+                await Task.Delay(500); // Simulate logout
+                result = await Navigator.NavigateAsync(Routes.LoginRoot);
             }
 
-            await Task.Delay(500); // Simulate logout
-            await Navigator.NavigateAsync(Routes.LoginRoot);
+            if (result is not NavigationResult.Success)
+                SelectedMenuItem = oldValue;
         });
     }
 
     public async Task OnNavigatedToAsync(NavigationArgs args)
     {
+        this.SetChildService(new MessageContainer("Hello from MainViewModel via child service MessageContainer!"));
         SelectedMenuItem = MainMenuItems[0];
         await Task.Delay(1000);
-        this.SetChildService(new MessageContainer("Hello from MainViewModel via child service MessageContainer!"));
     }
 
     public Task OnRouteNavigatedAsync(NavigationArgs args)

Playground/Playground/AppWindow.cs

@@ -30,13 +30,10 @@ public AppWindow()
         };
 
         Content = rootNav;
-        _navigator = CreateNavigator(rootNav);
 
-#if !WINDOWS
-        var navManager = Windows.UI.Core.SystemNavigationManager.GetForCurrentView();
-        navManager.AppViewBackButtonVisibility = Windows.UI.Core.AppViewBackButtonVisibility.Visible;
-        navManager.BackRequested += (s, e) => e.Handled = _navigator.HandleSystemBackRequest();
-#endif
+        _navigator = CreateNavigator(rootNav);
+        _navigator.HookWindowClosedEvents(this);
+        _navigator.HookSystemNavigationRequests();
     }
 
     public async void BeginNavigation()

Playground/Playground/Views/Home/HomePage.xaml

@@ -6,8 +6,10 @@
   Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">
 
   <Grid>
-    <TextBlock Text="{x:Bind Model.Messages}"
-               HorizontalAlignment="Center"
-               VerticalAlignment="Center"/>
+    <StackPanel Spacing="20" HorizontalAlignment="Center" VerticalAlignment="Center">
+      <CheckBox Content="Allow Navigating Away" IsChecked="{x:Bind Model.AllowNavigatingAway, Mode=TwoWay}"/>
+
+      <TextBlock Text="{x:Bind Model.Messages}" />
+    </StackPanel>
   </Grid>
 </UserControl>

Source/Singulink.UI.Navigation.WinUI/DialogNavigator.cs

@@ -10,11 +10,14 @@ internal sealed class DialogNavigator(Navigator navigator, ContentDialog dialog)
 
     public ITaskRunner TaskRunner => field ??= new TaskRunner(busy => dialog.IsEnabled = !busy);
 
-    /// <inheritdoc cref="IDialogPresenter.ShowDialogAsync{TViewModel}(TViewModel)"/>
-    public async Task ShowDialogAsync<TViewModel>(TViewModel viewModel)
-        where TViewModel : class, IDialogViewModel
+    /// <inheritdoc cref="IDialogPresenter.ShowDialogAsync(IDialogViewModel)"/>
+    public async Task ShowDialogAsync(IDialogViewModel viewModel) => await navigator.ShowDialogAsync(dialog, viewModel);
+
+    /// <inheritdoc cref="IDialogPresenter.ShowDialogAsync{TResult}(IDialogViewModel{TResult})"/>
+    public async Task<TResult> ShowDialogAsync<TResult>(IDialogViewModel<TResult> viewModel)
     {
         await navigator.ShowDialogAsync(dialog, viewModel);
+        return viewModel.Result;
     }
 
     /// <inheritdoc cref="IDialogNavigator.Close"/>

Source/Singulink.UI.Navigation.WinUI/MappingInfo.cs

@@ -17,6 +17,7 @@ internal sealed class MappingInfo
     /// <summary>
     /// Gets the view model type.
     /// </summary>
+    // Note: NonPublicConstructors is needed for calling GetUninitializedObject() in CreateViewModel().
     [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)]
     public Type ViewModelType { get; init; }
 
@@ -35,14 +36,19 @@ private MappingInfo(
         ViewModelType = viewModelType;
         ViewType = viewType;
 
-        _vmCtor = viewModelType.GetConstructors().OrderByDescending(c => c.GetParameters().Length).FirstOrDefault() ??
-            throw new InvalidOperationException($"View model type '{viewModelType}' must have a public constructor.");
+        var ctorCandidates = viewModelType.GetConstructors();
 
-        var nullabilityContext = new NullabilityInfoContext();
+        if (ctorCandidates.Length is 0)
+            throw new InvalidOperationException($"View model type '{viewModelType}' does not have any public constructors.");
 
-        _vmCtorParams = _vmCtor.GetParameters()
-            .Select(p => (p, nullabilityContext.Create(p).WriteState is NullabilityState.Nullable))
-            .ToImmutableArray();
+        if (ctorCandidates.Length > 1)
+            throw new InvalidOperationException($"View model type '{viewModelType}' has multiple public constructors.");
+
+        _vmCtor = ctorCandidates[0];
+        _vmCtorParams = [.. _vmCtor.GetParameters().Select(p => (p, new NullabilityInfoContext().Create(p).WriteState is NullabilityState.Nullable))];
+
+        if (_vmCtorParams.Any(p => p.Param.ParameterType.IsByRef))
+            throw new InvalidOperationException($"View model type '{viewModelType}' has a constructor with by-ref parameters, which is not supported.");
     }
 
     /// <summary>
@@ -53,7 +59,9 @@ public static MappingInfo Create(
         Type viewModelType,
         [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)]
         Type viewType)
-        => new(viewModelType, viewType);
+    {
+        return new(viewModelType, viewType);
+    }
 
     /// <summary>
     /// Creates an instance of the view type.
@@ -80,14 +88,19 @@ public IRoutedViewModelBase CreateViewModel(INavigator navigator, ConcreteRoute.
             var (param, isNullable) = _vmCtorParams[i];
             var paramType = param.ParameterType;
 
-            args[i] = routeItem.ParentItem?.GetChildViewModelService(paramType) ?? navigator.Services.GetService(paramType);
+            args[i] = routeItem.ParentItem?.GetChildViewModelService(paramType) ?? navigator.RootServices.GetService(paramType);
 
             if (args[i] is null)
             {
                 if (param.HasDefaultValue)
+                {
                     args[i] = param.DefaultValue;
+                }
                 else if (!isNullable)
-                    throw new InvalidOperationException($"Cannot resolve required constructor parameter '{param.Name}' of type '{paramType}' for view model type '{ViewModelType}'.");
+                {
+                    throw new InvalidOperationException(
+                        $"Cannot resolve required constructor parameter '{param.Name}' of type '{paramType}' for view model type '{ViewModelType}'.");
+                }
             }
         }
 

Source/Singulink.UI.Navigation.WinUI/Navigator.Dialogs.cs

@@ -5,20 +5,27 @@ namespace Singulink.UI.Navigation.WinUI;
 /// <content>
 /// Provides dialog related implementations for the navigator.
 /// </content>
-partial class Navigator
+partial class Navigator : IDialogPresenter
 {
-    /// <inheritdoc cref="IDialogPresenter.ShowDialogAsync{TViewModel}(TViewModel)"/>
-    public async Task ShowDialogAsync<TViewModel>(TViewModel viewModel) where TViewModel : class, IDialogViewModel
+    /// <inheritdoc cref="IDialogPresenter.ShowDialogAsync(IDialogViewModel)"/>
+    public async Task ShowDialogAsync(IDialogViewModel viewModel)
     {
         await ShowDialogAsync(null, viewModel);
     }
 
-    internal async Task ShowDialogAsync<TViewModel>(ContentDialog? requestingParentDialog, TViewModel viewModel) where TViewModel : class, IDialogViewModel
+    /// <inheritdoc cref="IDialogPresenter.ShowDialogAsync{TResult}(IDialogViewModel{TResult})"/>
+    public async Task<TResult> ShowDialogAsync<TResult>(IDialogViewModel<TResult> viewModel)
+    {
+        await ShowDialogAsync(null, viewModel);
+        return viewModel.Result;
+    }
+
+    internal async Task ShowDialogAsync(ContentDialog? requestingParentDialog, IDialogViewModel viewModel)
     {
         EnsureThreadAccess();
 
         if (_blockDialogs)
-            throw new InvalidOperationException("Show dialog requested at an invalid time while dialogs are blocked.");
+            throw new InvalidOperationException("Show dialog requested at an invalid time while showing dialogs is blocked.");
 
         EnsureDialogIsTopDialog(requestingParentDialog);
         CloseLightDismissPopups();
@@ -76,11 +83,10 @@ internal void CloseDialog(ContentDialog dialog)
         dialogInfo.Tcs.SetResult();
     }
 
-    private ContentDialog CreateDialogFor<TViewModel>(TViewModel viewModel)
-        where TViewModel : class, IDialogViewModel
+    private ContentDialog CreateDialogFor(IDialogViewModel viewModel)
     {
-        if (!_viewModelTypeToDialogActivator.TryGetValue(typeof(TViewModel), out var ctorFunc))
-            throw new KeyNotFoundException($"No dialog registered for view model of type '{typeof(TViewModel)}'.");
+        if (!_viewModelTypeToDialogActivator.TryGetValue(viewModel.GetType(), out var ctorFunc))
+            throw new KeyNotFoundException($"No dialog registered for view model of type '{viewModel.GetType()}'.");
 
         var dialog = ctorFunc.Invoke();
         dialog.DataContext = viewModel;
@@ -140,11 +146,8 @@ async void OnDialogClosing(ContentDialog sender, ContentDialogClosingEventArgs a
 
                     // Make sure we are still the top dialog and another event didn't close the dialog after the yield.
 
-                    if (_dialogStack.TryPeek(out dialogInfo) && dialogInfo.Dialog == sender &&
-                        MixinManager.GetNavigator(dismissibleVm) is { } navigator && !navigator.TaskRunner.IsBusy)
-                    {
-                        await navigator.TaskRunner.RunAsBusyAsync(dismissibleVm.OnDismissRequestedAsync());
-                    }
+                    if (_dialogStack.TryPeek(out dialogInfo) && dialogInfo.Dialog == sender && !dismissibleVm.TaskRunner.IsBusy)
+                        await dismissibleVm.TaskRunner.RunAsBusyAsync(dismissibleVm.OnDismissRequestedAsync());
                 }
             }
         }