From
https://learn.microsoft.com/en-us/dotnet/desktop/wpf/advanced/flow-document-overview?view=netframeworkdesktop-4.8

WPF Flow Documents Compared to PDF

What’s the Deal with Flow Documents?

Imagine you’re reading a book, and as you resize the window, the text magically adjusts to fit—no more horizontal scrolling or squinting at tiny fonts.

That’s basically the point behind Flow Documents.

They were Microsoft’s brainchild back in 2006 with the .NET Framework 3.0.

The goal?

To make on-screen reading as comfy as lounging in your favorite chair, regardless of device size, font size, or screen orientation..

A Brief Stroll Down Memory Lane

Back in the day, static documents were the norm.

But as screens of all shapes and sizes emerged, a need arose for content that could gracefully adapt.

Enter Flow Documents—a solution designed to let text and images flow smoothly, no matter where they’re displayed.

What Are Flow Documents?

Flow Documents are a feature of Windows Presentation Foundation (WPF), a graphical subsystem for rendering user interfaces in Windows applications.

Introduced with .NET Framework 3.0 in 2006, WPF aimed to provide a more modern approach to UI development, and Flow Documents were part of this initiative.

Flow Documents are designed to optimize readability by dynamically adjusting the layout based on factors like:

• Window size
• Device resolution
• User preferences

The goal being that content remains accessible and legible across various display environments.

Flow Documents support cool things like pagination, columns, and rich formatting.

The basic idea is to to enable ease of reading.
Microsoft’s documentation on Flow Documents.

PDFs and Their PostScript Pals

Born in 1992, PDFs are like the reliable friend who always shows up looking the same, no matter the occasion.

They’re based on PostScript, a programming language that describes page layouts.

While PostScript is like the chef preparing the meal, PDFs are the ready-to-serve dishes—consistent and unchanging.

Flow Documents vs. PDFs

Code:

Flow Document in WPF:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

<FlowDocumentReader xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
  <FlowDocument>
    <Paragraph>
      <Bold>Some bold text in the paragraph.</Bold>
      Some text that is not bold.
    </Paragraph>
    <List>
      <ListItem>
        <Paragraph>ListItem 1</Paragraph>
      </ListItem>
      <ListItem>
        <Paragraph>ListItem 2</Paragraph>
      </ListItem>
      <ListItem>
        <Paragraph>ListItem 3</Paragraph>
      </ListItem>
    </List>
  </FlowDocument>
</FlowDocumentReader>

Similar Content in a PDF (Raw PostScript):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

%!PS-Adobe-3.0
%%Pages: 1
%%BoundingBox: 0 0 595 842
%%EndComments

/Helvetica-Bold findfont 12 scalefont setfont
100 750 moveto
(Some bold text in the paragraph.) show

/Helvetica findfont 12 scalefont setfont
100 730 moveto
(Some text that is not bold.) show

100 700 moveto
(1. ListItem 1) show

100 680 moveto
(2. ListItem 2) show

100 660 moveto
(3. ListItem 3) show

showpage

In the WPF example, the content is like a yoga master—flexible and adaptable.

In the Postscript example, it’s more like a statue—solid and unchanging.

Which is KIND OF the point behind each respective technology. Goals achieved for each.. :)

Where Are Flow Documents Hanging Out Today?

Flow Documents are mostly in Windows desktop applications that need rich text presentation with dynamic layouts.

Are They Popular?

They have their niche following but haven’t hit the mainstream.

Why? They’re tied to WPF, which is Windows-only, and let’s face it, the world is moving towards cross-platform solutions.

Does .NET MAUI Support Flow Documents?

Nope.

.NET MAUI is all about cross-platform, and Flow Documents are the Windows-only type.

Key Ideas

Related Links

• Flow Document Overview
• PDF: Edit content of PDF page in WPF image viewer
• WPF RichTextBox and FlowDocuments
• Microsoft’s documentation on Flow Documents

====================================

Here’s your article in Obsidian-compatible Markdown for Hugo:

WPF Flow Documents Compared to PDF

History and Motivation Behind Flow Documents

The motivation for creating Flow Documents was enhancing the reading experience in digital applications. Traditional fixed-layout documents often failed to provide optimal readability on different screen sizes and resolutions.

By introducing Flow Documents, Microsoft aimed to offer a solution that could reflow content dynamically, ensuring that text and images adjusted seamlessly to the available display space. This approach was particularly beneficial for applications that displayed extensive textual content, such as:

• E-books
• Articles
• Reports

What Are PDF Files and Their Relationship to PostScript?

PDF (Portable Document Format)

PDF is a file format developed by Adobe Systems in 1992. It was created to present documents consistently across different platforms and devices, preserving the intended layout, fonts, and graphics.

