Udostępnij za pośrednictwem


Przegląd Dokument przepływu

Dokumenty przepływu zostały zaprojektowane pod kątem optymalizacji wyświetlania i czytelności. Zamiast ustawiać jeden wstępnie zdefiniowany układ, dokumenty przepływu dynamicznie dostosowują i zmieniają ich zawartość na podstawie zmiennych czasu wykonywania, takich jak rozmiar okna, rozdzielczość urządzenia i opcjonalne preferencje użytkownika. Ponadto dokumenty przepływu oferują zaawansowane funkcje dokumentów, takie jak stronicowanie i kolumny. Ten temat zawiera omówienie dokumentów przepływu i sposobu ich tworzenia.

Co to jest dokument przepływu

Dokument przepływu jest przeznaczony do "ponownego przepływu zawartości" w zależności od rozmiaru okna, rozdzielczości urządzenia i innych zmiennych środowiskowych. Ponadto dokumenty przepływu mają wiele wbudowanych funkcji, w tym wyszukiwanie, tryby wyświetlania, które optymalizują czytelność, oraz możliwość zmiany rozmiaru i wyglądu czcionek. Dokumenty przepływu najlepiej wykorzystać, gdy łatwość czytania jest podstawowym scenariuszem użycia dokumentów. Z kolei stałe dokumenty zostały zaprojektowane tak, aby prezentowała statyczną prezentację. Stałe dokumenty są przydatne, gdy wierność zawartości źródłowej jest niezbędna. Aby uzyskać więcej informacji na temat różnych typów dokumentów, zobacz Dokumenty w WPF .

Poniższa ilustracja przedstawia przykładowy dokument przepływu wyświetlany w kilku oknach o różnych rozmiarach. W miarę zmiany obszaru wyświetlania zawartość zmienia się, aby jak najlepiej wykorzystać dostępne miejsce.

Flow Document Content Reflow

Jak pokazano na powyższym obrazie, zawartość przepływu może zawierać wiele składników, w tym akapitów, list, obrazów i nie tylko. Te składniki odpowiadają elementom w znaczników i obiektach w kodzie proceduralnym. Omówimy te klasy szczegółowo w dalszej części sekcji Klasy powiązane z przepływem w tym omówieniu. Na razie oto prosty przykład kodu, który tworzy dokument przepływu składający się z akapitu z pogrubionym tekstem i listą.

<!-- 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

Na poniższej ilustracji przedstawiono wygląd tego fragmentu kodu.

Screenshot: Rendered FlowDocument example

W tym przykładzie kontrolka FlowDocumentReader jest używana do hostowania zawartości przepływu. Aby uzyskać więcej informacji na temat kontrolek hostingu zawartości przepływu, zobacz Flow Document Types (Typy dokumentów przepływu). Paragraphelementy , List, ListItemi Bold służą do kontrolowania formatowania zawartości na podstawie ich kolejności w adiustacji. Na przykład Bold element obejmuje tylko część tekstu w akapicie; w rezultacie tylko ta część tekstu jest pogrubiona. Jeśli używasz kodu HTML, będzie ci to znane.

Jak pokazano na powyższej ilustracji, istnieje kilka funkcji wbudowanych w dokumenty usługi Flow:

  • Wyszukiwanie: umożliwia użytkownikowi wykonywanie pełnotekstowego wyszukiwania całego dokumentu.

  • Tryb wyświetlania: użytkownik może wybrać preferowany tryb wyświetlania, w tym tryb przeglądania jednostronicowego (strona w czasie), tryb wyświetlania dwustronicowego (format czytania książki) oraz tryb przeglądania ciągłego przewijania (bez dołu). Aby uzyskać więcej informacji na temat tych trybów wyświetlania, zobacz FlowDocumentReaderViewingMode.

  • Kontrolki nawigacji strony: jeśli tryb wyświetlania dokumentu używa stron, kontrolki nawigacji stron zawierają przycisk umożliwiający przejście do następnej strony (strzałki w dół) lub poprzedniej strony (strzałki w górę), a także wskaźniki dla bieżącej liczby stron i łącznej liczby stron. Przerzucanie stron można również wykonać za pomocą klawiszy strzałek klawiatury.

  • Powiększenie: kontrolki powiększenia umożliwiają użytkownikowi zwiększenie lub zmniejszenie poziomu powiększenia, klikając odpowiednio przyciski plus lub minus. Kontrolki powiększenia zawierają również suwak do dostosowywania poziomu powiększenia. W celu uzyskania więcej informacji, zobacz następujący temat: Zoom.

