Übersicht über Flussdokumente

Flussdokumente dienen der Optimierung der Anzeige und Lesbarkeit. Flussdokumente sind nicht auf ein vordefiniertes Layout festgelegt, sondern passen ihren Inhalt auf Grundlage von Laufzeitvariablen wie Fenstergröße, Geräteauflösung und optionalen Benutzereinstellungen dynamisch an und brechen ihn dynamisch um. Zudem bieten Flussdokumente erweiterte Dokumentfunktionen, z.B. Paginierung und Spalten. Dieses Thema enthält eine Übersicht über Flussdokumente und deren Erstellung.

Was ist ein Flussdokument?

Ein Flussdokument wurde konzipiert, um abhängig von der Fenstergröße, der Geräteauflösung und anderen Umgebungsvariablen den „Inhalt dynamisch umzubrechen“. Zudem verfügen Flussdokumente über eine Vielzahl integrierter Funktionen, inklusive der Suche, Anzeigemodi zur Optimierung der Lesbarkeit und der Möglichkeit zum Ändern der Größe und Darstellung von Schriftarten. Flussdokumente werden am besten verwendet, wenn das erleichterte Lesen das Hauptgebrauchsszenario des Dokuments darstellt. Im Gegensatz dazu sind fixierte Dokumente für eine statische Darstellung entworfen. Fixierte Dokumente sind hilfreich, wenn die Originaltreue des Quellinhalts wichtig ist. Weitere Informationen zu den verschiedenen Dokumenttypen finden Sie unter Dokumente in WPF.

Die folgende Abbildung zeigt ein Beispielflussdokument in mehreren Fenstern von verschiedener Größe. Wenn sich der Bildschirmbereich ändert, bricht der Inhalt dynamisch um, um den verfügbaren Platz bestmöglich auszunutzen.

Wie in dem Bild oben dargestellt, kann fortlaufender Inhalt viele Komponenten umfassen, einschließlich Absätzen, Listen, Bilder usw. Diese Komponenten entsprechen Elementen im Markup und Objekten in prozeduralem Code. Weiter unten im Abschnitt Flussbezogene Klassen dieser Übersicht werden wir genauer auf diese Klassen eingehen. Zunächst sehen Sie hier ein einfaches Codebeispiel, das ein Flussdokument erstellt, das aus einem Absatz mit fett formatiertem Text und einer Liste besteht.

<!-- This simple flow document includes a paragraph with some
     bold text in it and a list. -->
<FlowDocumentReader xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
  <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>

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

namespace SDKSample
{
    public partial class SimpleFlowExample : Page
    {
        public SimpleFlowExample()
        {

            Paragraph myParagraph = new Paragraph();

            // Add some Bold text to the paragraph
            myParagraph.Inlines.Add(new Bold(new Run("Some bold text in the paragraph.")));

            // Add some plain text to the paragraph
            myParagraph.Inlines.Add(new Run(" Some text that is not bold."));

            // Create a List and populate with three list items.
            List myList = new List();

            // First create paragraphs to go into the list item.
            Paragraph paragraphListItem1 = new Paragraph(new Run("ListItem 1"));
            Paragraph paragraphListItem2 = new Paragraph(new Run("ListItem 2"));
            Paragraph paragraphListItem3 = new Paragraph(new Run("ListItem 3"));

            // Add ListItems with paragraphs in them.
            myList.ListItems.Add(new ListItem(paragraphListItem1));
            myList.ListItems.Add(new ListItem(paragraphListItem2));
            myList.ListItems.Add(new ListItem(paragraphListItem3));

            // Create a FlowDocument with the paragraph and list.
            FlowDocument myFlowDocument = new FlowDocument();
            myFlowDocument.Blocks.Add(myParagraph);
            myFlowDocument.Blocks.Add(myList);

            // Add the FlowDocument to a FlowDocumentReader Control
            FlowDocumentReader myFlowDocumentReader = new FlowDocumentReader();
            myFlowDocumentReader.Document = myFlowDocument;

            this.Content = myFlowDocumentReader;
        }
    }
}

Imports System.Windows
Imports System.Windows.Controls
Imports System.Windows.Documents

Namespace SDKSample
    Partial Public Class SimpleFlowExample
        Inherits Page
        Public Sub New()

            Dim myParagraph As New Paragraph()

            ' Add some Bold text to the paragraph
            myParagraph.Inlines.Add(New Bold(New Run("Some bold text in the paragraph.")))

            ' Add some plain text to the paragraph
            myParagraph.Inlines.Add(New Run(" Some text that is not bold."))

            ' Create a List and populate with three list items.
            Dim myList As New List()

            ' First create paragraphs to go into the list item.
            Dim paragraphListItem1 As New Paragraph(New Run("ListItem 1"))
            Dim paragraphListItem2 As New Paragraph(New Run("ListItem 2"))
            Dim paragraphListItem3 As New Paragraph(New Run("ListItem 3"))

            ' Add ListItems with paragraphs in them.
            myList.ListItems.Add(New ListItem(paragraphListItem1))
            myList.ListItems.Add(New ListItem(paragraphListItem2))
            myList.ListItems.Add(New ListItem(paragraphListItem3))

            ' Create a FlowDocument with the paragraph and list.
            Dim myFlowDocument As New FlowDocument()
            myFlowDocument.Blocks.Add(myParagraph)
            myFlowDocument.Blocks.Add(myList)

            ' Add the FlowDocument to a FlowDocumentReader Control
            Dim myFlowDocumentReader As New FlowDocumentReader()
            myFlowDocumentReader.Document = myFlowDocument

            Me.Content = myFlowDocumentReader
        End Sub
    End Class
End Namespace

In der folgenden Abbildung wird gezeigt, wie dieser Codeausschnitt aussieht.

In diesem Beispiel wird das FlowDocumentReader-Steuerelement verwendet, um den Inhalt des Flusses zu hosten. Weitere Informationen zu Hoststeuerelementen für fortlaufenden Inhalt finden Sie unter Flussdokumenttypen. Paragraph, List, ListItem, und Bold Elemente werden verwendet, um die Inhaltsformatierung basierend auf ihrer Reihenfolge im Markup zu steuern. Beispielsweise erstreckt sich das Element Bold nur über Teile des Texts im Absatz. Dadurch wird nur dieser Teil des Texts fett angezeigt. Wenn Sie HTML verwendet haben, wird Ihnen dies vertraut sein.

