Sdílet prostřednictvím

Přehled dokumentu toku

  • Článek

Dokumenty toku jsou navržené tak, aby optimalizovaly zobrazování a čitelnost. Místo toho, aby byly nastaveny na jedno předdefinované rozložení, dokumenty toku dynamicky upravují a přeformátovávají svůj obsah na základě proměnných za běhu, jako je velikost okna, rozlišení zařízení a volitelné uživatelské předvolby. Dokumenty toku navíc nabízejí pokročilé funkce dokumentů, jako je stránkování a sloupce. Toto téma obsahuje přehled dokumentů toku a jejich vytvoření.

Co je dokument toku

Dokument pro plynulé zobrazení je navržený tak, aby přizpůsoboval obsah v závislosti na velikosti okna, rozlišení zařízení a dalších parametrech prostředí. Kromě toho mají dokumenty toku řadu integrovaných funkcí, včetně vyhledávání, zobrazení režimů, které optimalizují čitelnost a schopnost měnit velikost a vzhled písem. Dokumenty s plynulým tokem se nejlépe využívají, když je prioritou snadné čtení. Naproti tomu pevné dokumenty jsou navržené tak, aby měly statickou prezentaci. Pevné dokumenty jsou užitečné, když je důležitá věrnost zdrojového obsahu. Další informace o různých typech dokumentů najdete v tématu Dokumenty ve WPF.

Následující obrázek znázorňuje ukázkový dokument toku zobrazený v několika oknech různých velikostí. Při změně oblasti zobrazení se obsah přeformátuje, aby se co nejlépe využilo dostupné místo.

Přizpůsobení obsahu dokumentu toku

Jak je vidět na obrázku výše, obsah toku může obsahovat mnoho součástí včetně odstavců, seznamů, obrázků a dalších. Tyto komponenty odpovídají prvkům ve značkovacím jazyce a objektům v procedurálním kódu. Tyto třídy projdeme podrobněji později v části Související třídy toku tohoto přehledu. Tady je jednoduchý příklad kódu, který vytvoří dokument toku skládající se z odstavce s určitým tučným textem a seznamem.

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

Následující obrázek ukazuje, jak tento fragment kódu vypadá.

snímek obrazovky : Příklad vykresleného toku ve formátu FlowDocument

V tomto příkladu se ovládací prvek FlowDocumentReader používá k hostování obsahu toku. Další informace o ovládacích prvcích hostování obsahu toku najdete v tématu Typy dokumentů toku. prvky Paragraph, List, ListItema Bold slouží k řízení formátování obsahu na základě jejich pořadí v označení. Například prvek Bold pokrývá pouze část textu v odstavci; v důsledku toho je tučným písmem pouze ta část textu. Pokud jste použili HTML, bude vám to známé.

Jak je zvýrazněno na obrázku výše, existuje několik funkcí integrovaných do dokumentů Flow:

  • Hledání: Umožňuje uživateli provádět fulltextové vyhledávání celého dokumentu.

  • Režim zobrazení: Uživatel může vybrat preferovaný režim zobrazení, včetně zobrazení po jedné stránce, dvoustránkového zobrazení (formát čtení knihy) a zobrazení s neustálým posouváním (bezedné). Pro další informace o těchto režimech se podívejte na FlowDocumentReaderViewingMode.

  • Ovládací prvky navigace na stránce: Pokud režim zobrazení dokumentu používá stránky, ovládací prvky navigace na stránce zahrnují tlačítko pro přechod na další stránku (šipka dolů) nebo předchozí stránku (šipka nahoru) a indikátory pro aktuální číslo stránky a celkový počet stránek. Překlopení stránek lze provést také pomocí kláves se šipkami klávesnice.

  • Lupa: Ovládací prvky lupy umožňují uživateli zvětšit nebo snížit úroveň přiblížení kliknutím na tlačítka plus nebo minus. Ovládací prvky lupy také obsahují posuvník pro úpravu úrovně přiblížení. Další informace najdete v tématu Zoom.

Tyto funkce je možné upravit na základě ovládacího prvku použitého k hostování obsahu toku. Další část popisuje různé ovládací prvky.

Typy dokumentů toku

Zobrazení obsahu tokového dokumentu a jeho podoba závisí na objektu, který se používá k hostování tokového obsahu. Existují čtyři ovládací prvky, které podporují zobrazení obsahu toku: FlowDocumentReader, FlowDocumentPageViewer, RichTextBoxa FlowDocumentScrollViewer. Tyto ovládací prvky jsou stručně popsány níže.