Te funkcje można modyfikować na podstawie kontrolki używanej do hostowania zawartości przepływu. W następnej sekcji opisano różne kontrolki.

Typy dokumentów przepływu

Wyświetlanie zawartości dokumentu przepływu i jego wyświetlania zależy od tego, jaki obiekt jest używany do hostowania zawartości przepływu. Istnieją cztery kontrolki obsługujące wyświetlanie zawartości przepływu: FlowDocumentReader, , FlowDocumentPageViewerRichTextBoxi FlowDocumentScrollViewer. Te kontrolki zostały krótko opisane poniżej.

Uwaga

FlowDocument jest wymagany do bezpośredniego hostowania zawartości przepływu, więc wszystkie te kontrolki wyświetlania używają FlowDocument elementu w celu włączenia hostingu zawartości przepływu.

FlowDocumentReader

FlowDocumentReader Zawiera funkcje, które umożliwiają użytkownikowi dynamiczne wybieranie między różnymi trybami wyświetlania, w tym tryb wyświetlania jednostronicowego (page-at-a-time), dwustronicowego trybu wyświetlania (format czytania książki) oraz trybu przeglądania ciągłego przewijania (bez dołu). Aby uzyskać więcej informacji na temat tych trybów wyświetlania, zobacz FlowDocumentReaderViewingMode. Jeśli nie potrzebujesz możliwości dynamicznego przełączania się między różnymi trybami FlowDocumentPageViewer wyświetlania i FlowDocumentScrollViewer udostępniaj przeglądarki zawartości przepływu o lżejszym przepływie, które zostały naprawione w określonym trybie wyświetlania.

FlowDocumentPageViewer i FlowDocumentScrollViewer

FlowDocumentPageViewer Wyświetla zawartość w trybie wyświetlania strony w czasie, a zawartość FlowDocumentScrollViewer jest wyświetlana w trybie ciągłego przewijania. Oba FlowDocumentPageViewer elementy i FlowDocumentScrollViewer są stałe w określonym trybie wyświetlania. Porównaj z FlowDocumentReaderelementem , który zawiera funkcje, które umożliwiają użytkownikowi dynamiczne wybieranie różnych trybów wyświetlania (jak podano w wyliczenie FlowDocumentReaderViewingMode ), kosztem większej ilości zasobów niż FlowDocumentPageViewer lub FlowDocumentScrollViewer.

Domyślnie pionowy pasek przewijania jest zawsze wyświetlany, a poziomy pasek przewijania staje się widoczny w razie potrzeby. Domyślny interfejs użytkownika dla FlowDocumentScrollViewer elementu nie zawiera paska narzędzi, IsToolBarVisible jednak właściwość może służyć do włączenia wbudowanego paska narzędzi.

RichTextBox

Używasz elementu RichTextBox , gdy chcesz zezwolić użytkownikowi na edytowanie zawartości przepływu. Jeśli na przykład chcesz utworzyć edytor, który zezwolił użytkownikowi na manipulowanie elementami, takimi jak tabele, kursywa i pogrubienie itp., należy użyć elementu RichTextBox. Aby uzyskać więcej informacji, zobacz RichTextBox Overview (Omówienie kontrolki RichTextBox).

Uwaga

Zawartość przepływu wewnątrz elementu RichTextBox nie zachowuje się dokładnie tak, jak zawartość przepływu zawarta w innych kontrolkach. Na przykład nie ma żadnych kolumn w elemecie RichTextBox i dlatego nie ma automatycznego zachowania zmiany rozmiaru. Ponadto wbudowane funkcje zawartości przepływu, takie jak wyszukiwanie, tryb wyświetlania, nawigacja po stronie i powiększanie, nie są dostępne w obrębie RichTextBoxelementu .

