Documents, Printing & Text

using System.Windows;
using System.Windows.Documents;
using System.Windows.Media;
using Bookshelf.Core;

namespace Bookshelf.Desktop.Reporting;

public static class BookReportBuilder
{
    public static FlowDocument Build(IReadOnlyList<Book> books, DateOnly generatedOn)
    {
        var document = new FlowDocument
        {
            FontFamily = new FontFamily("Palatino Linotype"),
            FontSize = 14,
            ColumnWidth = 400,
            PagePadding = new Thickness(48),
            IsOptimalParagraphEnabled = false,
            IsHyphenationEnabled = false,
        };

        document.Blocks.Add(new Paragraph(new Run("Bookshelf report"))
        {
            FontSize = 28,
            FontWeight = FontWeights.Bold,
            Margin = new Thickness(0, 0, 0, 4),
        });
        document.Blocks.Add(new Paragraph(new Run($"{books.Count} books, generated {generatedOn:D}"))
        {
            Foreground = Brushes.DimGray,
        });

        var table = new Table { CellSpacing = 0, BorderBrush = Brushes.Gray, BorderThickness = new Thickness(0, 0, 0, 1) };
        table.Columns.Add(new TableColumn { Width = new GridLength(40) });
        table.Columns.Add(new TableColumn { Width = new GridLength(3, GridUnitType.Star) });
        table.Columns.Add(new TableColumn { Width = new GridLength(2, GridUnitType.Star) });

        var rows = new TableRowGroup();
        rows.Rows.Add(HeaderRow("#", "Title", "Author"));
        var index = 1;
        foreach (var book in books.OrderBy(b => b.Author).ThenBy(b => b.Title))
        {
            rows.Rows.Add(DataRow(index++, book));
        }
        table.RowGroups.Add(rows);
        document.Blocks.Add(table);

        return document;
    }

    private static TableRow HeaderRow(params string[] headings)
    {
        var row = new TableRow { FontWeight = FontWeights.Bold, Background = Brushes.LightGray };
        foreach (var heading in headings)
        {
            row.Cells.Add(new TableCell(new Paragraph(new Run(heading))));
        }
        return row;
    }

    private static TableRow DataRow(int index, Book book)
    {
        var row = new TableRow();
        row.Cells.Add(new TableCell(new Paragraph(new Run(index.ToString()))));
        row.Cells.Add(new TableCell(new Paragraph(new Run(book.Title))));
        row.Cells.Add(new TableCell(new Paragraph(new Run(book.Author))));
        return row;
    }
}

using System.Windows.Documents;
using Bookshelf.Core;
using Bookshelf.Desktop.Reporting;
using CommunityToolkit.Mvvm.ComponentModel;
using CommunityToolkit.Mvvm.Input;

namespace Bookshelf.Desktop;

public partial class BookReportViewModel(IBookRepository repository, IPrintService printService) : ObservableObject
{
    [ObservableProperty]
    public partial FlowDocument? Report { get; set; }

    [RelayCommand]
    private async Task LoadAsync(CancellationToken cancellationToken)
    {
        var books = await repository.GetAllAsync(cancellationToken);
        Report = BookReportBuilder.Build(books, DateOnly.FromDateTime(DateTime.Today));
    }

    [RelayCommand(CanExecute = nameof(CanPrint))]
    private void Print()
    {
        if (Report is not null)
        {
            printService.PrintFlowDocument(Report, "Bookshelf report");
        }
    }

    private bool CanPrint() => Report is not null;

    partial void OnReportChanged(FlowDocument? value) => PrintCommand.NotifyCanExecuteChanged();
}

<Window x:Class="Bookshelf.Desktop.BookReportWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="Bookshelf report" Width="900" Height="640"
        Loaded="OnLoaded">
    <DockPanel>
        <ToolBar DockPanel.Dock="Top">
            <Button Content="Print..." Command="{Binding PrintCommand}" />
        </ToolBar>
        <FlowDocumentReader Document="{Binding Report}"
                            ViewingMode="Scroll"
                            IsFindEnabled="True" />
    </DockPanel>
</Window>