Wie in der obigen Abbildung hervorgehoben, sind mehrere Funktionen in Flussdokumenten integriert:

• Suche: Ermöglicht dem Benutzer, eine Volltextsuche auf ein ganzes Dokument auszuführen.

• Anzeigemodus: Der Benutzer kann seinen bevorzugten Anzeigemodus auswählen, darunter der Anzeigemodus „Einzelne Seite“ (Seite-für-Seite), der Anzeigemodus „Zwei Seiten“ (Buchleseformat) und der fortlaufende Anzeigemodus „Fensterinhalt verschieben“ (unbeschränkt). Weitere Informationen über diese Anzeigemodi finden Sie unter FlowDocumentReaderViewingMode.

• Steuerelemente für die Seitennavigation: Wenn der Anzeigemodus des Dokuments Seiten verwendet, umfassen die Steuerelemente für die Seitennavigation eine Schaltfläche zum Springen auf die nächste Seite (Pfeil nach unten) oder die vorherige Seite (Pfeil nach oben) sowie Indikatoren für die aktuelle Seitennummer und die Gesamtzahl der Seiten. Das Blättern durch Seiten funktioniert auch mithilfe der Pfeiltasten auf der Tastatur.

• Zoom: Die Zoomsteuerelemente ermöglichen es dem Benutzer, die Zoomstufe zu erhöhen oder zu verringern, indem er entsprechend auf die Plus- oder Minusschaltfächen klickt. Die Zoomsteuerelemente umfassen zudem einen Schieberegler zum Anpassen der Zoomstufe. Weitere Informationen finden Sie unter Zoom.

Diese Funktionen können basierend auf dem zum Hosten des fortlaufenden Inhalts verwendeten Steuerelement bearbeitet werden. Im nächsten Abschnitt werden die verschiedenen Steuerelemente beschrieben.

Flussdokumenttypen

Die Anzeige und Darstellung von Flussdokumentinhalt hängt davon ab, welches Objekt zum Hosten des fortlaufenden Inhalts verwendet wird. Es gibt vier Steuerelemente, die das Anzeigen von Flussinhalten unterstützen: FlowDocumentReader, FlowDocumentPageViewer, RichTextBox, und FlowDocumentScrollViewer. Diese Steuerelemente werden nachstehend kurz beschrieben.

FlowDocumentReader

FlowDocumentReader enthält Funktionen, mit denen der Benutzer dynamisch zwischen verschiedenen Anzeigemodi wählen kann, darunter „Einzelne Seite“ (Seite für Seite), „Zwei Seiten“ (Buchleseformat) und der fortlaufende Anzeigemodus „Fensterinhalt verschieben“ (unbeschränkt). Weitere Informationen über diese Anzeigemodi finden Sie unter FlowDocumentReaderViewingMode. Wenn Sie nicht die Möglichkeit benötigen, dynamisch zwischen verschiedenen Anzeigemodi zu wechseln, bieten FlowDocumentPageViewer und FlowDocumentScrollViewer einfachere Viewer für fortlaufenden Inhalt, die auf einen bestimmten Anzeigemodus festgelegt sind.

FlowDocumentPageViewer und FlowDocumentScrollViewer

FlowDocumentPageViewer zeigt den Inhalt im Modus „Einzelne Seite“ an, während FlowDocumentScrollViewer den Inhalt im Modus „Fensterinhalt verschieben“ anzeigt. Sowohl FlowDocumentPageViewer als auch FlowDocumentScrollViewer sind auf einen bestimmten Anzeigemodus festgelegt. Vergleichen Sie diese Modi mit FlowDocumentReader und den darin enthaltenen Funktionen, die es dem Benutzer ermöglichen, dynamisch zwischen verschiedenen Anzeigemodi zu wählen (wie durch die FlowDocumentReaderViewingMode-Enumeration bereitgestellt). Allerdings ist dieser Anzeigemodus ressourcenintensiver als FlowDocumentPageViewer oder FlowDocumentScrollViewer ist.

Standardmäßig wird eine vertikale Scrollleiste immer angezeigt, und eine horizontale Scrollleiste wird bei Bedarf angezeigt. Die Standardbenutzeroberfläche für FlowDocumentScrollViewer enthält keine Symbolleiste. Die Eigenschaft IsToolBarVisible kann jedoch verwendet werden, um eine integrierte Symbolleiste zu aktivieren.

RichTextBox

Sie verwenden RichTextBox, wenn Sie dem Benutzer erlauben möchten, den Inhalt des Flusses zu bearbeiten. Wenn Sie beispielsweise einen Editor erstellen möchten, der es einem Benutzer ermöglicht, Dinge wie Tabellen, Kursiv- und Fettformatierung usw. zu bearbeiten, verwenden Sie eine RichTextBox-Klasse. Weitere Informationen finden Sie unter Übersicht über RichTextBox.

Erstellen von fortlaufendem Inhalt

Fortlaufender Inhalt kann komplex sein und aus verschiedenen Elementen einschließlich Text, Bildern, Tabellen und sogar abgeleiteten UIElement-Klassen wie Steuerelementen bestehen. Um zu verstehen, wie komplexer fortlaufender Inhalt erstellt wird, sind die folgenden Punkte wichtig:

• Flussbezogene Klassen: Jede in fortlaufendem Inhalt verwendete Klasse hat einen bestimmten Zweck. Darüber hinaus hilft Ihnen die hierarchische Beziehung zwischen Flussklassen dabei, zu verstehen, wie sie verwendet werden. Beispielsweise werden von der Block-Klasse abgeleitete Klassen dazu verwendet, andere Objekte einzuschließen, während von Inline abgeleitete Klassen Objekte einschließen, die angezeigt werden.

• Inhaltsschema: Ein Flussdokument kann eine beträchtliche Anzahl von geschachtelten Elementen erfordern. Das Inhaltsschema gibt mögliche Übergeordnet/Untergeordnet-Beziehungen zwischen Elementen an.

In den folgenden Abschnitten wird jeder dieser Bereiche ausführlicher erklärt.