Tworzenie zawartości przepływu

Zawartość przepływu może być złożona, składająca się z różnych elementów, w tym tekstu, obrazów, tabel, a nawet UIElement klas pochodnych, takich jak kontrolki. Aby zrozumieć, jak utworzyć złożoną zawartość przepływu, kluczowe są następujące kwestie:

  • Klasy związane z przepływem: każda klasa używana w zawartości przepływu ma określony cel. Ponadto hierarchiczna relacja między klasami przepływów ułatwia zrozumienie sposobu ich użycia. Na przykład klasy pochodzące z Block klasy są używane do zawierania innych obiektów, podczas gdy klasy pochodzące z Inline obiektów, które są wyświetlane.

  • Schemat zawartości: dokument przepływu może wymagać znacznej liczby zagnieżdżonych elementów. Schemat zawartości określa możliwe relacje nadrzędne/podrzędne między elementami.

W poniższych sekcjach bardziej szczegółowo omówimy poszczególne obszary.

Na poniższym diagramie przedstawiono obiekty najczęściej używane z zawartością przepływu:

Diagram: Flow content element class hierarchy

Do celów zawartości przepływu istnieją dwie ważne kategorie:

  1. Klasy pochodne blokowe: nazywane również "Blokuj elementy zawartości" lub po prostu "Elementy blokowe". Elementy dziedziczone z Block programu mogą służyć do grupowania elementów w ramach wspólnego elementu nadrzędnego lub stosowania wspólnych atrybutów do grupy.

  2. Klasy pochodne wbudowane: nazywane również "elementami zawartości wbudowanej" lub po prostu "Elementami wbudowanymi". Elementy dziedziczone z Inline elementu są zawarte w elemecie Blokuj lub innym elemblem wbudowanym. Wbudowane elementy są często używane jako bezpośredni kontener zawartości renderowanej na ekranie. Na przykład element Paragraph (Blokuj) może zawierać Run element (element wbudowany), ale Run faktycznie zawiera tekst renderowany na ekranie.

Każda klasa w tych dwóch kategoriach jest krótko opisana poniżej.

Klasy pochodne blokowe

Ustęp

Paragraph jest zwykle używana do grupowania zawartości w akapit. Najprostszym i najbardziej typowym zastosowaniem akapitu jest utworzenie akapitu tekstu.

<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

Można jednak również zawierać inne elementy pochodne śródwierszowo, jak pokazano poniżej.

Obszar

Section jest używany tylko do zawierania innych Block-pochodnych elementów. Nie stosuje żadnego domyślnego formatowania do elementów, które zawiera. Jednak wszystkie wartości właściwości ustawione na obiekcie Section mają zastosowanie do jej elementów podrzędnych. Sekcja umożliwia również programowe iterowanie po kolekcji podrzędnej. Section jest używany w podobny sposób do tagu <DIV> w kodzie HTML.

W poniższym przykładzie trzy akapity są definiowane w ramach jednego Section. Sekcja ma Background wartość właściwości Red, dlatego kolor tła akapitów jest również czerwony.

<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 umożliwia osadzanie UIElement elementów (tj. Button) w zawartości przepływu pochodnego bloku. InlineUIContainer (patrz poniżej) służy do osadzania UIElement elementów w zawartości przepływu wbudowanego. BlockUIContainer i InlineUIContainer są ważne, ponieważ nie ma innego sposobu używania UIElement zawartości przepływu, chyba że znajduje się w jednym z tych dwóch elementów.

W poniższym przykładzie pokazano, jak używać BlockUIContainer elementu do hostowania UIElement obiektów w ramach zawartości przepływu.

<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>

Na poniższej ilustracji przedstawiono sposób renderowania tego przykładu:

Screenshot that shows a UIElement embedded in flow content.

Lista

List służy do tworzenia listy punktowanej lub liczbowej. MarkerStyle Ustaw właściwość na TextMarkerStyle wartość wyliczenia, aby określić styl listy. W poniższym przykładzie pokazano, jak utworzyć prostą listę.

<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

Uwaga

List jest jedynym elementem przepływu, który używa elementu ListItemCollection do zarządzania elementami podrzędnym.

Tabela