<DockPanel xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
           xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
    <DockPanel.Resources>
        <Style x:Key="FormatButton" TargetType="Button">
            <Setter Property="Width" Value="30" />
            <Setter Property="CommandTarget" Value="{Binding ElementName=NotesEditor}" />
        </Style>
    </DockPanel.Resources>

    <ToolBar DockPanel.Dock="Top">
        <Button Style="{StaticResource FormatButton}" Command="ApplicationCommands.Undo" Content="Undo" Width="48" />
        <Button Style="{StaticResource FormatButton}" Command="ApplicationCommands.Redo" Content="Redo" Width="48" />
        <Separator />
        <Button Style="{StaticResource FormatButton}" Command="EditingCommands.ToggleBold" ToolTip="Bold">
            <TextBlock FontWeight="Bold">B</TextBlock>
        </Button>
        <Button Style="{StaticResource FormatButton}" Command="EditingCommands.ToggleItalic" ToolTip="Italic">
            <TextBlock FontStyle="Italic" FontWeight="Bold">I</TextBlock>
        </Button>
        <Button Style="{StaticResource FormatButton}" Command="EditingCommands.ToggleUnderline" ToolTip="Underline">
            <TextBlock TextDecorations="Underline" FontWeight="Bold">U</TextBlock>
        </Button>
        <Separator />
        <Button Style="{StaticResource FormatButton}" Command="EditingCommands.ToggleBullets" Content="List" Width="48" />
        <Button Style="{StaticResource FormatButton}" Command="EditingCommands.AlignLeft" Content="Left" Width="48" />
        <Button Style="{StaticResource FormatButton}" Command="EditingCommands.AlignCenter" Content="Center" Width="56" />
    </ToolBar>

    <RichTextBox x:Name="NotesEditor" AcceptsTab="True" SpellCheck.IsEnabled="True">
        <FlowDocument>
            <Paragraph>Notes about <Bold>this book</Bold> go here.</Paragraph>
        </FlowDocument>
    </RichTextBox>
</DockPanel>

using System.IO;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;

namespace Bookshelf.Desktop.Reporting;

public static class RichTextPersistence
{
    public static async Task SaveAsync(RichTextBox editor, string path, string dataFormat)
    {
        var range = new TextRange(editor.Document.ContentStart, editor.Document.ContentEnd);
        await using var stream = new FileStream(path, FileMode.Create, FileAccess.Write);
        range.Save(stream, dataFormat);
        await stream.FlushAsync();
    }

    public static async Task LoadAsync(RichTextBox editor, string path, string dataFormat)
    {
        if (!File.Exists(path))
        {
            return;
        }

        var range = new TextRange(editor.Document.ContentStart, editor.Document.ContentEnd);
        await using var stream = new FileStream(path, FileMode.Open, FileAccess.Read);
        range.Load(stream, dataFormat);
    }
}

// Usage in the notes window:
//   await RichTextPersistence.SaveAsync(NotesEditor, path, DataFormats.XamlPackage);
//   await RichTextPersistence.LoadAsync(NotesEditor, path, DataFormats.Rtf);

<DocumentViewer xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
                xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
    <FixedDocument>
        <PageContent>
            <FixedPage Width="793.7" Height="1122.5" Background="White">
                <TextBlock FixedPage.Left="48" FixedPage.Top="40"
                           FontFamily="Palatino Linotype" FontSize="22" FontWeight="Bold"
                           Text="Bookshelf spine labels" />

                <Border FixedPage.Left="48" FixedPage.Top="100" Width="220" Height="120"
                        BorderBrush="Black" BorderThickness="1" Padding="10">
                    <StackPanel>
                        <TextBlock FontFamily="Palatino Linotype" FontSize="16" FontWeight="Bold"
                                   TextWrapping="Wrap" Text="Dune" />
                        <TextBlock FontFamily="Palatino Linotype" FontSize="12" Text="Frank Herbert" />
                        <TextBlock FontFamily="Palatino Linotype" FontSize="12"
                                   Typography.NumeralAlignment="Tabular" Text="Shelf 03 / Row 02" />
                    </StackPanel>
                </Border>

                <Border FixedPage.Left="288" FixedPage.Top="100" Width="220" Height="120"
                        BorderBrush="Black" BorderThickness="1" Padding="10">
                    <StackPanel>
                        <TextBlock FontFamily="Palatino Linotype" FontSize="16" FontWeight="Bold"
                                   TextWrapping="Wrap" Text="Neuromancer" />
                        <TextBlock FontFamily="Palatino Linotype" FontSize="12" Text="William Gibson" />
                        <TextBlock FontFamily="Palatino Linotype" FontSize="12"
                                   Typography.NumeralAlignment="Tabular" Text="Shelf 03 / Row 03" />
                    </StackPanel>
                </Border>
            </FixedPage>
        </PageContent>
    </FixedDocument>
