Folyamatdokumentum áttekintése

A folyamatdokumentumok a megtekintés és az olvashatóság optimalizálására szolgálnak. Ahelyett, hogy egy előre definiált elrendezésre állítaná be, a folyamatdokumentumok dinamikusan módosítják és újrafuttatják a tartalmat a futásidejű változók, például az ablakméret, az eszközfeloldás és az opcionális felhasználói beállítások alapján. A folyamatdokumentumok emellett speciális dokumentumszolgáltatásokat is kínálnak, például lapozást és oszlopokat. Ez a témakör áttekintést nyújt a folyamatdokumentumokról és azok létrehozásának módjáról.

Mi az a folyamatdokumentum?

A folyamatdokumentumok az ablak méretétől, az eszköz felbontásától és más környezeti változóktól függően "újrarendelik a tartalmat". Emellett a folyamatdokumentumok számos beépített funkcióval rendelkeznek, beleértve a keresést, az olvashatóságot optimalizáló megtekintési módokat, valamint a betűtípusok méretének és megjelenésének módosítását. A folyamatdokumentumok akkor használhatók a legjobban, ha az egyszerű olvasás az elsődleges dokumentumhasználati forgatókönyv. Ezzel szemben a Rögzített dokumentumok statikus bemutatóhoz vannak tervezve. A rögzített dokumentumok akkor hasznosak, ha a forrástartalom megbízhatósága elengedhetetlen. A különböző típusú dokumentumokkal kapcsolatos további információkért tekintse meg a WPF dokumentumait .

Az alábbi ábrán egy több különböző méretű ablakban megtekintett folyamatábra-mintadokumentum látható. A megjelenítési terület változásakor a tartalom újrarendezi a rendelkezésre álló területet, hogy a lehető legjobban kihasználhassa azt.

Ahogy a fenti képen látható, a folyamat tartalma számos összetevőt tartalmazhat, beleértve a bekezdéseket, listákat, képeket és egyebeket. Ezek az összetevők a korrektúra elemeinek és az eljárási kód objektumainak felelnek meg. Ezeket az osztályokat az áttekintés Folyamattal kapcsolatos osztályok szakaszában tekintjük át részletesen. Egyelőre egy egyszerű példakód, amely egy bekezdésből álló folyamatdokumentumot hoz létre félkövér szöveggel és egy listával.

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

Az alábbi ábrán látható, hogy néz ki ez a kódrészlet.

Ebben a példában a FlowDocumentReader vezérlő a folyamat tartalmának üzemeltetésére szolgál. A folyamattartalom-üzemeltetési vezérlőkkel kapcsolatos további információkért tekintse meg a folyamatdokumentum-típusokat . Paragraph, List, ListItemés Bold az elemek a tartalomformázás szabályozására szolgálnak a korrektúra sorrendje alapján. Az elem például a Bold bekezdés szövegének csak egy részére terjed ki, ezért csak a szövegnek az adott része félkövér. Ha már használt HTML-t, ez ismerős lesz.

Ahogy a fenti ábrán is látható, a Flow Documents számos funkcióval rendelkezik:

• Keresés: Lehetővé teszi, hogy a felhasználó teljes szöveges keresést végezzen egy teljes dokumentumon.

• Megtekintési mód: A felhasználó kiválaszthatja az előnyben részesített megtekintési módot, beleértve az egyoldalas (oldal-at-a-time) megjelenítési módot, a kétoldalas megjelenítési módot (könyvolvasási formátum) és a folyamatos görgetési (feneketlen) megjelenítési módot. További információ ezekről a megtekintési módokról: FlowDocumentReaderViewingMode.

• Oldalnavigációs vezérlők: Ha a dokumentum megjelenítési módja oldalakat használ, a lapnavigációs vezérlők között szerepel egy gomb, amely a következő oldalra (a lefelé mutató nyílra) vagy az előző oldalra (a felfelé mutató nyílra) ugrik, valamint az aktuális oldalszám és az oldalak teljes számának mutatói. Az oldalak között való tükrözés a billentyűzet nyílbillentyűivel is elvégezhető.