Table służy do tworzenia tabeli. Table element jest podobny do Grid elementu, ale ma więcej możliwości i dlatego wymaga większego obciążenia związanego z zasobami. Ponieważ Grid jest elementem UIElement, nie można go używać w zawartości przepływu, chyba że znajduje się w BlockUIContainer obiekcie lub InlineUIContainer. Aby uzyskać więcej informacji na temat Tableprogramu , zobacz Omówienie tabeli.

Klasy pochodne wbudowane

Run

Run jest używany do zawierania niesformatowanych tekstu. Można oczekiwać Run , że obiekty będą szeroko używane w zawartości przepływu. Jednak w adiustacji Run elementy nie są wymagane do jawnego użycia. Run jest wymagane do użycia podczas tworzenia lub manipulowania dokumentami przepływu przy użyciu kodu. Na przykład w adiustacji poniżej pierwszy Paragraph określa Run element jawnie, podczas gdy drugi nie. Oba akapity generują identyczne dane wyjściowe.

<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>

Uwaga

Począwszy od programu .NET Framework 4, Text właściwość Run obiektu jest właściwością zależności. Właściwość można powiązać Text ze źródłem danych, takim jak TextBlock. Właściwość Text w pełni obsługuje powiązanie jednokierunkowe. Właściwość Text obsługuje również powiązanie dwukierunkowe, z wyjątkiem RichTextBox. Przykład można znaleźć w temacie Run.Text.

Span

Span grupuje inne elementy zawartości wbudowanej. Nie zastosowano żadnego nieodłącznego renderowania do zawartości w elementu Span . Jednak elementy dziedziczone z Span dołączania Hyperlink, BoldItalic i Underline mają zastosowanie formatowania do tekstu.

Poniżej znajduje się przykład zawartości wbudowanej zawierającej Span tekst, Bold element i element Button.

<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>

Poniższy zrzut ekranu przedstawia sposób renderowania tego przykładu.

Screenshot: Rendered Span example

Inlineuicontainer

InlineUIContainer umożliwia osadzanie UIElement elementów (np. kontrolki takiej jak Button) w elemecie Inline zawartości. Ten element jest wbudowanym odpowiednikiem BlockUIContainer opisanym powyżej. Poniżej znajduje się przykład używany InlineUIContainer do wstawiania śródliniowego Button elementu w elemecie 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

Uwaga

InlineUIContainer nie musi być używana jawnie w adiustacji. Jeśli go pominiesz, InlineUIContainer zostanie on utworzony mimo to, gdy kod zostanie skompilowany.

Rysunek i zmiennoprzecinkowy

Figure i Floater służą do osadzania zawartości w dokumentach usługi Flow z właściwościami umieszczania, które można dostosować niezależnie od podstawowego przepływu zawartości. Figure lub Floater elementy są często używane do wyróżniania lub podkreślania fragmentów zawartości, hostowania obrazów pomocniczych lub innej zawartości w głównym przepływie zawartości lub do wstrzykiwania luźno powiązanej zawartości, takiej jak reklamy.

W poniższym przykładzie pokazano, jak osadzić element Figure w akapicie tekstu.

<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

Na poniższej ilustracji przedstawiono sposób renderowania tego przykładu.

Screenshot: Figure example

Figure i Floater różnią się na kilka sposobów i są używane w różnych scenariuszach.

Rysunek:

  • Można ustawić jego kotwice poziome i pionowe, aby zadokować je względem strony, zawartości, kolumny lub akapitu. Można również użyć jej HorizontalOffset właściwości i VerticalOffset , aby określić dowolne przesunięcia.

  • Można rozłożyć na więcej niż jedną kolumnę: możesz ustawić Figure wysokość i szerokość na wielokrotność stron, zawartości lub wysokości lub szerokości kolumny. Należy pamiętać, że w przypadku strony i zawartości wielokrotności większe niż 1 są niedozwolone. Na przykład można ustawić szerokość wartości Figure "0,5 page" lub "0,25 content" lub "2 Column". Możesz również ustawić wysokość i szerokość na bezwzględne wartości pikseli.

  • Nie stronicuje: jeśli zawartość wewnątrz elementu Figure nie mieści się wewnątrz Figureelementu , będzie renderować zawartość, która pasuje, a pozostała zawartość zostanie utracona