Flussbezogene Klassen

Das folgende Diagramm zeigt die am häufigsten bei fortlaufendem Inhalt verwendeten Objekte:

Für die Zwecke des fortlaufenden Inhalts gibt es zwei wichtige Kategorien:

1. Blockabgeleitete Klassen: Auch „Blockinhaltselemente“ oder einfach „Blockelemente“ genannt. Elemente, die von Block erben können dazu verwendet werden, Elemente unter einem gemeinsamen übergeordneten Element zu gruppieren oder gemeinsame Attribute auf eine Gruppe anzuwenden.

2. Inlineabgeleitete Klassen: Auch „Inlineinhaltselemente“ oder einfach „Inlineelemente“ genannt. Elemente, die von Inline erben sind entweder in einem Blockelement oder in einem anderen Inlineelement eingeschlossen. Inlineelemente werden oft als direkter Container für Inhalt verwendet, der auf dem Bildschirm gerendert wird. Zum Beispiel kann ein Paragraph (Blockelement) ein Run (Inline-Element) enthalten, aber das Run enthält den Text, der auf dem Bildschirm dargestellt wird.

Jede Klasse in diesen zwei Kategorien wird nachstehend kurz beschrieben.

Blockabgeleitete Klassen

Paragraph

Paragraph wird normalerweise verwendet, um Inhalte in einem Absatz zusammenzufassen. Die einfachste und häufigste Verwendung von Paragraph ist, einen Textabsatz zu erstellen.

<FlowDocument xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
  <Paragraph>
    Some paragraph text.
  </Paragraph>
</FlowDocument>

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

namespace SDKSample
{
    public partial class ParagraphExample : Page
    {
        public ParagraphExample()
        {

            // Create paragraph with some text.
            Paragraph myParagraph = new Paragraph();
            myParagraph.Inlines.Add(new Run("Some paragraph text."));

            // Create a FlowDocument and add the paragraph to it.
            FlowDocument myFlowDocument = new FlowDocument();
            myFlowDocument.Blocks.Add(myParagraph);

            this.Content = myFlowDocument;
        }
    }
}

Imports System.Windows
Imports System.Windows.Controls
Imports System.Windows.Documents

Namespace SDKSample
    Partial Public Class ParagraphExample
        Inherits Page
        Public Sub New()

            ' Create paragraph with some text.
            Dim myParagraph As New Paragraph()
            myParagraph.Inlines.Add(New Run("Some paragraph text."))

            ' Create a FlowDocument and add the paragraph to it.
            Dim myFlowDocument As New FlowDocument()
            myFlowDocument.Blocks.Add(myParagraph)

            Me.Content = myFlowDocument
        End Sub
    End Class
End Namespace

Sie können jedoch auch andere inlineabgeleitete Elemente enthalten, wie Sie nachstehend sehen können.

Abschnitt

Section wird nur verwendet, um andere von Block abgeleitete Elemente zu enthalten. Sie wendet keine Standardformatierungen auf die Elemente an, die sie einschließt. Alle Eigenschaftswerte, die für ein Section festgelegt werden, gelten jedoch auch für seine untergeordneten Elemente. Eine Section-Klasse ermöglicht es Ihnen auch, ihre untergeordnete Auflistung programmgesteuert zu durchlaufen. Section wird in ähnlicher Weise wie der <DIV>-Tag in HTML verwendet.

Im nachstehenden Beispiel werden drei Absätze als eine Section-Klasse definiert. Die Section-Klasse hat den Background-Eigenschaftswert „Red“, weshalb die Hintergrundfarbe des Absatzes rot ist.

<FlowDocument xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
  <!-- By default, Section applies no formatting to elements contained
       within it. However, in this example, the section has a Background
       property value of "Red", therefore, the three paragraphs (the block)  
       inside the section also have a red background. -->
  <Section Background="Red">
    <Paragraph>
      Paragraph 1
    </Paragraph>
    <Paragraph>
      Paragraph 2
    </Paragraph>
    <Paragraph>
      Paragraph 3
    </Paragraph>
  </Section>
</FlowDocument>

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

namespace SDKSample
{
    public partial class SectionExample : Page
    {
        public SectionExample()
        {

            // Create three paragraphs
            Paragraph myParagraph1 = new Paragraph(new Run("Paragraph 1"));
            Paragraph myParagraph2 = new Paragraph(new Run("Paragraph 2"));
            Paragraph myParagraph3 = new Paragraph(new Run("Paragraph 3"));

            // Create a Section and add the three paragraphs to it.
            Section mySection = new Section();
            mySection.Background = Brushes.Red;

            mySection.Blocks.Add(myParagraph1);
            mySection.Blocks.Add(myParagraph2);
            mySection.Blocks.Add(myParagraph3);

            // Create a FlowDocument and add the section to it.
            FlowDocument myFlowDocument = new FlowDocument();
            myFlowDocument.Blocks.Add(mySection);

            this.Content = myFlowDocument;
        }
    }
}

Imports System.Windows
Imports System.Windows.Media
Imports System.Windows.Controls
Imports System.Windows.Documents

Namespace SDKSample
    Partial Public Class SectionExample
        Inherits Page
        Public Sub New()

            ' Create three paragraphs
            Dim myParagraph1 As New Paragraph(New Run("Paragraph 1"))
            Dim myParagraph2 As New Paragraph(New Run("Paragraph 2"))
            Dim myParagraph3 As New Paragraph(New Run("Paragraph 3"))

            ' Create a Section and add the three paragraphs to it.
            Dim mySection As New Section()
            mySection.Background = Brushes.Red

            mySection.Blocks.Add(myParagraph1)
            mySection.Blocks.Add(myParagraph2)
            mySection.Blocks.Add(myParagraph3)

            ' Create a FlowDocument and add the section to it.
            Dim myFlowDocument As New FlowDocument()
            myFlowDocument.Blocks.Add(mySection)

            Me.Content = myFlowDocument
        End Sub
    End Class
End Namespace

BlockUIContainer