Relationship to PostScript

PDFs are based on the PostScript language, which is also developed by Adobe. While PostScript is a programming language used to describe page layouts and graphics, PDFs encapsulate this information in a fixed, static format optimized for viewing and printing.

This encapsulation makes PDFs more user-friendly, as they do not require interpretation by a PostScript interpreter at the time of viewing.

For more details, see Wikipedia’s article on PDF.

PostScript and PDF in Relation to WPF Flow Documents

PostScript and PDF are both fixed-layout formats, ensuring that documents look the same across all devices. WPF Flow Documents, on the other hand, are designed for flexibility, allowing content to adapt dynamically to different screen sizes.

This fundamental difference means:

• PDFs are ideal for documents that must maintain an exact layout (e.g., legal documents, brochures).
• Flow Documents are better for interactive content that adapts to the screen (e.g., articles, e-books).

Comparison Code Examples

Creating a Simple Flow Document in WPF

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

<FlowDocumentReader xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
  <FlowDocument>
    <Paragraph>
      <Bold>Some bold text in the paragraph.</Bold>
      Some text that is not bold.
    </Paragraph>
    <List>
      <ListItem>
        <Paragraph>ListItem 1</Paragraph>
      </ListItem>
      <ListItem>
        <Paragraph>ListItem 2</Paragraph>
      </ListItem>
      <ListItem>
        <Paragraph>ListItem 3</Paragraph>
      </ListItem>
    </List>
  </FlowDocument>
</FlowDocumentReader>

In the WPF example, the FlowDocumentReader control displays a FlowDocument that contains a paragraph with bold text and a list. The content will automatically adjust based on the window size.

Creating a Similar Document in PDF (using a Hypothetical PDF Library in C#)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

using (var document = new PdfDocument())
{
    var page = document.AddPage();
    var gfx = XGraphics.FromPdfPage(page);
    var fontBold = new XFont("Times New Roman", 12, XFontStyle.Bold);
    var fontRegular = new XFont("Times New Roman", 12, XFontStyle.Regular);

    gfx.DrawString("Some bold text in the paragraph.", fontBold, XBrushes.Black,
      new XRect(0, 0, page.Width, page.Height),
      XStringFormats.TopLeft);

    gfx.DrawString(" Some text that is not bold.", fontRegular, XBrushes.Black,
      new XRect(0, 20, page.Width, page.Height),
      XStringFormats.TopLeft);

    gfx.DrawString("1. ListItem 1", fontRegular, XBrushes.Black,
      new XRect(0, 40, page.Width, page.Height),
      XStringFormats.TopLeft);
    gfx.DrawString("2. ListItem 2", fontRegular, XBrushes.Black,
      new XRect(0, 60, page.Width, page.Height),
      XStringFormats.TopLeft);
    gfx.DrawString("3. ListItem 3", fontRegular, XBrushes.Black,
      new XRect(0, 80, page.Width, page.Height),
      XStringFormats.TopLeft);

    document.Save("example.pdf");
}

In the PDF example, a new document is created, and text is drawn onto the page with specific fonts and positions. Unlike Flow Documents, the layout is fixed and will not change based on the viewing environment.

Where Are WPF Flow Documents Used Today?

Flow Documents are primarily used in Windows desktop applications that require rich text presentation with dynamic layout capabilities. They are useful for:

• E-book readers
• Report viewers
• UI-driven document display in WPF applications

However, they are not widely used outside of the WPF ecosystem.

Does Anyone Use Them in Any Application?

Yes, Flow Documents are used in certain e-book readers, document viewers, and applications that need dynamic content layout. However, they remain niche due to limited platform support.

Why Didn’t Flow Documents Become More Popular?

Several reasons contributed to their limited popularity:

1. Platform Limitation

   • Flow Documents are specific to WPF, which is primarily used for Windows desktop applications.
   • The rise of web and cross-platform apps reduced the demand for Windows-only solutions.

2. Complexity

   • Implementing Flow Documents requires knowledge of WPF and XAML, making it less accessible compared to HTML/CSS for dynamic content.

3. Lack of Standardization

   • Unlike PDFs, which have become an industry standard, Flow Documents are WPF-exclusive and not widely adopted outside of Microsoft technologies.

Does MAUI Support Flow Documents?

No, .NET MAUI does not support Flow Documents. Since MAUI is designed for cross-platform applications (Windows, macOS, iOS, and Android), it does not include WPF-specific features like Flow Documents.

If you need dynamic text formatting in .NET MAUI, you may have to use:

• HTML/CSS rendering
• Markdown parsing
• Custom text layouts

Conclusion

Flow Documents were a powerful but niche feature in WPF, while PDF remains the industry standard for document sharing and printing.

Want to copy this article? Click the button below! 😎 🚀