• Nagyítás: A nagyítási vezérlők lehetővé teszik, hogy a felhasználó a plusz vagy mínusz gombokra kattintva növelje vagy csökkentse a nagyítási szintet. A nagyítási vezérlők egy csúszkát is tartalmaznak a nagyítási szint beállításához. További információért lásd Zoom.

Ezek a funkciók a folyamat tartalmának üzemeltetéséhez használt vezérlő alapján módosíthatók. A következő szakasz a különböző vezérlőket ismerteti.

Folyamatdokumentum-típusok

A folyamatdokumentum tartalmának és megjelenésének megjelenítése a folyamattartalom üzemeltetéséhez használt objektumtól függ. A folyamattartalom megtekintését négy vezérlő támogatja: FlowDocumentReader, FlowDocumentPageViewer, RichTextBoxés FlowDocumentScrollViewer. Ezeket a vezérlőket röviden az alábbiakban ismertetjük.

Megjegyzés:

FlowDocument szükséges a folyamattartalom közvetlen fogadásához, így ezek a megtekintési vezérlők mindegyike egy FlowDocument-t fogyaszt, amely lehetővé teszi a folyamattartalom fogadását.

FlowDocumentReader

FlowDocumentReader Olyan funkciókat tartalmaz, amelyek lehetővé teszik a felhasználó számára, hogy dinamikusan válasszon a különböző megjelenítési módok közül, beleértve az egyoldalas (lap-at-a-time) megjelenítési módot, a kétoldalas (könyvolvasási formátum) megjelenítési módot és a folyamatos görgetési (alulról lefelé nem álló) megjelenítési módot. További információ ezekről a megtekintési módokról: FlowDocumentReaderViewingMode. Ha nincs szüksége arra, hogy dinamikusan váltson a különböző megjelenítési módok között, a FlowDocumentPageViewer és a FlowDocumentScrollViewer kisebb erőforrás-igényű tartalommegjelenítőket biztosítanak, amelyek egy adott megjelenítési módban rögzítettek.

FlowDocumentPageViewer és FlowDocumentScrollViewer

FlowDocumentPageViewer A tartalmakat lapozási módban jeleníti meg, míg FlowDocumentScrollViewer a tartalmat folyamatos görgetési módban jeleníti meg. Mindkettő FlowDocumentPageViewer , és FlowDocumentScrollViewer egy adott megtekintési módhoz van rögzítve. FlowDocumentReaderHasonlítsa össze azokkal a funkciókkal, amelyek lehetővé teszik a felhasználó számára, hogy dinamikusan válasszon a különböző megtekintési módok közül (az FlowDocumentReaderViewingMode enumerálás által biztosítottak szerint), annak árán, hogy erőforrás-igényesebb, mint FlowDocumentPageViewer vagy FlowDocumentScrollViewer.

Alapértelmezés szerint mindig megjelenik egy függőleges görgetősáv, és szükség esetén egy vízszintes görgetősáv is láthatóvá válik. Az alapértelmezett felhasználói felület FlowDocumentScrollViewer nem tartalmaz eszköztárat, IsToolBarVisible a tulajdonság azonban a beépített eszköztár engedélyezésére használható.

Rich szövegdoboz

Ha engedélyezni szeretné a felhasználónak a folyamattartalom szerkesztését, használja a RichTextBox-t. Ha például olyan szerkesztőt szeretne létrehozni, amely lehetővé teszi a felhasználó számára a táblázatok, dőlt és félkövér formázás stb RichTextBox. További információt a RichTextBox áttekintésében talál.

Megjegyzés:

A RichTextBox belüli folyamattartalmak nem viselkednek pontosan úgy, mint a más vezérlőkben található folyamattartalmak. Például a RichTextBox formátumban nincsenek oszlopok, és ezért nincs automatikus átméretezési viselkedés. Emellett a folyamattartalmak jellemzően beépített funkciói, például a keresés, a megtekintési mód, a lapnavigáció és a nagyítás nem érhetők el egy RichTextBoxadott területen belül.

Folyamatos tartalom létrehozása