</DocumentViewer>

using System.IO;
using System.IO.Packaging;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Xps;
using System.Windows.Xps.Packaging;

namespace Bookshelf.Desktop.Reporting;

public static class XpsExport
{
    public static void Save(FlowDocument document, string xpsPath, Size pageSize)
    {
        // Paginate for a fixed page size. Use a clone in a real app (see Pitfalls).
        var paginator = ((IDocumentPaginatorSource)document).DocumentPaginator;
        paginator.PageSize = pageSize;

        using var package = Package.Open(xpsPath, FileMode.Create, FileAccess.ReadWrite);
        using var xps = new XpsDocument(package, CompressionOption.Maximum);
        XpsDocument.CreateXpsDocumentWriter(xps).Write(paginator);
    }

    public static void ShowInViewer(DocumentViewer viewer, string xpsPath)
    {
        var xps = new XpsDocument(xpsPath, FileAccess.Read);
        viewer.Document = xps.GetFixedDocumentSequence();
    }
}

using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Media;

namespace Bookshelf.Desktop;

public interface IPrintService
{
    /// <summary>Shows the print dialog and prints the document. Returns false when the user cancels.</summary>
    bool PrintFlowDocument(FlowDocument document, string description);

    /// <summary>Shows the print dialog and prints a single visual. Returns false when the user cancels.</summary>
    bool PrintVisual(Visual visual, string description);
}

public sealed class WpfPrintService : IPrintService
{
    public bool PrintFlowDocument(FlowDocument document, string description)
    {
        var dialog = new PrintDialog { UserPageRangeEnabled = true };
        if (dialog.ShowDialog() != true)
        {
            return false;
        }

        var paginator = ((IDocumentPaginatorSource)document).DocumentPaginator;
        paginator.PageSize = new Size(dialog.PrintableAreaWidth, dialog.PrintableAreaHeight);

        dialog.PrintDocument(paginator, description);
        return true;
    }

    public bool PrintVisual(Visual visual, string description)
    {
        var dialog = new PrintDialog();
        if (dialog.ShowDialog() != true)
        {
            return false;
        }

        dialog.PrintVisual(visual, description);
        return true;
    }
}

using System.Printing;

namespace Bookshelf.Desktop;

public static class PrintTickets
{
    /// <summary>Creates a ticket that prefers collated, duplex output when the printer supports it.</summary>
    public static PrintTicket ForBookReport(PrintQueue printQueue)
    {
        PrintCapabilities capabilities = printQueue.GetPrintCapabilities();
        PrintTicket ticket = printQueue.DefaultPrintTicket;

        if (capabilities.CollationCapability.Contains(Collation.Collated))
        {
            ticket.Collation = Collation.Collated;
        }

        if (capabilities.DuplexingCapability.Contains(Duplexing.TwoSidedLongEdge))
        {
            ticket.Duplexing = Duplexing.TwoSidedLongEdge;
        }

        return ticket;
    }

    public static PrintQueueCollection LocalQueues()
    {
        var server = new LocalPrintServer();
        return server.GetPrintQueues();
    }
}

using System.IO;
using System.Printing;
using System.Windows.Documents;
using System.Windows.Xps;
using System.Windows.Xps.Packaging;

namespace Bookshelf.Desktop;

public static class XpsPrinting
{
    public static void Print(string xpsFilePath, PrintQueue printQueue, PrintTicket printTicket)
    {
        XpsDocumentWriter writer = PrintQueue.CreateXpsDocumentWriter(printQueue);

        using var xpsDocument = new XpsDocument(xpsFilePath, FileAccess.Read);
        FixedDocumentSequence sequence = xpsDocument.GetFixedDocumentSequence();

        // Synchronous. Use writer.WriteAsync(sequence, printTicket) to avoid blocking the UI thread.
        writer.Write(sequence, printTicket);
    }
}