Floater:

  • Nie można ustawić pozycji i będzie renderować wszędzie tam, gdzie można udostępnić miejsce. Nie można ustawić przesunięcia ani zakotwiczenia Floater.

  • Nie można mieć rozmiaru do więcej niż jednej kolumny: domyślnie Floater rozmiary w jednej kolumnie. Ma Width właściwość, którą można ustawić na wartość bezwzględną pikseli, ale jeśli ta wartość jest większa niż jedna szerokość kolumny, jest ignorowana, a zmiennoprzecinkowy ma rozmiar w jednej kolumnie. Rozmiar można ustawić na mniejszą niż jedną kolumnę, ustawiając prawidłową szerokość pikseli, ale rozmiar nie jest względny w kolumnie, więc wyrażenie "0,5Column" nie jest prawidłowym wyrażeniem szerokości Floater . Floater nie ma właściwości height i nie można jej ustawić, a wysokość zależy od zawartości

  • Floater stronicowanie: jeśli jego zawartość o określonej szerokości rozciąga się na więcej niż 1 wysokość kolumny, podziały zmiennoprzecinkowe i podziały na strony do następnej kolumny, następna strona itp.

Figure jest dobrym miejscem do umieszczania autonomicznej zawartości, w której chcesz kontrolować rozmiar i pozycjonowanie, i masz pewność, że zawartość będzie mieścić się w określonym rozmiarze. Floater jest dobrym miejscem, aby umieścić bardziej swobodnie przepływającą zawartość, która przepływa podobnie do zawartości strony głównej, ale jest oddzielona od niej.

Linebreak

LineBreak powoduje wystąpienie podziału wiersza w zawartości przepływu. W poniższym przykładzie pokazano użycie metody 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>

Poniższy zrzut ekranu przedstawia sposób renderowania tego przykładu.

Screenshot: LineBreak example

Elementy kolekcji przepływów

W wielu powyższych przykładach element BlockCollection i InlineCollection służy do programowego konstruowania zawartości przepływu. Aby na przykład dodać elementy do Paragraphelementu , możesz użyć składni :

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

Spowoduje to dodanie elementu Run do InlineCollection elementu Paragraph. Jest to takie samo, jak niejawne Run znalezione wewnątrz Paragraph znaczników:

<Paragraph>
Some Text
</Paragraph>

Jako przykład użycia metody , BlockCollectionponiższy przykład tworzy nowy Section , a następnie używa metody Add , aby dodać nową Paragraph do Section zawartości.

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...")))

Oprócz dodawania elementów do kolekcji przepływów można również usuwać elementy. Poniższy przykład usuwa ostatni Inline element w pliku Span.

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

Poniższy przykład czyści całą zawartość (Inline elementy) z elementu Span.

spanx.Inlines.Clear();
spanx.Inlines.Clear()

Podczas pracy z zawartością przepływu programowo będziesz prawdopodobnie korzystać z tych kolekcji.

Niezależnie od tego, czy element przepływu używa InlineCollection elementu (wbudowanego) lub BlockCollection (Bloki) do zawierania elementów podrzędnych, zależy od typu elementów podrzędnych (Block lub Inline) zawartych przez element nadrzędny. Reguły zawierania elementów zawartości przepływu są sumowane w schemacie zawartości w następnej sekcji.

Uwaga

Istnieje trzeci typ kolekcji używany z zawartością przepływu, ListItemCollectionale ta kolekcja jest używana tylko z elementem List. Ponadto istnieje kilka kolekcji używanych z Tableprogramem . Aby uzyskać więcej informacji, zobacz Omówienie tabeli.

Schemat zawartości

Biorąc pod uwagę liczbę różnych elementów zawartości przepływu, może to być przytłaczające, aby śledzić, jaki typ elementów podrzędnych może zawierać element. Na poniższym diagramie przedstawiono podsumowanie reguł zawierania elementów przepływu. Strzałki reprezentują możliwe relacje nadrzędne/podrzędne.

Diagram: Flow content containment schema