A folyamat tartalma összetett lehet, amely különböző elemekből, például szövegből, képekből, táblázatokból és akár UIElement származtatott osztályokból, például vezérlőkből áll. Az összetett folyamattartalom létrehozásának megértéséhez a következő pontok kritikus fontosságúak:

• Folyamattal kapcsolatos osztályok: A folyamattartalmakban használt minden osztálynak meghatározott célja van. Emellett a folyamatosztályok közötti hierarchikus kapcsolat segít megérteni a használatuk módját. Az Block osztályból származtatott osztályokat például más objektumok tárolására használják, míg a Inline osztályból származtatott osztályok a megjelenített objektumokat tartalmazzák.

• Tartalomséma: A folyamatdokumentumok jelentős számú beágyazott elemet igényelhetnek. A tartalomséma az elemek közötti lehetséges szülő-gyermek kapcsolatokat határozza meg.

A következő szakaszok részletesebben ismertetik ezeket a területeket.

Folyamattal kapcsolatos osztályok

Az alábbi ábrán a folyamattartalommal leggyakrabban használt objektumok láthatók:

A folyamattartalom szempontjából két fontos kategória van:

1. Blokkalapú osztályok: Más néven "Tartalomelemek blokkolása" vagy csak "Blokkelemek". Az öröklődő Block elemek felhasználhatók a közös szülő elemeinek csoportosítására vagy a közös attribútumok csoportra való alkalmazására.

2. Beágyazott osztályok: "Beágyazott tartalomelemeknek" vagy csak "beágyazott elemeknek" is nevezik. Azok az elemek, amelyektől öröklődnek Inline , egy blokkelemben vagy egy másik beágyazott elemben találhatók. A beágyazott elemeket gyakran használják a képernyőre renderelt tartalom közvetlen tárolójaként. Például egy Paragraph (Blokkelem) tartalmazhat egy Run (Beágyazott Elem), de valójában a Run tartalmazza a képernyőn megjelenített szöveget.

A két kategória minden osztályát röviden ismertetjük az alábbiakban.

Blokkalapú osztályok

bekezdés

Paragraph általában egy bekezdésbe csoportosítja a tartalmat. A Bekezdés legegyszerűbb és leggyakoribb használata egy szöveg bekezdésének létrehozása.

<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

Az alábbiakban látható módon azonban más beágyazott elemeket is tartalmazhat.

Szakasz

Section csak más Blockszármaztatott elemeket tartalmaz. Nem alkalmazza az alapértelmezett formázást a benne található elemekre. A megadott Section tulajdonságértékek azonban a gyermekelemekre vonatkoznak. A szakaszok lehetővé teszik a gyermekgyűjtemény programozott módon történő iterálását is. Section a HTML-ben a <DIV> címkéhez hasonlóan használható.

Az alábbi példában három bekezdés van egy Section alá definiálva. A szakasz Background tulajdonságértéke Piros, ezért a bekezdések háttérszíne is piros.

<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 lehetővé teszi UIElement az elemek (például a Button) blokkalapú folyamattartalmakba való beágyazását. A InlineUIContainer elemek beágyazására származtatott folyamattartalomként az UIElement (lásd alább) szolgál. BlockUIContainer és InlineUIContainer fontosak, mert nincs más mód a folyamatban lévő tartalom használatára UIElement , kivéve, ha az e két elem egyikében található.

Az alábbi példa bemutatja, hogyan használhatja a BlockUIContainer elemet UIElement objektumok üzemeltetésére áramlásos tartalom keretein belül.

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

Az alábbi ábra a példa megjelenítését mutatja be:

Lista

List felsorolásjeles vagy numerikus lista létrehozásához használható. Az MarkerStyle tulajdonságot állítsa be egy TextMarkerStyle enumerációs értékre a lista stílusának meghatározásához. Az alábbi példa bemutatja, hogyan hozhat létre egyszerű listát.

<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

Megjegyzés:

List az egyetlen folyamatelem, amely a ListItemCollection gyermekelemek kezelésére használja.

Tábla

Table tábla létrehozásához használható. Table hasonló az Grid elemhez, de több képességekkel rendelkezik, ezért nagyobb erőforrás-többletterhelést igényel. Mivel a Grid egy UIElement, nem használható folyamatos tartalomban, hacsak nem tartalmazza egy BlockUIContainer vagy InlineUIContainer. További információkért Tablelásd a Táblázat áttekintése című témakört.