using System.Globalization;
using System.Windows;
using System.Windows.Media;

namespace Bookshelf.Desktop.Reporting;

public static class SpineLabel
{
    public static DrawingVisual Create(string title, string author, double pixelsPerDip)
    {
        var typeface = new Typeface("Palatino Linotype");
        var visual = new DrawingVisual();

        using (DrawingContext context = visual.RenderOpen())
        {
            var heading = new FormattedText(
                title,
                CultureInfo.CurrentUICulture,
                FlowDirection.LeftToRight,
                typeface,
                emSize: 20,
                foreground: Brushes.Black,
                pixelsPerDip: pixelsPerDip)
            {
                MaxTextWidth = 220,
                MaxTextHeight = 60,
            };

            var byline = new FormattedText(
                author,
                CultureInfo.CurrentUICulture,
                FlowDirection.LeftToRight,
                typeface,
                emSize: 13,
                foreground: Brushes.DimGray,
                pixelsPerDip: pixelsPerDip);

            context.DrawRectangle(null, new Pen(Brushes.Black, 1), new Rect(0, 0, 240, 120));
            context.DrawText(heading, new Point(10, 8));
            context.DrawText(byline, new Point(10, 80));
        }

        return visual;
    }
}

// Usage (from a window):
//   var dpi = VisualTreeHelper.GetDpi(this).PixelsPerDip;
//   printService.PrintVisual(SpineLabel.Create("Dune", "Frank Herbert", dpi), "Spine label");

<FlowDocument xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
              FontFamily="Palatino Linotype" FontSize="16">

    <Paragraph FontSize="28">
        <Run Typography.Capitals="SmallCaps">Bookshelf price list</Run>
    </Paragraph>

    <Paragraph>
        Dune, 2<Run Typography.Variants="Superscript">nd</Run> edition
    </Paragraph>

    <Table>
        <Table.Columns>
            <TableColumn Width="200" />
            <TableColumn Width="100" />
        </Table.Columns>
        <TableRowGroup Typography.NumeralAlignment="Tabular">
            <TableRow>
                <TableCell><Paragraph>Dune</Paragraph></TableCell>
                <TableCell><Paragraph TextAlignment="Right">12.50</Paragraph></TableCell>
            </TableRow>
            <TableRow>
                <TableCell><Paragraph>Neuromancer</Paragraph></TableCell>
                <TableCell><Paragraph TextAlignment="Right">111.00</Paragraph></TableCell>
            </TableRow>
        </TableRowGroup>
    </Table>

    <Paragraph Typography.Fraction="Slashed">Half price: 1/2, three quarters: 3/4</Paragraph>

    <Paragraph Typography.StandardLigatures="False">Ligatures off: fi ff fl</Paragraph>
</FlowDocument>

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>WinExe</OutputType>
    <TargetFramework>net10.0-windows</TargetFramework>
    <UseWPF>true</UseWPF>
    <Nullable>enable</Nullable>
  </PropertyGroup>

  <ItemGroup>
    <!-- Embedded in the assembly. Use Resource, not EmbeddedResource. -->
    <Resource Include="Fonts\BookshelfSerif-Regular.ttf" />
    <Resource Include="Fonts\BookshelfSerif-Bold.ttf" />
  </ItemGroup>
</Project>

<TextBlock xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
           FontFamily="./Fonts/#Bookshelf Serif"
           Text="Aegean Sea" />

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

namespace Bookshelf.Desktop;

public static class LabelFonts
{
    // Two-part reference: a base URI plus a relative location with the family name after '#'.
    public static void Apply(TextBlock textBlock)
    {
        textBlock.FontFamily = new FontFamily(new Uri("pack://application:,,,/"), "./Fonts/#Bookshelf Serif");
    }

    public static IEnumerable<FontFamily> Packaged()
        => Fonts.GetFontFamilies(new Uri("pack://application:,,,/"), "./Fonts/");
}

using Microsoft.UI.Xaml;
using Microsoft.UI.Xaml.Printing;
using Windows.Graphics.Printing;

namespace Bookshelf.WinUI;