Poznámka

FlowDocument se vyžaduje k přímému hostování obsahu toku, takže všechny tyto ovládací prvky zobrazení využívají FlowDocument k povolení hostování obsahu toku.

FlowDocumentReader

FlowDocumentReader zahrnuje funkce, které uživateli umožňují dynamicky vybírat mezi různými režimy zobrazení, včetně režimu zobrazení na jedné stránce (jedna stránka najednou), dvoustránkového režimu (formát čtení knihy) a režimu průběžného posouvání (neomezeného) zobrazení. Další informace o těchto režimech naleznete v FlowDocumentReaderViewingMode. Pokud nepotřebujete možnost dynamického přepínání mezi různými režimy zobrazení, FlowDocumentPageViewer a FlowDocumentScrollViewer poskytují méně náročné prohlížeče obsahu, které jsou pevně nastaveny na konkrétní režim zobrazení.

FlowDocumentProhlížečStránky a FlowDocumentProhlížečPosuvníku

FlowDocumentPageViewer zobrazuje obsah v režimu prohlížení po jedné stránce, zatímco FlowDocumentScrollViewer zobrazuje obsah v režimu souvislého rolování. Oba FlowDocumentPageViewer a FlowDocumentScrollViewer jsou nastaveny na konkrétní režim zobrazení. Porovnejte FlowDocumentReader, která zahrnuje funkce, které uživateli umožňují dynamicky vybírat mezi různými režimy zobrazení (jak je poskytuje výčet FlowDocumentReaderViewingMode), za cenu větší náročnosti prostředků než FlowDocumentPageViewer nebo FlowDocumentScrollViewer.

Ve výchozím nastavení se vždy zobrazí svislý posuvník a v případě potřeby se zobrazí vodorovný posuvník. Výchozí uživatelské rozhraní pro FlowDocumentScrollViewer neobsahuje panel nástrojů; vlastnost IsToolBarVisible lze však použít k povolení integrovaného panelu nástrojů.

RichTextBox

Pokud chcete uživateli povolit úpravy obsahu toku, použijete RichTextBox. Pokud byste například chtěli vytvořit editor, který uživateli umožnil manipulovat s tabulkami, kurzívou a tučným formátováním atd., použili byste RichTextBox. Další informace najdete v tématu RichTextBox – přehled.

Poznámka

Obsah toku uvnitř RichTextBox se nechová přesně jako obsah toku obsažený v jiných ovládacích prvcích. Například v RichTextBox nejsou žádné sloupce, a proto žádné chování automatické změny velikosti. Také obvykle integrované funkce toku obsahu, jako je vyhledávání, režim zobrazení, navigace na stránce a přiblížení, nejsou dostupné v rámci RichTextBox.

Vytváření dynamického obsahu

Obsah toku může být složitý, který se skládá z různých prvků, včetně textu, obrázků, tabulek a dokonce i UIElement odvozených tříd, jako jsou ovládací prvky. Abyste pochopili, jak vytvořit komplexní obsah toku, jsou důležité následující body:

  • Tokové třídy: Každá třída použitá v tokovém obsahu má specifický účel. Kromě toho hierarchický vztah mezi třídami toku pomáhá pochopit, jak se používají. Třídy odvozené z třídy Block například slouží k zahrnutí jiných objektů, zatímco třídy odvozené z Inline obsahují objekty, které jsou zobrazeny.

  • Content Schéma: Dokument toku může vyžadovat velký počet vnořených prvků. Schéma obsahu určuje možné vztahy nadřazenosti a podřízenosti mezi prvky.

Následující části podrobněji projdou každou z těchto oblastí.

Následující diagram znázorňuje objekty, které se nejčastěji používají s obsahem toku:

diagram : Hierarchie tříd elementů obsahu toku

Pro účely obsahu toku existují dvě důležité kategorie:

  1. Třídy odvozené z bloku: Označují se také jako "Prvky obsahu bloku" nebo jen "Blokové elementy". Prvky, které dědí z Block, lze použít k seskupení prvků pod společnou nadřazenou položkou nebo k použití společných atributů ve skupině.

  2. vložené odvozené třídy: Označuje se také jako "Vložené prvky obsahu" nebo jen "Vložené elementy". Prvky, které dědí z Inline, jsou buď obsaženy v blokovém elementu, nebo v jiném řádkovém elementu. Vložené elementy se často používají jako přímý kontejner obsahu, který se vykresluje na obrazovku. Například Paragraph (blokový element) může obsahovat Run (vložený element), ale Run skutečně obsahuje text vykreslený na obrazovce.