Beágyazott osztályok

Fut

Run formázatlan szöveget tartalmaz. Előfordulhat, hogy az Run objektumokat széles körben használják a folyamat tartalmában. Azonban jelölőnyelvben a Run elemeket nem szükséges kifejezetten használni. Run a folyamatdokumentumok kóddal történő létrehozásakor vagy módosításakor kell használni. Az alábbi korrektúrában például az első Paragraph explicit módon adja meg az Run elemet, míg a második nem. Mindkét bekezdés azonos kimenetet eredményez.

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

Megjegyzés:

A .NET-keretrendszer 4-től kezdve az TextRun objektum tulajdonsága függőségi tulajdonság. A Text tulajdonságot hozzá tudja kötni egy adatforráshoz, például egy TextBlock-hez. A Text tulajdonság teljes mértékben támogatja az egyirányú kötést. A Text tulajdonság támogatja a kétirányú kötést is, kivéve a RichTextBox. Példaként tekintse meg a Run.Text-t.

Átível

Span más beágyazott tartalomelemeket csoportosít. Az Span elemben lévő tartalomra nem alkalmaznak alapértelmezett renderelést. Azonban azok az elemek, amelyek öröklődnek a Span elemről, beleértve a Hyperlink, Bold, Italic és Underline elemeket, formázást alkalmaznak a szövegre.

Az alábbiakban egy példa látható, ahol egy Span tartalmaz beágyazott tartalmat, beleértve a szöveget, egy Bold elemet és egy 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>

Az alábbi képernyőképen látható, hogyan jelenik meg ez a példa.

InlineUIContainer

InlineUIContainer lehetővé teszi az olyan UIElement elemeket (például egy Button vezérlőt), hogy be legyenek ágyazva egy Inline tartalomelembe. Ez az elem a fent leírtaknak BlockUIContainer megfelelő beágyazott elem. Az alábbiakban egy példa látható, amely InlineUIContainer használ a Button beágyazására egy Paragraph-be.

<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

Megjegyzés:

InlineUIContainer nem szükséges explicit módon használni a korrektúrában. Ha azt kihagyja, a kód lefordításakor automatikusan létrejön egy InlineUIContainer.

Ábra és lebegő

Figure és Floater olyan tartalom beágyazására szolgálnak a Flow-dokumentumokban, amelyek elhelyezési tulajdonságai az elsődleges tartalomfolyamtól függetlenül testre szabhatók. Figure vagy Floater elemeket gyakran használnak a tartalom egyes részeinek kiemelésére vagy kiemelésére, támogató képek vagy más tartalmak tárolására a fő tartalomfolyamaton belül, vagy lazán kapcsolódó tartalmak, például hirdetések beszúrására.

A következő példa bemutatja, hogyan ágyazhat be egy Figure-t szöveges bekezdésbe.

<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

Az alábbi ábra bemutatja, hogyan jelenik meg ez a példa.

Figure és Floater többféleképpen is különböznek, és különböző forgatókönyvekhez használják.

Ábra:

• Elhelyezhető: Beállíthatja annak vízszintes és függőleges horgonyait úgy, hogy az oldalhoz, tartalomhoz, oszlophoz vagy bekezdéshez képest rögzítse. Az ő HorizontalOffset és VerticalOffset tulajdonságainak használatával tetszőleges eltolásokat is megadhat.

• Több oszlopra méretezhető: A magasságot és a szélességet több oldalra, tartalomra vagy oszlopmagasságra vagy szélességre állíthatja Figure be. Vegye figyelembe, hogy oldal és tartalom esetén az 1-nél nagyobb többszörösök nem engedélyezettek. Beállíthatja Figure például a "0,5 oldal" vagy a "0,25 tartalom" vagy a "2 oszlop" szélességet. A magasságot és a szélességet is beállíthatja abszolút képpontértékekként.

• Nem lapoz: Ha a tartalom Figure nem fér el a Figurebelső részen belül, akkor az bármilyen tartalmat megjelenít, és a fennmaradó tartalom elveszik

