Windows, Dialogs & Navigation

using System.ComponentModel;
using System.Windows;

namespace Bookshelf.Desktop;

public partial class MainWindow : Window
{
    private readonly BooksViewModel _viewModel;

    public MainWindow(BooksViewModel viewModel)
    {
        InitializeComponent();
        _viewModel = viewModel;
        DataContext = viewModel;
    }

    protected override void OnClosing(CancelEventArgs e)
    {
        if (_viewModel.HasUnsavedChanges)
        {
            var answer = MessageBox.Show(
                this,
                "There are unsaved changes. Close without saving?",
                "Bookshelf Desktop",
                MessageBoxButton.YesNo,
                MessageBoxImage.Warning,
                MessageBoxResult.No);

            if (answer == MessageBoxResult.No)
            {
                e.Cancel = true;
            }
        }

        base.OnClosing(e);
    }
}

<Window x:Class="Bookshelf.Desktop.BookDetailsWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="Edit book"
        MinWidth="360"
        SizeToContent="WidthAndHeight"
        ResizeMode="NoResize"
        ShowInTaskbar="False"
        WindowStartupLocation="CenterOwner"
        FocusManager.FocusedElement="{Binding ElementName=TitleBox}">
    <Grid Margin="16">
        <Grid.RowDefinitions>
            <RowDefinition Height="Auto"/>
            <RowDefinition Height="Auto"/>
            <RowDefinition Height="Auto"/>
        </Grid.RowDefinitions>
        <Grid.ColumnDefinitions>
            <ColumnDefinition Width="Auto"/>
            <ColumnDefinition Width="*"/>
        </Grid.ColumnDefinitions>

        <Label Grid.Row="0" Content="_Title:" Target="{Binding ElementName=TitleBox}"/>
        <TextBox x:Name="TitleBox" Grid.Row="0" Grid.Column="1" Margin="0,0,0,8"
                 Text="{Binding Title, UpdateSourceTrigger=PropertyChanged}"/>

        <Label Grid.Row="1" Content="_Author:" Target="{Binding ElementName=AuthorBox}"/>
        <TextBox x:Name="AuthorBox" Grid.Row="1" Grid.Column="1" Margin="0,0,0,16"
                 Text="{Binding Author, UpdateSourceTrigger=PropertyChanged}"/>

        <StackPanel Grid.Row="2" Grid.ColumnSpan="2" Orientation="Horizontal"
                    HorizontalAlignment="Right">
            <Button Content="_Save" Width="80" Margin="0,0,8,0" IsDefault="True"
                    Click="OnSaveClicked"/>
            <Button Content="Cancel" Width="80" IsCancel="True"/>
        </StackPanel>
    </Grid>
</Window>

using System.Windows;

namespace Bookshelf.Desktop;

public partial class BookDetailsWindow : Window
{
    public BookDetailsWindow(BookDetailsViewModel viewModel)
    {
        InitializeComponent();
        DataContext = viewModel;
    }

    private void OnSaveClicked(object sender, RoutedEventArgs e)
    {
        if (DataContext is BookDetailsViewModel { CanSave: true })
        {
            // Setting DialogResult closes a window shown with ShowDialog.
            DialogResult = true;
        }
    }
}

namespace Bookshelf.Core;

public interface IDialogService
{
    /// <summary>Asks a yes/no question and returns the answer.</summary>
    Task<bool> ConfirmAsync(string title, string message);

    /// <summary>Opens the add/edit dialog modally; returns null when the user cancels.</summary>
    Task<Book?> EditBookAsync(Book? existing);
}

using System.Linq;
using System.Windows;
using Bookshelf.Core;
using Bookshelf.Desktop.ViewModels;
using Microsoft.Extensions.DependencyInjection;

namespace Bookshelf.Desktop;

public sealed class WpfDialogService(IServiceProvider services) : IDialogService
{
    public Task<Book?> EditBookAsync(Book? existing)
    {
        var details = new BookDetailsViewModel(existing);
        var window = ActivatorUtilities.CreateInstance<BookDetailsWindow>(services, details);
        window.Owner = GetActiveWindow();
        return Task.FromResult(window.ShowDialog() == true ? details.ToBook() : null);
    }

    public Task<bool> ConfirmAsync(string title, string message) =>
        Task.FromResult(
            MessageBox.Show(GetActiveWindow(), message, title,
                MessageBoxButton.YesNo, MessageBoxImage.Question, MessageBoxResult.No)
            == MessageBoxResult.Yes);

    // The active window is the natural owner; fall back to the main window.
    private static Window? GetActiveWindow() =>
        Application.Current.Windows.OfType<Window>().FirstOrDefault(w => w.IsActive)
        ?? Application.Current.MainWindow;
}

using System.Collections.ObjectModel;
using Bookshelf.Core;
using CommunityToolkit.Mvvm.ComponentModel;
using CommunityToolkit.Mvvm.Input;

namespace Bookshelf.Desktop.ViewModels;