Každá třída v těchto dvou kategoriích je stručně popsána níže.

Třídy odvozené z bloku

odstavec

Paragraph se obvykle používá k seskupení obsahu do odstavce. Nejjednodušším a nejběžnějším použitím odstavce je vytvoření odstavce textu.

<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

Můžete však také obsahovat další vložené odvozené prvky, jak vidíte níže.

oddíl

Section je používán pouze k tomu, aby obsahoval jiné prvky odvozené od Block. Na prvky, které obsahuje, nepoužije žádné výchozí formátování. Všechny hodnoty vlastností nastavené na Section však platí pro jeho podřízené prvky. Oddíl také umožňuje iterovat pomocí programových prostředků prostřednictvím dceřiné kolekce. Section se používá podobným způsobem jako značka <DIV> ve formátu HTML.

V následujícím příkladu jsou tři odstavce definovány pod jedním Section. Oddíl má Background hodnotu vlastnosti Red, proto barva pozadí odstavců je také červená.

<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žňuje vložení prvků UIElement (tj. Button) do obsahu odvozeného z toku bloku. InlineUIContainer (viz níže) slouží k vložení UIElement prvků do obsahu odvozeného z in-line toku. BlockUIContainer a InlineUIContainer jsou důležité, protože neexistuje žádný jiný způsob, jak použít UIElement v obsahu toku, pokud není obsažen v jednom z těchto dvou prvků.

Následující příklad ukazuje, jak použít prvek BlockUIContainer k hostování UIElement objektů v rámci proudového obsahu.

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

Následující obrázek ukazuje, jak se tento příklad vykresluje:

Snímek obrazovky, který ukazuje objekt UIElement vložený do obsahu toku.

Seznam

List slouží k vytvoření odrážkového nebo číslovaného seznamu. Nastavte vlastnost MarkerStyle na hodnotu výčtu TextMarkerStyle pro určení stylu seznamu. Následující příklad ukazuje, jak vytvořit jednoduchý seznam.

<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

Poznámka

List je jediný prvek toku, který používá ListItemCollection ke správě podřízených prvků.

Tabulka

Table slouží k vytvoření tabulky. Table se podobá prvku Grid, ale má více funkcí, a proto vyžaduje větší režii na prostředky. Vzhledem k tomu, že Grid je UIElement, nelze jej použít v tokovém obsahu, pokud není obsažen v BlockUIContainer nebo InlineUIContainer. Další informace o Tablenaleznete v přehled tabulky.

Vložené odvozené třídy

Spustit

Run slouží k tomu, aby obsahoval neformátovaný text. Můžete očekávat, že Run objekty budou v tokovém obsahu hojně používány. Ve značkování se však prvky Run nevyžadují používat explicitně. Je nutné použít Run při vytváření nebo úpravě tokových dokumentů pomocí kódu. Například v níže uvedeném kódu první Paragraph určuje prvek Run explicitně, zatímco druhý ne. Oba odstavce generují stejný výstup.

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

Poznámka

Od .NET Framework 4 je vlastnost Text objektu Run vlastností závislosti. Vlastnost Text lze svázat se zdrojem dat, například TextBlock. Vlastnost Text plně podporuje jednosměrnou vazbu. Vlastnost Text také podporuje obousměrnou vazbu s výjimkou RichTextBox. Pro příklad viz Run.Text.

Span

Span seskupí další vložené prvky obsahu dohromady. Na obsah uvnitř elementu Span se nepoužívá žádné inherentní vykreslování. Prvky, které dědí z Span, včetně Hyperlink, Bold, Italic a Underline, používají formátování textu.

Níže je příklad použití Span pro obsah zahrnující vložený text, prvek Bold a 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>

Následující snímek obrazovky ukazuje, jak se tento příklad vykresluje.

Snímek obrazovky : Vykreslený příklad rozsahu

InlineUIContainer

InlineUIContainer umožňuje vložit prvky UIElement (tj. ovládací prvek jako Button) do elementu obsahu Inline. Tento prvek je ekvivalent v textu k BlockUIContainer, jak je popsán výše. Níže je příklad, který používá InlineUIContainer k vložení Button do 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

Poznámka

InlineUIContainer není nutné explicitně používat v kódu. Pokud ho vynecháte, při kompilaci kódu se přesto vytvoří InlineUIContainer.

obrázek a plovoucí objekt