Lebegő:

• Nem helyezhető el, és ott jelenik meg, ahol szabad hely áll rendelkezésre. Nem állítható be az eltolás vagy a horgony a Floater számára.

• Nem méretezhető egynél több oszlopra: Alapértelmezés szerint Floater egy oszlop méretei. Van egy Width tulajdonsága, amely beállítható abszolút képpontértékre, de ha ez az érték nagyobb egy oszlopszélességnél, az értéket figyelmen kívül hagyják, és az úszó mérete egy oszlopszélességnyi lesz. A megfelelő képpontszélesség beállításával méretezhető egy oszlopnál kisebbre, de a méretezés nem oszlophoz viszonyított, ezért a "0,5Column" nem érvényes kifejezés a szélességhez Floater . Floater nincs magasság tulajdonsága, és a magasság nem állítható be, a magasság a tartalomtól függ

• Floater oldalakra bont: Ha a tartalma a megadott szélességnél meghaladja egy oszlop magasságát, a lebegő elválasztások megszakadnak, és a következő oszlopban vagy oldalon folytatódnak stb.

Figure jó hely önálló tartalmak elhelyezésére, ahol szabályozni szeretné a méretet és a elhelyezést, és biztos abban, hogy a tartalom a megadott méretben fog elférni. Floater jó hely arra, hogy a főoldal tartalmához hasonló, de attól elválasztott, szabadon áramló tartalmakat helyezzen el.

LineBreak

LineBreak sortörést okoz a folytonos tartalomnál. Az alábbi példa bemutatja a LineBreak használatát.

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

Az alábbi képernyőképen látható, hogyan jelenik meg ez a példa.

Folyamatgyűjtemény elemei

A fenti példák közül sokban a BlockCollectionInlineCollection folyamattartalom programozott módon történő létrehozására szolgálnak. Ha például elemeket szeretne hozzáadni egy Paragraphadott elemhez, használhatja a szintaxist:

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

Ez hozzáad egy Run-t a InlineCollectionParagraph-hoz. Ez ugyanaz, mint az implicit Run , amely egy Paragraph korrektúrában található:

<Paragraph>
Some Text
</Paragraph>

Példaként a BlockCollection használatára, az alábbi példa létrehoz egy új Section-t, majd a Hozzáadás metódussal hozzáad egy új Paragraph-t a Section tartalmához.

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

Amellett, hogy elemeket ad hozzá egy folyamatgyűjteményhez, az elemeket is eltávolíthatja. Az alábbi példa törli a Inlineutolsó Span elemét.

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

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

Az alábbi példa az összes tartalmat (Inline elemeket) törli a Span-ből.

spanx.Inlines.Clear();

spanx.Inlines.Clear()

Ha programozott módon dolgozik a folyamattartalomon, valószínűleg széles körben használja ezeket a gyűjteményeket.

Az, hogy egy folyamatelem InlineCollection (Inline) vagy BlockCollection (Blokk) segítségével tartalmazza a gyermekelemeit, attól függ, hogy a szülő milyen típusú gyermekelemeket (Block vagy Inline) tartalmazhat. A folyamattartalom-elemekre vonatkozó elszigetelési szabályokat a következő szakaszban található tartalomséma foglalja össze.

Megjegyzés:

Van egy harmadik típusú gyűjtemény, amelyet a folyam tartalommal használnak, a ListItemCollection, de ezt a gyűjteményt csak egy List-val/-vel használják. Emellett számos gyűjteményt is használnak.Table További információt a Táblázat áttekintése című témakörben talál.

Tartalomséma

A különböző folyamattartalom-elemek száma miatt nehéz nyomon követni, hogy az elemek milyen típusú gyermekelemeket tartalmazhatnak. Az alábbi diagram összefoglalja a folyamatelemekre vonatkozó elszigetelési szabályokat. A nyilak a lehetséges szülő-gyermek kapcsolatokat jelölik.