BlockUIContainer ermöglicht die Einbettung von UIElement-Elementen (z. B. Button ) in von Blöcken abgeleitete Flussinhalte. InlineUIContainer (siehe unten) wird verwendet, um UIElement-Elemente in Inline-Flow-Inhalte einzubetten. BlockUIContainer und InlineUIContainer sind wichtig, weil es keine andere Möglichkeit gibt, ein UIElement in Flowinhalt zu verwenden, wenn es nicht in einem dieser beiden Elemente enthalten ist.

Das folgende Beispiel zeigt, wie Sie das BlockUIContainer-Element verwenden können, um UIElement-Objekte innerhalb von Flow-Inhalten unterzubringen.

<FlowDocument ColumnWidth="400">
  <Section Background="GhostWhite">
    <Paragraph>
      A UIElement element may be embedded directly in flow content
      by enclosing it in a BlockUIContainer element.
    </Paragraph>
    <BlockUIContainer>
      <Button>Click me!</Button>
    </BlockUIContainer>
    <Paragraph>
      The BlockUIContainer element may host no more than one top-level
      UIElement.  However, other UIElements may be nested within the
      UIElement contained by an BlockUIContainer element.  For example,
      a StackPanel can be used to host multiple UIElement elements within
      a BlockUIContainer element.
    </Paragraph>
    <BlockUIContainer>
      <StackPanel>
        <Label Foreground="Blue">Choose a value:</Label>
        <ComboBox>
          <ComboBoxItem IsSelected="True">a</ComboBoxItem>
          <ComboBoxItem>b</ComboBoxItem>
          <ComboBoxItem>c</ComboBoxItem>
        </ComboBox>
        <Label Foreground ="Red">Choose a value:</Label>
        <StackPanel>
          <RadioButton>x</RadioButton>
          <RadioButton>y</RadioButton>
          <RadioButton>z</RadioButton>
        </StackPanel>
        <Label>Enter a value:</Label>
        <TextBox>
          A text editor embedded in flow content.
        </TextBox>
      </StackPanel>
    </BlockUIContainer>
  </Section>
</FlowDocument>

Die folgende Abbildung zeigt, wie dieses Beispiel gerendert wird:

Liste

List wird verwendet, um eine Aufzählung oder eine numerische Liste zu erstellen. Setzen Sie die MarkerStyle-Eigenschaft auf einen TextMarkerStyle-Enumerationswert, um den Stil der Liste zu bestimmen. Das folgende Beispiel zeigt, wie Sie eine einfache Liste erstellen.

<FlowDocument xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
  <List>
    <ListItem>
      <Paragraph>
        List Item 1
      </Paragraph>
    </ListItem>
    <ListItem>
      <Paragraph>
        List Item 2
      </Paragraph>
    </ListItem>
    <ListItem>
      <Paragraph>
        List Item 3
      </Paragraph>
    </ListItem>
  </List>
</FlowDocument>

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

namespace SDKSample
{
    public partial class ListExample : Page
    {
        public ListExample()
        {

            // Create three paragraphs
            Paragraph myParagraph1 = new Paragraph(new Run("List Item 1"));
            Paragraph myParagraph2 = new Paragraph(new Run("List Item 2"));
            Paragraph myParagraph3 = new Paragraph(new Run("List Item 3"));

            // Create the ListItem elements for the List and add the
            // paragraphs to them.
            ListItem myListItem1 = new ListItem();
            myListItem1.Blocks.Add(myParagraph1);
            ListItem myListItem2 = new ListItem();
            myListItem2.Blocks.Add(myParagraph2);
            ListItem myListItem3 = new ListItem();
            myListItem3.Blocks.Add(myParagraph3);

            // Create a List and add the three ListItems to it.
            List myList = new List();

            myList.ListItems.Add(myListItem1);
            myList.ListItems.Add(myListItem2);
            myList.ListItems.Add(myListItem3);

            // Create a FlowDocument and add the section to it.
            FlowDocument myFlowDocument = new FlowDocument();
            myFlowDocument.Blocks.Add(myList);

            this.Content = myFlowDocument;
        }
    }
}

Imports System.Windows
Imports System.Windows.Media
Imports System.Windows.Controls
Imports System.Windows.Documents

Namespace SDKSample
    Partial Public Class ListExample
        Inherits Page
        Public Sub New()

            ' Create three paragraphs
            Dim myParagraph1 As New Paragraph(New Run("List Item 1"))
            Dim myParagraph2 As New Paragraph(New Run("List Item 2"))
            Dim myParagraph3 As New Paragraph(New Run("List Item 3"))

            ' Create the ListItem elements for the List and add the 
            ' paragraphs to them.
            Dim myListItem1 As New ListItem()
            myListItem1.Blocks.Add(myParagraph1)
            Dim myListItem2 As New ListItem()
            myListItem2.Blocks.Add(myParagraph2)
            Dim myListItem3 As New ListItem()
            myListItem3.Blocks.Add(myParagraph3)

            ' Create a List and add the three ListItems to it.
            Dim myList As New List()

            myList.ListItems.Add(myListItem1)
            myList.ListItems.Add(myListItem2)
            myList.ListItems.Add(myListItem3)

            ' Create a FlowDocument and add the section to it.
            Dim myFlowDocument As New FlowDocument()
            myFlowDocument.Blocks.Add(myList)

            Me.Content = myFlowDocument
        End Sub
    End Class
End Namespace

Tabelle

Table wird verwendet, um eine Tabelle zu erstellen. Table ist dem Grid-Element ähnlich, hat aber mehr Funktionen und erfordert daher einen größeren Ressourcenaufwand. Da es sich bei Grid um ein UIElement handelt, kann es nicht in Flussinhalten verwendet werden, es sei denn, es ist in einem BlockUIContainer oder InlineUIContainer enthalten. Weitere Informationen über Table finden Sie unter Tabellenübersicht.

Inlineabgeleitete Klassen

Ausführen

Run wird verwendet, um unformatierten Text zu enthalten. Sie können davon ausgehen, dass Run-Objekte in Flowinhalten ausgiebig verwendet werden. Jedoch ist die Verwendung von Run-Elementen im Markup nicht explizit erforderlich. Die Verwendung von Run ist erforderlich, wenn Flussdokumente mithilfe von Code erstellt oder bearbeitet werden. In der folgenden Markierung beispielsweise wird das Run-Element im ersten Paragraph explizit angegeben, im zweiten Fall nicht. Beide Absätze generieren eine identische Ausgabe.