Figure a Floater slouží k vložení obsahu do dokumentů toku s vlastnostmi umístění, které lze přizpůsobit nezávisle na primárním toku obsahu. Figure nebo Floater prvky se často používají ke zvýraznění nebo podtržení částí obsahu, k hostování podpůrných obrázků nebo jiného obsahu v rámci hlavního toku obsahu, nebo k vkládání volně souvisejícího obsahu, jako jsou reklamy.

Následující příklad ukazuje, jak vložit Figure do odstavce textu.

<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

Následující obrázek ukazuje, jak se tento příklad vykresluje.

Snímek obrazovky: Příklad obrázku

Figure a Floater se liší několika způsoby a používají se pro různé scénáře.

obrázek :

  • Lze umístit: Můžete nastavit jeho vodorovné a svislé kotvy tak, aby se ukotvily vzhledem k stránce, obsahu, sloupci nebo odstavci. Můžete také použít jeho HorizontalOffset a VerticalOffset vlastnosti k určení libovolných posunů.

  • Lze změnit velikost do více sloupců: Můžete nastavit výšku a šířku Figure na násobky výšky stránky, obsahu nebo sloupce. Všimněte si, že v případě stránky a obsahu nejsou povoleny násobky větší než 1. Můžete například nastavit šířku Figure na "0,5 stránky" nebo "0,25 obsahu" nebo "2 sloupec". Výšku a šířku můžete také nastavit na absolutní hodnoty pixelů.

  • Neprovádí stránkování: Pokud se obsah uvnitř Figure nevejde do Figure, vykreslí se obsah, který se vejde, a zbývající obsah se ztratí.

Plovák:

  • Nelze umístit a bude vykresleno tam, kde je možné pro něj udělat místo. Nelze nastavit posun nebo ukotvit objekt Floater.

  • Nemůže mít větší velikost než jeden sloupec: Ve výchozím nastavení má Floater velikost jednoho sloupce. Má vlastnost Width, kterou lze nastavit na absolutní pixelovou hodnotu, ale pokud je tato hodnota větší než šířka jednoho sloupce, je ignorována a velikost plovoucího prvku je nastavena na jeden sloupec. Můžete ji nastavit na méně než jeden sloupec tím, že nastavíte správnou šířku v pixelech, ale velikost není relativní vůči sloupci, takže "0,5Sloupec" není platný výraz pro šířku Floater. Floater nemá žádnou vlastnost výšky a není možné ji nastavit, výška závisí na obsahu.

  • Floater stránkuje: Pokud jeho obsah při zadané šířce přesáhne výšku jednoho sloupce, plovoucí objekt se rozdělí a stránkuje do dalšího sloupce, na další stránku atd.

Figure je vhodné umístit samostatný obsah tam, kde chcete řídit velikost a umístění, a máte jistotu, že se obsah vejde do zadané velikosti. Floater je dobrým místem, kde můžete dát více volného toku obsahu, který se podobá obsahu hlavní stránky, ale je oddělený od něj.

zalomení řádku

LineBreak způsobí, že v tokovém obsahu dojde k přerušení řádku. Následující příklad ukazuje použití 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>

Následující snímek obrazovky ukazuje, jak se tento příklad vykresluje.

Snímek obrazovky : Příklad linebreaku

Prvky kolekce průtoků

V mnoha příkladech výše se BlockCollection a InlineCollection používají k programovému vytváření obsahu toku. Pokud chcete například přidat prvky do Paragraph, můžete použít syntaxi:

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

Tím se do InlineCollectionParagraphpřidá Run . Je to stejné jako implicitní Run nalezené uvnitř Paragraph v kódu:

<Paragraph>
Some Text
</Paragraph>

Jako příklad použití BlockCollectionvytvoří následující příklad nový Section a pak použije metodu Přidat k přidání nového Paragraph do obsahu Section.

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

Kromě přidávání položek do kolekce toků můžete také odebrat položky. Následující příklad odstraní poslední Inline prvek v Span.

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

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

Následující příklad vymaže veškerý obsah (Inline elementy) z Span.

spanx.Inlines.Clear();

spanx.Inlines.Clear()

Při programové práci s tokovým obsahem pravděpodobně využijete tyto kolekce.

To, zda element toku používá InlineCollection (vložené položky) nebo BlockCollection (bloky) k obsahu svých podřízených prvků, závisí na tom, jaký typ podřízených prvků (Block nebo Inline) může nadřazený prvek obsahovat. Pravidla omezení pro prvky toku obsahu jsou shrnuta ve schématu obsahu v další části.

Poznámka