Ahogy a fenti ábrán látható, az elemekhez engedélyezett gyermekeket nem feltétlenül határozza meg, hogy Block elemről vagy Inline elemről van-e szó. Például egy Span (egy Inline elem) csak Inline gyermekelemekkel rendelkezhet, míg egy Figure (szintén egy Inline elem) csak Block gyermekelemekkel rendelkezhet. Ezért a diagramok segítségével gyorsan meghatározható, hogy egy másik elem milyen elemet tartalmazhat. Példaként használjuk a diagramot annak meghatározására, hogy miként hozhat létre folyamattartalmat egy RichTextBox.

1. Az RichTextBox tartalmaznia kell egy FlowDocument, amelynek viszont egy Block származtatott objektumot kell tartalmaznia. Az alábbiakban a fenti diagram megfelelő szegmense látható.

Eddig így nézhet ki a jelölés.

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

2. A diagram szerint több Block elem közül lehet választani, beleértve Paragrapha , Section, Table, Listés BlockUIContainer (lásd a blokkalapú osztályokat fent). Tegyük fel, hogy egy Table. A fenti Table diagram szerint egy Table tartalmaz egy TableRow-et, amely TableCell elemeket tartalmaz, és ezek Block elemeket tartalmaznak, amelyek egy -származtatott objektumot tartalmaznak. A diagram fenti részéből vett megfelelő szegmens látható alább Table formában.

Az alábbiakban látható a megfelelő jelölés.

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

3. Ismét egy vagy több Block elem szükséges egy TableCell alá. Az egyszerűség érdekében helyezzük el a szöveget a cellába. A Paragraph egy Run elemmel használva végezhetjük el ezt. Az alábbiakban a diagram megfelelő szegmensei láthatók, amelyek azt mutatják, hogy egy Paragraph elem el tud venni egy Inline elemet, és hogy egy Run (elem Inline ) csak egyszerű szöveget vehet fel.

Az alábbiakban a teljes példa látható jelölőnyelvben.

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

Szöveg testreszabása

A folyamatdokumentumokban általában a szöveg a leggyakoribb tartalomtípus. Bár a fent bemutatott objektumok a szöveg megjelenítésének legtöbb aspektusát szabályozhatják, a jelen szakaszban szereplő szöveg testreszabására más módszerek is vonatkoznak.

Szövegdekorációk

A szövegdekorációk lehetővé teszik az aláhúzás, a túlvonal, az alapvonal és az áthúzás effektusok szövegre való alkalmazását (lásd az alábbi képeket). Ezeket a dekorációkat azokkal a TextDecorations tulajdonsággal adják hozzá, amelyeket számos objektum tesz elérhetővé, köztük Inline, Paragraph, TextBlock, és TextBox.

Az alábbi példa bemutatja, hogyan állíthatja be a TextDecorations tulajdonságát egy 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

Az alábbi ábra bemutatja, hogyan jelenik meg ez a példa.

Az alábbi ábrák azt mutatják be, hogyan jelennek meg a Felülvonal, az Alapterv és az Aláhúzás dekorációk.

Tipográfia

A Typography tulajdonságot a legtöbb folyamattal kapcsolatos tartalom közzéteszi, beleértve a TextElement, FlowDocument, TextBlock és a TextBox elemeket. Ez a tulajdonság a szöveg tipográfiai jellemzőinek vagy változatainak szabályozására szolgál (mint például kis- vagy nagybetűk, felső- és alsó indexek stb.).

Az alábbi példa bemutatja, hogyan állíthatja be a Typography attribútumot Paragraph mint példaelem használatával.

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

Az alábbi ábra bemutatja, hogyan jelenik meg ez a példa.

Ezzel szemben az alábbi ábra bemutatja, hogyan jelenik meg egy hasonló példa alapértelmezett tipográfiai tulajdonságokkal.

Az alábbi példa bemutatja, hogyan állíthatja be a Typography tulajdonságot programozott módon.

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

A tipográfiai adatokról további információt a WPF tipográfiájában talál.

Lásd még

• Szöveg
• Tipográfia a WPF-ben
• útmutató témakörök
• TextElement tartalommodell áttekintése
• RichTextBox áttekintése
• Dokumentumok a WPF-ben
• táblázat áttekintése
• Annotációk áttekintése