<Paragraph>
  <Run>Paragraph that explicitly uses the Run element.</Run>
</Paragraph>

<Paragraph>
  This Paragraph omits the Run element in markup. It renders
  the same as a Paragraph with Run used explicitly. 
</Paragraph>

span

Span fasst andere Inline-Inhaltselemente zusammen. Auf Inhalte innerhalb eines Span-Elements wird kein inhärentes Rendering angewendet. Die Elemente, die von Span erben, einschließlich Hyperlink, Bold, Italic und Underline, wenden jedoch Formatierungen auf Text an.

Nachfolgend sehen Sie ein Beispiel für die Nutzung von Span für einen Inlineinhalt, der Text, ein Bold-Element und eine Button umfasst.

<FlowDocument xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">

  <Paragraph>
    Text before the Span. <Span Background="Red">Text within the Span is
    red and <Bold>this text is inside the Span-derived element Bold.</Bold>
    A Span can contain more then text, it can contain any inline content. For
    example, it can contain a 
    <InlineUIContainer>
      <Button>Button</Button>
    </InlineUIContainer>
    or other UIElement, a Floater, a Figure, etc.</Span>
  </Paragraph>

</FlowDocument>

Der folgende Screenshot zeigt, wie dieses Beispiel gerendert wird.

InlineUIContainer

InlineUIContainer aktiviert UIElement-Elemente (z. B. ein Steuerelement wie Button), um in ein Inline-Inhaltselement eingebettet zu werden. Dieses Element ist das Inline-Äquivalent zum oben beschriebenen BlockUIContainer. Nachfolgend finden Sie ein Beispiel für InlineUIContainer zum Einfügen einer Inline-Button in eine Paragraph.

<FlowDocument xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">

  <Paragraph>
    Text to precede the button...

    <!-- Set the BaselineAlignment property to "Bottom" 
         so that the Button aligns properly with the text. -->
    <InlineUIContainer BaselineAlignment="Bottom">
      <Button>Button</Button>
    </InlineUIContainer>
    Text to follow the button...
  </Paragraph>

</FlowDocument>

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

namespace SDKSample
{
    public partial class InlineUIContainerExample : Page
    {
        public InlineUIContainerExample()
        {
            Run run1 = new Run(" Text to precede the button... ");
            Run run2 = new Run(" Text to follow the button... ");

            // Create a new button to be hosted in the paragraph.
            Button myButton = new Button();
            myButton.Content = "Click me!";

            // Create a new InlineUIContainer to contain the Button.
            InlineUIContainer myInlineUIContainer = new InlineUIContainer();

            // Set the BaselineAlignment property to "Bottom" so that the
            // Button aligns properly with the text.
            myInlineUIContainer.BaselineAlignment = BaselineAlignment.Bottom;

            // Asign the button as the UI container's child.
            myInlineUIContainer.Child = myButton;

            // Create the paragraph and add content to it.
            Paragraph myParagraph = new Paragraph();
            myParagraph.Inlines.Add(run1);
            myParagraph.Inlines.Add(myInlineUIContainer);
            myParagraph.Inlines.Add(run2);

            // Create a FlowDocument and add the paragraph to it.
            FlowDocument myFlowDocument = new FlowDocument();
            myFlowDocument.Blocks.Add(myParagraph);

            this.Content = myFlowDocument;
        }
    }
}

Imports System.Windows
Imports System.Windows.Media
Imports System.Windows.Controls
Imports System.Windows.Documents

Namespace SDKSample
    Partial Public Class InlineUIContainerExample
        Inherits Page
        Public Sub New()
            Dim run1 As New Run(" Text to precede the button... ")
            Dim run2 As New Run(" Text to follow the button... ")

            ' Create a new button to be hosted in the paragraph.
            Dim myButton As New Button()
            myButton.Content = "Click me!"

            ' Create a new InlineUIContainer to contain the Button.
            Dim myInlineUIContainer As New InlineUIContainer()

            ' Set the BaselineAlignment property to "Bottom" so that the 
            ' Button aligns properly with the text.
            myInlineUIContainer.BaselineAlignment = BaselineAlignment.Bottom

            ' Asign the button as the UI container's child.
            myInlineUIContainer.Child = myButton

            ' Create the paragraph and add content to it.
            Dim myParagraph As New Paragraph()
            myParagraph.Inlines.Add(run1)
            myParagraph.Inlines.Add(myInlineUIContainer)
            myParagraph.Inlines.Add(run2)

            ' Create a FlowDocument and add the paragraph to it.
            Dim myFlowDocument As New FlowDocument()
            myFlowDocument.Blocks.Add(myParagraph)

            Me.Content = myFlowDocument
        End Sub
    End Class
End Namespace

Figure und Floater

Figure und Floater werden verwendet, um Inhalt in Flussdokumenten mit Positionierungseigenschaften einzubetten, die unabhängig vom primären fortlaufenden Inhalt angepasst werden können. Figure- oder Floater-Elemente werden oft dazu verwendet, Teile von Inhalt hervorzuheben, um unterstützende Bilder oder anderen Inhalt innerhalb des fortlaufenden Hauptinhalts zu hosten oder um losen in Zusammenhang stehenden Inhalt wie Werbung einzufügen.

Das folgende Beispiel zeigt, wie eine Figure-Klasse in einen Textabsatz eingefügt wird.

<FlowDocument xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">

  <Paragraph>
    <Figure 
      Width="300" Height="100" 
      Background="GhostWhite" HorizontalAnchor="PageLeft" >
      <Paragraph FontStyle="Italic" Background="Beige" Foreground="DarkGreen" >
        A Figure embeds content into flow content with placement properties 
        that can be customized independently from the primary content flow
      </Paragraph>
    </Figure>
    Lorem ipsum dolor sit amet, consectetuer adipiscing elit, sed diam nonummy
    nibh euismod tincidunt ut laoreet dolore magna aliquam erat volutpat. Ut wisi
    enim ad minim veniam, quis nostrud exerci tation ullamcorper suscipit lobortis
    nisl ut aliquip ex ea commodo consequat. Duis autem vel eum iriure.
  </Paragraph>