public sealed partial class ReportPage : Microsoft.UI.Xaml.Controls.Page
{
    private PrintDocument? printDocument;
    private IPrintDocumentSource? printDocumentSource;
    private readonly List<UIElement> printPages = [];

    private void RegisterForPrinting()
    {
        var hWnd = WinRT.Interop.WindowNative.GetWindowHandle(App.MainWindow);
        PrintManager printManager = PrintManagerInterop.GetForWindow(hWnd);
        printManager.PrintTaskRequested += OnPrintTaskRequested;

        printDocument = new PrintDocument();
        printDocumentSource = printDocument.DocumentSource;
        printDocument.Paginate += OnPaginate;
        printDocument.GetPreviewPage += OnGetPreviewPage;
        printDocument.AddPages += OnAddPages;
    }

    private async void OnPrintClicked(object sender, RoutedEventArgs e)
    {
        var hWnd = WinRT.Interop.WindowNative.GetWindowHandle(App.MainWindow);
        await PrintManagerInterop.ShowPrintUIForWindowAsync(hWnd);
    }

    private void OnPrintTaskRequested(PrintManager sender, PrintTaskRequestedEventArgs args)
    {
        args.Request.CreatePrintTask("Bookshelf report", sourceArgs => sourceArgs.SetSource(printDocumentSource));
    }

    private void OnPaginate(object sender, PaginateEventArgs e)
    {
        printPages.Clear();
        var options = (PrintTaskOptions)e.PrintTaskOptions;
        PrintPageDescription page = options.GetPageDescription(0);

        // One page: a panel sized to the printer page. Real reports flow content over several pages here.
        var layout = new Microsoft.UI.Xaml.Controls.StackPanel { Width = page.PageSize.Width, Height = page.PageSize.Height };
        printPages.Add(layout);

        ((PrintDocument)sender).SetPreviewPageCount(printPages.Count, PreviewPageCountType.Intermediate);
    }

    private void OnGetPreviewPage(object sender, GetPreviewPageEventArgs e)
        => ((PrintDocument)sender).SetPreviewPage(e.PageNumber, printPages[e.PageNumber - 1]);

    private void OnAddPages(object sender, AddPagesEventArgs e)
    {
        var document = (PrintDocument)sender;
        foreach (UIElement page in printPages)
        {
            document.AddPage(page);
        }
        document.AddPagesComplete();
    }
}

using System.Drawing;
using System.Drawing.Printing;

namespace Bookshelf.WinForms;

public partial class ReportForm : Form
{
    private string stringToPrint = "";

    private void OnPrintClicked(object? sender, EventArgs e)
    {
        printDocument1.DocumentName = "Bookshelf report";
        stringToPrint = File.ReadAllText(Path.Combine(AppContext.BaseDirectory, "report.txt"));
        printDocument1.Print();
    }

    private void OnPrintPage(object? sender, PrintPageEventArgs e)
    {
        int charactersOnPage = 0;
        int linesPerPage = 0;

        // How much of the remaining text fits within the page margins.
        e.Graphics!.MeasureString(stringToPrint, Font, e.MarginBounds.Size, StringFormat.GenericTypographic,
            out charactersOnPage, out linesPerPage);

        e.Graphics.DrawString(stringToPrint, Font, Brushes.Black, e.MarginBounds, StringFormat.GenericTypographic);

        stringToPrint = stringToPrint[charactersOnPage..];
        e.HasMorePages = stringToPrint.Length > 0;
    }
}

using Microsoft.UI.Text;
using Windows.Storage;
using Windows.Storage.Streams;

namespace Bookshelf.WinUI;

public static class NotesStorage
{
    public static async Task LoadAsync(Microsoft.UI.Xaml.Controls.RichEditBox editor, StorageFile file)
    {
        using IRandomAccessStream stream = await file.OpenAsync(FileAccessMode.Read);
        editor.Document.LoadFromStream(TextSetOptions.FormatRtf, stream);
    }

    public static async Task SaveAsync(Microsoft.UI.Xaml.Controls.RichEditBox editor, StorageFile file)
    {
        using IRandomAccessStream stream = await file.OpenAsync(FileAccessMode.ReadWrite);
        editor.Document.SaveToStream(TextGetOptions.FormatRtf, stream);
    }
}