Jak widać na powyższym diagramie, elementy podrzędne dozwolone dla elementu nie muszą być określane przez to, czy jest Block to element, czy Inline element. Na przykład element Span (element Inline ) może mieć Inline tylko elementy podrzędne, a Figure element (również Inline element) może zawierać Block tylko elementy podrzędne. W związku z tym diagram jest przydatny do szybkiego określania, który element może być zawarty w innym. Na przykład użyjemy diagramu, aby określić sposób konstruowania zawartości przepływu obiektu RichTextBox.

1. Element RichTextBox musi zawierać element FlowDocument , który z kolei musi zawierać Blockobiekt pochodny. Poniżej znajduje się odpowiedni segment z powyższego diagramu.

Diagram: RichTextBox containment rules

Do tej pory tak może wyglądać znaczniki.

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

2. Zgodnie z diagramem istnieje kilka Block elementów do wyboru, w tym Paragraph, Section, Table, Listi BlockUIContainer (zobacz Klasy pochodne blokowe powyżej). Załóżmy, że chcemy .Table Zgodnie z powyższym diagramem element Table zawiera TableRowGroup zawierające TableRow elementy, które zawierają elementy, które zawierają BlockTableCell obiekt pochodny. Poniżej znajduje się odpowiedni segment dla Table pobranego z powyższego diagramu.

Diagram: Parent/child schema for Table

Poniżej znajduje się odpowiedni znacznik.

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

3. Ponownie co najmniej jeden Block element jest wymagany pod elementem TableCell. Aby ułatwić sobie to, umieśćmy jakiś tekst w komórce. Możemy to zrobić przy użyciu Paragraph elementu z elementem Run . Poniżej przedstawiono odpowiednie segmenty z diagramu pokazujące, że Paragraph element może przyjmować element i że Run (Inlineelement) może przyjmować Inline zwykły tekst.

Diagram: Parent/child schema for Paragraph

Diagram: Parent/Child schema for Run

Poniżej znajduje się cały przykład w adiustacji.

<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>

Dostosowywanie tekstu

Zazwyczaj tekst jest najbardziej rozpowszechnionym typem zawartości w dokumencie przepływu. Chociaż obiekty wprowadzone powyżej mogą służyć do kontrolowania większości aspektów renderowania tekstu, istnieją inne metody dostosowywania tekstu, które zostały omówione w tej sekcji.

Dekoracje tekstu

Dekoracje tekstu umożliwiają stosowanie efektów podkreślenia, podkreślenia, linii bazowej i przekreślenia do tekstu (zobacz obrazy poniżej). Te dekoracje są dodawane przy użyciu TextDecorations właściwości uwidocznionej przez wiele obiektów, w tym Inline, Paragraph, TextBlocki TextBox.

W poniższym przykładzie pokazano, jak ustawić TextDecorations właściwość 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

Na poniższej ilustracji przedstawiono sposób renderowania tego przykładu.

Screenshot: Text with default strikethrough effect

Na poniższych ilustracjach pokazano, jak są renderowane odpowiednio dekoracje Overline, Baseline i Underline .

Screenshot: Overline TextDecorator

Screenshot: Default baseline effect on text

Screenshot: Text with default underline effect

Typografia

Właściwość Typography jest udostępniana przez większość zawartości związanych z przepływem, w tym TextElement, FlowDocument, TextBlocki TextBox. Ta właściwość służy do kontrolowania cech typograficznych/odmian tekstu (np. małych lub dużych limitów, tworzenia indeksów górnych i indeksów dolnych itp.).

W poniższym przykładzie pokazano, jak ustawić Typography atrybut przy użyciu Paragraph jako przykładowego elementu.

<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>

Na poniższej ilustracji przedstawiono sposób renderowania tego przykładu.

Screenshot showing text with altered typography.

Z kolei na poniższej ilustracji przedstawiono sposób renderowania podobnego przykładu z domyślnymi właściwościami typograficzne.

Screenshot showing text with default typography.

W poniższym przykładzie pokazano, jak programowo ustawić Typography właściwość.

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

Zobacz Typografia w WPF , aby uzyskać więcej informacji na temat typografii.

Zobacz też