</FlowDocument>

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

namespace SDKSample
{
    public partial class FigureExample : Page
    {
        public FigureExample()
        {

            // Create strings to use as content.
            string strFigure = "A Figure embeds content into flow content with" +
                               " placement properties that can be customized" +
                               " independently from the primary content flow";
            string strOther = "Lorem ipsum dolor sit amet, consectetuer adipiscing" +
                              " elit, sed diam nonummy nibh euismod tincidunt ut laoreet" +
                              " dolore magna aliquam erat volutpat. Ut wisi enim ad" +
                              " minim veniam, quis nostrud exerci tation ullamcorper" +
                              " suscipit lobortis nisl ut aliquip ex ea commodo consequat." +
                              " Duis autem vel eum iriure.";

            // Create a Figure and assign content and layout properties to it.
            Figure myFigure = new Figure();
            myFigure.Width = new FigureLength(300);
            myFigure.Height = new FigureLength(100);
            myFigure.Background = Brushes.GhostWhite;
            myFigure.HorizontalAnchor = FigureHorizontalAnchor.PageLeft;
            Paragraph myFigureParagraph = new Paragraph(new Run(strFigure));
            myFigureParagraph.FontStyle = FontStyles.Italic;
            myFigureParagraph.Background = Brushes.Beige;
            myFigureParagraph.Foreground = Brushes.DarkGreen;
            myFigure.Blocks.Add(myFigureParagraph);

            // Create the paragraph and add content to it.
            Paragraph myParagraph = new Paragraph();
            myParagraph.Inlines.Add(myFigure);
            myParagraph.Inlines.Add(new Run(strOther));

            // Create a FlowDocument and add the paragraph to it.
            FlowDocument myFlowDocument = new FlowDocument();
            myFlowDocument.Blocks.Add(myParagraph);

            this.Content = myFlowDocument;
        }
    }
}

Imports System.Windows
Imports System.Windows.Media
Imports System.Windows.Controls
Imports System.Windows.Documents

Namespace SDKSample
    Partial Public Class FigureExample
        Inherits Page
        Public Sub New()

            ' Create strings to use as content.
            Dim strFigure As String = "A Figure embeds content into flow content with" & " placement properties that can be customized" & " independently from the primary content flow"
            Dim strOther As String = "Lorem ipsum dolor sit amet, consectetuer adipiscing" & " elit, sed diam nonummy nibh euismod tincidunt ut laoreet" & " dolore magna aliquam erat volutpat. Ut wisi enim ad" & " minim veniam, quis nostrud exerci tation ullamcorper" & " suscipit lobortis nisl ut aliquip ex ea commodo consequat." & " Duis autem vel eum iriure."

            ' Create a Figure and assign content and layout properties to it.
            Dim myFigure As New Figure()
            myFigure.Width = New FigureLength(300)
            myFigure.Height = New FigureLength(100)
            myFigure.Background = Brushes.GhostWhite
            myFigure.HorizontalAnchor = FigureHorizontalAnchor.PageLeft
            Dim myFigureParagraph As New Paragraph(New Run(strFigure))
            myFigureParagraph.FontStyle = FontStyles.Italic
            myFigureParagraph.Background = Brushes.Beige
            myFigureParagraph.Foreground = Brushes.DarkGreen
            myFigure.Blocks.Add(myFigureParagraph)

            ' Create the paragraph and add content to it.
            Dim myParagraph As New Paragraph()
            myParagraph.Inlines.Add(myFigure)
            myParagraph.Inlines.Add(New Run(strOther))

            ' Create a FlowDocument and add the paragraph to it.
            Dim myFlowDocument As New FlowDocument()
            myFlowDocument.Blocks.Add(myParagraph)

            Me.Content = myFlowDocument
        End Sub
    End Class
End Namespace

Die folgende Abbildung zeigt, wie dieses Beispiel gerendert wird.

Figure und Floater unterscheiden sich in mehreren Punkten und werden für unterschiedliche Szenarien verwendet.

Abbildung:

• Kann positioniert werden: Sie können die horizontalen und vertikalen Textmarken so festlegen, dass diese relativ an der Seite, dem Inhalt, der Spalte oder dem Absatz andocken. Sie können auch seine HorizontalOffset- und VerticalOffset-Eigenschaften verwenden, um beliebige Offsets anzugeben.

• Kann in der Größe für mehr als eine Spalte angepasst werden: Sie können die Höhe und Breite von Figure für Vielfache der Höhen und Breiten von Seite, Inhalt oder Spalte festlegen. Beachten Sie, dass im Fall von Seiten und Inhalt keine Vielfachen über 1 zulässig sind. Beispielsweise können Sie die Breite einer Figure-Klasse auf „0.5 page“, „0.25 content“ oder „2 Column“ festlegen. Sie können die Höhe und Breite auch auf absolute Pixelwerte festlegen.

• Paginiert nicht: Wenn der Inhalt in einer Figure-Klasse nicht in die Figure-Klasse passt, rendert diese den Inhalt, der hineinpasst, und der restliche Inhalt geht verloren.

Floater:

• Kann nicht positioniert werden und wird gerendert, wo Speicherplatz dafür verfügbar gemacht werden kann. Sie können den Versatz nicht festlegen oder eine Floater verankern.

• Kann in der Größe nicht für mehr als eine Spalte angepasst werden: Standardmäßig passt sich Floater in der Größe an eine Spalte an. Sie verfügt über eine Width-Eigenschaft, die auf einen absoluten Pixelwert festgelegt werden kann. Wenn dieser Wert jedoch größer als eine Spaltenbreite ist, wird er ignoriert, und die Floater-Klasse wird an die Größe einer Spalte angepasst. Sie können die Größe auf weniger als eine Spalte anpassen, indem Sie die richtige Pixelbreite festlegen. Die Größenanpassung ist jedoch nicht spaltenabhängig, sodass „0.5Column“ kein gültiger Ausdruck für die Floater-Breite ist. Floater hat keine Höheneigenschaft, und die Höhe kann nicht festgelegt werden, sondern hängt vom Inhalt ab.