Existuje třetí druh kolekce používaného s tokovým obsahem, ListItemCollection, tato kolekce se však používá pouze s List. Kromě toho existuje několik kolekcí používaných s Table. Další informace najdete v části Přehled tabulky.

Schéma obsahu

Vzhledem k počtu různých prvků tokového obsahu může být ohromující sledovat, jaký typ podřízených prvků může prvek obsahovat. Následující diagram shrnuje pravidla zahrnutí pro prvky toku. Šipky představují možné vztahy nadřazenosti a podřízenosti.

Diagram : Schéma zahrnutí toku obsahu

Jak je vidět z výše uvedeného diagramu, podřízené položky povolené pro prvek nemusí nutně určovat, zda se jedná o prvek Block nebo prvek Inline. Například Span (element Inline) může mít pouze Inline podřízené prvky, zatímco Figure (také prvek Inline) může mít pouze Block podřízených elementů. Diagram je proto užitečný k rychlému určení toho, který prvek může být obsažen v jiném prvku. Jako příklad použijeme diagram k určení, jak vytvořit obsah toku RichTextBox.

1. Jeden RichTextBox musí obsahovat jeden FlowDocument, který musí obsahovat objekt odvozený z Block. Níže je odpovídající segment z výše uvedeného diagramu.

Diagram: pravidla zahrnutí RichTextBoxu

Zatím to vypadá takto.

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

2. Podle diagramu existuje několik Block prvků, ze které si můžete vybrat, včetně Paragraph, Section, Table, Lista BlockUIContainer (viz výše uvedené třídy odvozené od bloku). Řekněme, že chceme Table. Podle výše uvedeného diagramu Table obsahuje TableRowGroup, který obsahuje prvky TableRow, zahrnující prvky TableCell, obsahující objekt odvozený z Block. Níže je odpovídající segment pro Table převzatý z výše uvedeného diagramu.

diagram : Nadřazené/podřízené schéma pro tabulku

Níže je uveden odpovídající kód.

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

3. Jeden nebo více prvků Block jsou znovu vyžadovány pod TableCell. Abychom to mohli jednoduše udělat, dejte do buňky nějaký text. Můžeme to udělat pomocí Paragraph s prvkem Run. Níže jsou uvedeny odpovídající segmenty z diagramu, které ukazují, že Paragraph může vzít prvek Inline a že Run (element Inline) může mít pouze prostý text.

Diagram: Schéma rodič/dítě pro odstavec

diagram : Nadřazené/podřízené schéma pro spuštění

Níže je uveden celý příklad v kódu.

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

Přizpůsobení textu

Text je obvykle nejběžnějším typem obsahu v dokumentu toku. I když výše uvedené objekty lze použít k řízení většiny aspektů vykreslení textu, existují některé další metody přizpůsobení textu, které jsou popsány v této části.

Textové dekorace

Textové dekorace umožňují použít u textu efekty podtržení, nadtržení a přeškrtnutí (viz obrázky níže). Tyto dekorace se přidávají pomocí vlastnosti TextDecorations, která je zpřístupněna řadou objektů, včetně Inline, Paragraph, TextBlocka TextBox.

Následující příklad ukazuje, jak nastavit vlastnost TextDecorations pro 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

Následující obrázek ukazuje, jak se tento příklad vykresluje.

snímek obrazovky : Text s výchozím přeškrtnutím

Následující obrázky ukazují, jak dekorace nadtržení, základní liniea podtržení jsou zobrazeny, v uvedeném pořadí.

Snímek snímku obrazovky: přeřádkovací textDecorator

Snímek obrazovky: Výchozí efekt základní linie u textuScreenshot: Default baseline effect on text

snímek obrazovky : Text s výchozím efektem podtržení

Typografie

Vlastnost Typography je vystavena většinou obsahu souvisejícího s tokem, včetně TextElement, FlowDocument, TextBlocka TextBox. Tato vlastnost se používá k řízení typografických charakteristik a variací textu (tj. malých nebo velkých písmen, vytváření horních a dolních indexů atd.).

Následující příklad ukazuje, jak nastavit atribut Typography pomocí Paragraph jako příklad 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>

Následující obrázek ukazuje, jak se tento příklad vykresluje.

Snímek obrazovky s textem se změněnou typografií

Naproti tomu následující obrázek ukazuje, jak se podobný příklad s výchozími typografickými vlastnostmi vykresluje.

Snímek obrazovky s textem s výchozí typografií

Následující příklad ukazuje, jak nastavit Typography vlastnost programově.

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

Další informace o typografii najdete v tématu typografie ve WPF.

Viz také