public sealed partial class BooksViewModel(IBookRepository repository, IDialogService dialogs)
    : ObservableObject
{
    public ObservableCollection<BookViewModel> Books { get; } = [];

    [ObservableProperty]
    [NotifyCanExecuteChangedFor(nameof(EditSelectedCommand))]
    [NotifyCanExecuteChangedFor(nameof(DeleteSelectedCommand))]
    public partial BookViewModel? SelectedBook { get; set; }

    [RelayCommand(CanExecute = nameof(HasSelection))]
    private async Task EditSelectedAsync()
    {
        if (SelectedBook is null) return;

        var edited = await dialogs.EditBookAsync(SelectedBook.Model);
        if (edited is null) return;

        await repository.UpdateAsync(edited, CancellationToken.None);
        // BookViewModel wraps an immutable Book, so the wrapper is replaced.
        Books[Books.IndexOf(SelectedBook)] = new BookViewModel(edited);
    }

    [RelayCommand(CanExecute = nameof(HasSelection))]
    private async Task DeleteSelectedAsync()
    {
        if (SelectedBook is null) return;
        if (!await dialogs.ConfirmAsync("Bookshelf Desktop", $"Delete \"{SelectedBook.Title}\"?")) return;

        await repository.DeleteAsync(SelectedBook.Id, CancellationToken.None);
        Books.Remove(SelectedBook);
    }

    private bool HasSelection() => SelectedBook is not null;
}

<Grid>
    <Grid.ColumnDefinitions>
        <ColumnDefinition Width="200"/>
        <ColumnDefinition Width="*"/>
    </Grid.ColumnDefinitions>

    <StackPanel Margin="8">
        <Button Content="General" Command="{Binding OpenGeneralCommand}"/>
        <Button Content="Appearance" Command="{Binding OpenAppearanceCommand}"/>
        <Button Content="Back" Command="{Binding GoBackCommand}"/>
    </StackPanel>

    <Frame x:Name="SettingsFrame" Grid.Column="1"
           NavigationUIVisibility="Hidden"
           JournalOwnership="OwnsJournal"/>
</Grid>

using System.Windows.Controls;
using Microsoft.Extensions.DependencyInjection;

namespace Bookshelf.Desktop;

// Page-local helper for the settings Frame; not the MVVM INavigationService from Bookshelf.Core.
public interface IFrameNavigator
{
    bool CanGoBack { get; }
    void NavigateTo<TPage>() where TPage : Page;
    void GoBack();
}

public sealed class SettingsFrameNavigator(IServiceProvider services) : IFrameNavigator
{
    private Frame? _frame;

    /// <summary>Called once by the view that owns the Frame, from its Loaded handler.</summary>
    public void Attach(Frame frame) => _frame = frame;

    public bool CanGoBack => _frame?.CanGoBack ?? false;

    public void NavigateTo<TPage>() where TPage : Page
    {
        // Navigating to an object keeps that instance in the journal.
        _frame?.Navigate(services.GetRequiredService<TPage>());
    }

    public void GoBack()
    {
        if (_frame is { CanGoBack: true })
        {
            _frame.GoBack();
        }
    }
}

using System.Windows;
using System.Windows.Controls;

namespace Bookshelf.Desktop;

public partial class MainWindow
{
    // Injected through the constructor in the host-created window (not shown).
    private SettingsFrameNavigator _settingsNavigator = null!;

    private void OnLoaded(object sender, RoutedEventArgs e)
    {
        // The Frame exists once the markup is loaded; hand it to the service.
        _settingsNavigator.Attach(SettingsFrame);
    }
}

<PageFunction x:Class="Bookshelf.Desktop.IsbnLookupPage"
              xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
              xmlns:sys="clr-namespace:System;assembly=System.Runtime"
              x:TypeArguments="sys:String"
              Title="Look up ISBN">
    <StackPanel Margin="16">
        <TextBox x:Name="IsbnBox"/>
        <Button Content="Accept" IsDefault="True" Click="OnAccept"/>
        <Button Content="Cancel" IsCancel="True" Click="OnCancel"/>
    </StackPanel>
</PageFunction>

using System.Windows;
using System.Windows.Navigation;

namespace Bookshelf.Desktop;

public partial class IsbnLookupPage : PageFunction<string>
{
    public IsbnLookupPage() => InitializeComponent();

    private void OnAccept(object sender, RoutedEventArgs e) =>
        OnReturn(new ReturnEventArgs<string>(IsbnBox.Text.Trim()));

    // Returning with a null Result tells the caller the user cancelled.
    private void OnCancel(object sender, RoutedEventArgs e) =>
        OnReturn(new ReturnEventArgs<string>());
}

public static class AddBookFlow
{
    public static void Start(NavigationService navigation, Action<string> onIsbn)
    {
        var page = new IsbnLookupPage();
        page.Returned += (_, e) =>
        {
            if (e.Result is { Length: > 0 } isbn)
            {
                onIsbn(isbn);
            }
        };
        navigation.Navigate(page);
    }
}