• Floater paginiert: Wenn der Inhalt bei angegebener Breite eine Höhe von mehr als einer Spalte erreicht, bricht Floater um und paginiert zur nächsten Spalte, nächsten Seite usw.

Figure ist ein guter Ort, um eigenständigen Inhalt zu platzieren, bei dem Sie Größe und Position steuern möchten und sicher sind, dass der Inhalt in die angegebene Größe passt. Floater ist ein guter Ort, um weiteren frei fortlaufenden Inhalt zu platzieren, der ähnlich wie der Inhalt der Hauptseite fortläuft, jedoch von diesem getrennt ist.

LineBreak

LineBreak bewirkt einen Zeilenumbruch im Flussinhalt. Das folgende Beispiel veranschaulicht die Verwendung von LineBreak.

<FlowDocument xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
  <Paragraph>
    Before the LineBreak in Paragraph.
    <LineBreak />
    After the LineBreak in Paragraph.
    <LineBreak/><LineBreak/>
    After two LineBreaks in Paragraph.
  </Paragraph>

  <Paragraph>
    <LineBreak/>
  </Paragraph>

  <Paragraph>
    After a Paragraph with only a LineBreak in it.
  </Paragraph>
</FlowDocument>

Der folgende Screenshot zeigt, wie dieses Beispiel gerendert wird.

Flussauflistungselemente

In vielen der obigen Beispiele werden die BlockCollection und InlineCollection verwendet, um den Inhalt des Flusses programmatisch zu erstellen. Um zum Beispiel Elemente zu einem Paragraph, hinzuzufügen, können Sie die Syntax verwenden:

myParagraph.Inlines.Add(new Run("Some text"));

Dies fügt ein Run zu dem InlineCollection der Paragraph hinzu. Dies ist dasselbe wie das implizite Run in einem Paragraph im Markup:

<Paragraph>
Some Text
</Paragraph>

Als Beispiel für die Verwendung von BlockCollection, erstellt das folgende Beispiel ein neues Section und verwendet dann die Methode Hinzufügen, um eine neue Paragraph dem Section-Inhalt hinzuzufügen.

Section secx = new Section();
secx.Blocks.Add(new Paragraph(new Run("A bit of text content...")));

Dim secx As New Section()
secx.Blocks.Add(New Paragraph(New Run("A bit of text content...")))

Neben dem Hinzufügen von Elementen zu einer Flussauflistung können Sie auch Elemente entfernen. Im folgenden Beispiel wird das letzte Inline-Element in Span gelöscht.

spanx.Inlines.Remove(spanx.Inlines.LastInline);

spanx.Inlines.Remove(spanx.Inlines.LastInline)

Das folgende Beispiel löscht den gesamten Inhalt (Inline-Elemente) aus Span.

spanx.Inlines.Clear();

spanx.Inlines.Clear()

Beim programmgesteuerten Arbeiten mit fortlaufendem Inhalt werden Sie diese Auflistungen wahrscheinlich häufig verwenden.

Ob ein Flowelement ein InlineCollection (Inlines) oder BlockCollection (Blocks) verwendet, um seine untergeordneten Elemente zu enthalten, hängt davon ab, welche Art von untergeordneten Elementen (Block oder Inline) vom übergeordneten Element enthalten werden können. Einschlussregeln für Flussinhaltselemente sind im Inhaltsschema im nächsten Abschnitt zusammengefasst.

Inhaltsschema

In Anbetracht der Anzahl verschiedener Flussinhaltselemente kann es überwältigend sein, den Überblick darüber zu behalten, welchen Typ von untergeordnetem Element ein Element einschließen kann. Das folgende Diagramm fasst die Einschlussregeln für Inhaltselemente zusammen. Die Pfeile stellen die möglichen Übergeordnet/Untergeordnet-Beziehungen dar.

Wie aus dem Diagramm oben ersichtlich ist, werden die für ein Element zulässigen untergeordneten Elemente nicht zwingend davon bestimmt, ob es sich um ein Block-Element oder ein Inline-Element handelt. Beispielsweise kann ein Span-Element (ein Inline-Element) nur untergeordnete Inline-Elemente enthalten, aber ein Figure-Element (auch ein Inline-Element) kann nur untergeordnete Block-Elemente aufweisen. Aus diesem Grund ist ein Diagramm nützlich, um schnell zu bestimmen, welches Element in einem anderen eingeschlossen sein kann. Verwenden wir die Abbildung beispielsweise dazu, zu bestimmen, wie der fortlaufende Inhalt einer RichTextBox-Klasse konstruiert wird.

1. Ein RichTextBox-Element muss ein FlowDocument enthalten, das wiederum ein von Block abgeleitetes Objekt enthalten muss. Im Folgenden finden Sie das entsprechende Segment aus dem Diagramm oben.

Bis jetzt könnte das Markup wie folgt aussehen.

<RichTextBox>
  <FlowDocument>
    <!-- One or more Block-derived object… -->
  </FlowDocument>
</RichTextBox>

2. Der Abbildung zufolge gibt es mehrere -Elemente zur Auswahl, darunter Block, Paragraph, Section, Table, List und BlockUIContainer (siehe „blockabgeleitete Klassen“ in der Abbildung oben). Angenommen, wir möchten ein Table-Element verwenden. Gemäß der Abbildung oben enthält ein Table-Element eine TableRowGroup, die TableRow-Elemente enthält, die wiederum TableCell-Elemente enthalten, die ein Block-abgeleitetes Objekt enthalten. Im Folgenden finden Sie das entsprechende Segment für Table aus dem Diagramm oben.

Im Folgenden finden Sie das entsprechende Markup.

<RichTextBox>
  <FlowDocument>
    <Table>
      <TableRowGroup>
        <TableRow>
          <TableCell>
            <!-- One or more Block-derived object… -->
          </TableCell>
        </TableRow>
      </TableRowGroup>
    </Table>
  </FlowDocument>
</RichTextBox>

3. Erneut ist mindestens ein Block-Element unter einem TableCell erforderlich. Um es einfach zu gestalten, fügen wir Text in die Zelle ein. Dazu können wir ein Paragraph-Element mit einem Run-Element verwenden. Im Folgenden werden die entsprechenden Segmente aus der Abbildung dargestellt, die zeigen, dass ein Paragraph ein Inline-Element annehmen kann und dass ein Run-Element (ein Inline-Element) ausschließlich Nur-Text annehmen kann.

Nachstehend finden Sie das gesamte Beispiel im Markup.

<Page xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
  <RichTextBox>
    <FlowDocument>
      
      <!-- Normally a table would have multiple rows and multiple
           cells but this code is for demonstration purposes.-->
      <Table>
        <TableRowGroup>
          <TableRow>
            <TableCell>
              <Paragraph>

                <!-- The schema does not actually require
                     explicit use of the Run tag in markup. It 
                     is only included here for clarity. -->
                <Run>Paragraph in a Table Cell.</Run>
              </Paragraph>
            </TableCell>
          </TableRow>
        </TableRowGroup>
      </Table>

    </FlowDocument>
  </RichTextBox>
</Page>

Anpassen von Text

In der Regel ist Text der am weitesten verbreitete Inhaltstyp in einem Flussdokument. Obwohl die oben eingeführten Objekte verwendet werden können, um die meisten Aspekte beim Rendern von Text zu steuern, gibt es einige andere Methoden zum Anpassen von Text, die in diesem Abschnitt abgedeckt werden.

Textverzierungen

Textverzierungen ermöglichen es Ihnen, die Effekte „Unterstreichen“, „Überstreichen“, „Grundlinie“ und „Durchgestrichen“ auf den Text anzuwenden (siehe Bilder unten). Diese Dekorationen werden mithilfe der TextDecorations-Eigenschaft hinzugefügt, die von einer Reihe von Objekten verfügbar gemacht wird, einschließlich Inline, Paragraph, TextBlock und TextBox.

Das folgende Beispiel veranschaulicht das Festlegen der TextDecorations-Eigenschaft einer Paragraph.

<FlowDocument ColumnWidth="200">
  <Paragraph TextDecorations="Strikethrough">
    This text will render with the strikethrough effect.
  </Paragraph>
</FlowDocument>

Paragraph parx = new Paragraph(new Run("This text will render with the strikethrough effect."));
parx.TextDecorations = TextDecorations.Strikethrough;

Dim parx As New Paragraph(New Run("This text will render with the strikethrough effect."))
parx.TextDecorations = TextDecorations.Strikethrough

Die folgende Abbildung zeigt, wie dieses Beispiel gerendert wird.

Der folgenden Abbildung wird wie die überlagernde Linie, Baseline, und Unterstreichen Ergänzungen zu rendern, bzw.

Typografie

Die Typography-Eigenschaft wird von den meisten flussbezogenen Inhalten verfügbar gemacht, einschließlich TextElement, FlowDocument, TextBlock und TextBox. Diese Eigenschaft wird verwendet, um typografische Eigenschaften/Variationen von Text (d.h. Kapitälchen oder Großbuchstaben, hoch- und tiefgestellter Text usw.) zu steuern.

Das folgende Beispiel zeigt, wie das Typography-Attribut gesetzt wird, wobei Paragraph als Beispielelement verwendet wird.

<Paragraph
  TextAlignment="Left"
  FontSize="18" 
  FontFamily="Palatino Linotype"
  Typography.NumeralStyle="OldStyle"
  Typography.Fraction="Stacked"
  Typography.Variants="Inferior"
>
  <Run>
    This text has some altered typography characteristics.  Note
    that use of an open type font is necessary for most typographic
    properties to be effective.
  </Run>
  <LineBreak/><LineBreak/>
  <Run>
    0123456789 10 11 12 13
  </Run>
  <LineBreak/><LineBreak/>
  <Run>
    1/2 2/3 3/4
  </Run>
</Paragraph>

Die folgende Abbildung zeigt, wie dieses Beispiel gerendert wird.

Im Gegensatz dazu zeigt die folgende Abbildung, wie ein ähnliches Beispiel mit typografischen Standardeigenschaften gerendert wird.

Das folgende Beispiel zeigt, wie Sie die Typography-Eigenschaft programmatisch einstellen können.

Paragraph par = new Paragraph();

Run runText = new Run(
    "This text has some altered typography characteristics.  Note" +
    "that use of an open type font is necessary for most typographic" +
    "properties to be effective.");
Run runNumerals = new Run("0123456789 10 11 12 13");
Run runFractions = new Run("1/2 2/3 3/4");

par.Inlines.Add(runText);
par.Inlines.Add(new LineBreak());
par.Inlines.Add(new LineBreak());
par.Inlines.Add(runNumerals);
par.Inlines.Add(new LineBreak());
par.Inlines.Add(new LineBreak());
par.Inlines.Add(runFractions);

par.TextAlignment = TextAlignment.Left;
par.FontSize = 18;
par.FontFamily = new FontFamily("Palatino Linotype");

par.Typography.NumeralStyle = FontNumeralStyle.OldStyle;
par.Typography.Fraction = FontFraction.Stacked;
par.Typography.Variants = FontVariants.Inferior;

Dim par As New Paragraph()

Dim runText As New Run("This text has some altered typography characteristics.  Note" & "that use of an open type font is necessary for most typographic" & "properties to be effective.")
Dim runNumerals As New Run("0123456789 10 11 12 13")
Dim runFractions As New Run("1/2 2/3 3/4")

par.Inlines.Add(runText)
par.Inlines.Add(New LineBreak())
par.Inlines.Add(New LineBreak())
par.Inlines.Add(runNumerals)
par.Inlines.Add(New LineBreak())
par.Inlines.Add(New LineBreak())
par.Inlines.Add(runFractions)

par.TextAlignment = TextAlignment.Left
par.FontSize = 18
par.FontFamily = New FontFamily("Palatino Linotype")

par.Typography.NumeralStyle = FontNumeralStyle.OldStyle
par.Typography.Fraction = FontFraction.Stacked
par.Typography.Variants = FontVariants.Inferior

Weitere Informationen zur Typografie finden Sie unter Typografie in WPF.

Siehe auch

• Text
• Typografie in WPF
• Artikel zu Vorgehensweisen
• Übersicht über das TextElement-Inhaltsmodell
• Übersicht über RichTextBox
• Dokumente in WPF
• Übersicht über Tabellen
• Übersicht über Anmerkungen