Vue d'ensemble des documents dynamiquesFlow Document Overview

Les documents dynamiques sont conçus pour optimiser l’affichage et la lisibilité.Flow documents are designed to optimize viewing and readability. Au lieu d’avoir une disposition prédéfinie, ces documents dynamiques ajustent et refluent dynamiquement leur contenu en fonction des variables d’exécution telles que la taille de la fenêtre, la résolution de l’appareil et les préférences facultatives de l’utilisateur.Rather than being set to one predefined layout, flow documents dynamically adjust and reflow their content based on run-time variables such as window size, device resolution, and optional user preferences. En outre, les documents dynamiques offrent des fonctionnalités de document avancées, telles que la pagination et les colonnes.In addition, flow documents offer advanced document features, such as pagination and columns. Cette rubrique fournit une vue d’ensemble des documents dynamiques et explique comment les créer.This topic provides an overview of flow documents and how to create them.

Description d’un document dynamiqueWhat is a Flow Document

Un document dynamique est conçu pour « redisposer le contenu » en fonction de la taille de la fenêtre, de la résolution de l’appareil et d’autres variables d’environnement.A flow document is designed to "reflow content" depending on window size, device resolution, and other environment variables. En outre, les documents dynamiques possèdent plusieurs fonctionnalités intégrées, notamment la recherche, les modes d’affichage qui optimisent la lisibilité et la possibilité de changer la taille et l’apparence des polices.In addition, flow documents have a number of built in features including search, viewing modes that optimize readability, and the ability to change the size and appearance of fonts. Les documents dynamiques sont utilisés surtout quand la facilité de lecture est le scénario principal de consommation des documents.Flow Documents are best utilized when ease of reading is the primary document consumption scenario. À l’inverse, les documents fixes sont conçus pour avoir une présentation statique.In contrast, Fixed Documents are designed to have a static presentation. Ces documents sont utiles quand le contenu source doit être fidèlement respecté.Fixed Documents are useful when fidelity of the source content is essential. Pour plus d’informations sur les différents types de documents , consultez documents dans WPF .See Documents in WPF for more information on different types of documents.

L’illustration suivante montre un exemple de document dynamique affiché dans des fenêtres de différentes tailles.The following illustration shows a sample flow document viewed in several windows of different sizes. Chaque fois que la zone d’affichage change, le contenu est redisposé pour utiliser de façon optimale l’espace disponible.As the display area changes, the content reflows to make the best use of the available space.

Redisposition du contenu du document dynamiqueFlow Document Content Reflow

Comme illustré dans l’image ci-dessus, le contenu dynamique peut comprendre plusieurs composants, notamment des paragraphes, des listes, des images et bien plus encore.As seen in the image above, flow content can include many components including paragraphs, lists, images, and more. Ces composants correspondent à des éléments dans le balisage et à des objets dans le code procédural.These components correspond to elements in markup and objects in procedural code. Nous allons passer en revue ces classes plus en détail dans la section classes liées au Flow de cette vue d’ensemble.We will go over these classes in detail later in the Flow Related Classes section of this overview. Pour le moment, voici un exemple de code simple qui crée un document dynamique constitué d’un paragraphe avec du texte en gras et une liste.For now, here is a simple code example that creates a flow document consisting of a paragraph with some bold text and a list.

<!-- This simple flow document includes a paragraph with some
     bold text in it and a list. -->
<FlowDocumentReader xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
  <FlowDocument>
    <Paragraph>
      <Bold>Some bold text in the paragraph.</Bold>
      Some text that is not bold.
    </Paragraph>

    <List>
      <ListItem>
        <Paragraph>ListItem 1</Paragraph>
      </ListItem>
      <ListItem>
        <Paragraph>ListItem 2</Paragraph>
      </ListItem>
      <ListItem>
        <Paragraph>ListItem 3</Paragraph>
      </ListItem>
    </List>

  </FlowDocument>
</FlowDocumentReader>
using System;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;

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

            Paragraph myParagraph = new Paragraph();

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

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

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

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

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

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

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

            this.Content = myFlowDocumentReader;
        }
    }
}

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

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

            Dim myParagraph As New Paragraph()

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

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

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

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

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

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

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

            Me.Content = myFlowDocumentReader
        End Sub
    End Class
End Namespace

Cet extrait de code est illustré ci-dessous.The illustration below shows what this code snippet looks like.

![Capture d’écran Exemple]de(./media/flow-ovw-first-example.png "Flow_Ovw_First_Example") de FlowDocument renduScreenshot: Rendered FlowDocument example

Dans cet exemple, le FlowDocumentReader contrôle est utilisé pour héberger le contenu dynamique.In this example, the FlowDocumentReader control is used to host the flow content. Pour plus d’informations sur les contrôles d’hébergement de contenu dynamique, consultez types de documents dynamiques .See Flow Document Types for more information on flow content hosting controls. Paragraphles éléments,, Bold et sont utilisés pour contrôler la mise en forme du contenu, en fonction de leur ordre dans le balisage. List ListItemParagraph, List, ListItem, and Bold elements are used to control content formatting, based on their order in markup. Par exemple, l' Bold élément s’étend uniquement à une partie du texte du paragraphe ; par conséquent, seule cette partie du texte est en gras.For example, the Bold element spans across only part of the text in the paragraph; as a result, only that part of the text is bold. Si vous avez déjà utilisé le langage HTML, cela doit vous sembler familier.If you have used HTML, this will be familiar to you.

Comme indiqué dans l’illustration ci-dessus, plusieurs fonctionnalités sont intégrées aux documents dynamiques :As highlighted in the illustration above, there are several features built into Flow Documents:

  • Rechercher : Permet à l’utilisateur d’effectuer une recherche en texte intégral d’un document entier.Search: Allows the user to perform a full text search of an entire document.

  • Mode d’affichage : L’utilisateur peut sélectionner son mode d’affichage préféré, y compris un mode d’affichage de page unique (page par page), un mode d’affichage à deux pages à la fois (format de livre) et un mode d’affichage de défilement continu (sans fin).Viewing Mode: The user can select their preferred viewing mode including a single-page (page-at-a-time) viewing mode, a two-page-at-a-time (book reading format) viewing mode, and a continuous scrolling (bottomless) viewing mode. Pour plus d’informations sur ces modes d’affichage FlowDocumentReaderViewingMode, consultez.For more information about these viewing modes, see FlowDocumentReaderViewingMode.

  • Contrôles de navigation entre les pages : Si le mode d’affichage du document utilise des pages, les contrôles de navigation entre les pages incluent un bouton pour accéder à la page suivante (flèche bas) ou la page précédente (flèche vers le haut), ainsi que des indicateurs pour le numéro de page actuel et le nombre total de pages.Page Navigation Controls: If the viewing mode of the document uses pages, the page navigation controls include a button to jump to the next page (the down arrow) or previous page (the up arrow), as well as indicators for the current page number and total number of pages. Vous pouvez aussi faire défiler les pages à l’aide des touches de direction du clavier.Flipping through pages can also be accomplished using the keyboard arrow keys.

  • Zoom : Les contrôles de zoom permettent à l’utilisateur d’augmenter ou de diminuer le niveau de zoom en cliquant respectivement sur les boutons plus ou moins.Zoom: The zoom controls enable the user to increase or decrease the zoom level by clicking the plus or minus buttons, respectively. Les contrôles de zoom incluent également un curseur pour ajuster le niveau de zoom.The zoom controls also include a slider for adjusting the zoom level. Pour plus d'informations, consultez Zoom.For more information, see Zoom.

Ces fonctionnalités peuvent être modifiées selon le contrôle utilisé pour héberger le contenu dynamique.These features can be modified based upon the control used to host the flow content. La section suivante décrit les différents contrôles.The next section describes the different controls.

Types de documents dynamiquesFlow Document Types

L’affichage et l’apparence du contenu des documents dynamiques dépendent de l’objet utilisé pour héberger le contenu dynamique.Display of flow document content and how it appears is dependent upon what object is used to host the flow content. Quatre contrôles prennent en charge l’affichage du contenu dynamique : FlowDocumentReader, FlowDocumentPageViewer, RichTextBoxet FlowDocumentScrollViewer.There are four controls that support viewing of flow content: FlowDocumentReader, FlowDocumentPageViewer, RichTextBox, and FlowDocumentScrollViewer. Ces contrôles sont brièvement décrits ci-dessous.These controls are briefly described below.

Notes

FlowDocumentest requis pour héberger directement le contenu dynamique, donc tous ces contrôles d’affichage FlowDocument consomment un pour activer l’hébergement du contenu dynamique.FlowDocument is required to directly host flow content, so all of these viewing controls consume a FlowDocument to enable flow content hosting.

FlowDocumentReaderFlowDocumentReader

FlowDocumentReaderinclut des fonctionnalités qui permettent à l’utilisateur de choisir dynamiquement entre différents modes d’affichage, y compris un mode d’affichage d’une seule page (page par page), un mode d’affichage à deux pages à un moment donné (format de lecture du livre) et un mode d’affichage de défilement continu (sans fin).FlowDocumentReader includes features that enable the user to dynamically choose between various viewing modes, including a single-page (page-at-a-time) viewing mode, a two-page-at-a-time (book reading format) viewing mode, and a continuous scrolling (bottomless) viewing mode. Pour plus d’informations sur ces modes d’affichage FlowDocumentReaderViewingMode, consultez.For more information about these viewing modes, see FlowDocumentReaderViewingMode. Si vous n’avez pas besoin de basculer dynamiquement entre les différents modes d' FlowDocumentPageViewer affichage FlowDocumentScrollViewer , et de fournir des visionneuses de contenu de circulation plus légères qui sont fixes dans un mode d’affichage particulier.If you do not need the ability to dynamically switch between different viewing modes, FlowDocumentPageViewer and FlowDocumentScrollViewer provide lighter-weight flow content viewers that are fixed in a particular viewing mode.

FlowDocumentPageViewer et FlowDocumentScrollViewerFlowDocumentPageViewer and FlowDocumentScrollViewer

FlowDocumentPageVieweraffiche le contenu en mode page par page, tandis que FlowDocumentScrollViewer affiche le contenu en mode de défilement continu.FlowDocumentPageViewer shows content in page-at-a-time viewing mode, while FlowDocumentScrollViewer shows content in continuous scrolling mode. FlowDocumentPageViewer EtFlowDocumentScrollViewer sont résolus en un mode d’affichage particulier.Both FlowDocumentPageViewer and FlowDocumentScrollViewer are fixed to a particular viewing mode. Comparez FlowDocumentReaderà, qui comprend des fonctionnalités qui permettent à l’utilisateur de choisir dynamiquement entre plusieurs modes d’affichage ( FlowDocumentReaderViewingMode comme fourni par l’énumération), au détriment d’une FlowDocumentPageViewer plus FlowDocumentScrollViewergrande quantité de ressources que ou.Compare to FlowDocumentReader, which includes features that enable the user to dynamically choose between various viewing modes (as provided by the FlowDocumentReaderViewingMode enumeration), at the cost of being more resource intensive than FlowDocumentPageViewer or FlowDocumentScrollViewer.

Par défaut, une barre de défilement verticale est toujours affichée et une barre de défilement horizontale apparaît si nécessaire.By default, a vertical scrollbar is always shown, and a horizontal scrollbar becomes visible if needed. L’interface utilisateur par FlowDocumentScrollViewer défaut pour n’inclut pas de barre d’outils IsToolBarVisible ; Toutefois, la propriété peut être utilisée pour activer une barre d’outils intégrée.The default UI for FlowDocumentScrollViewer does not include a toolbar; however, the IsToolBarVisible property can be used to enable a built-in toolbar.

RichTextBoxRichTextBox

Vous utilisez une RichTextBox lorsque vous souhaitez autoriser l’utilisateur à modifier le contenu dynamique.You use a RichTextBox when you want to allow the user to edit flow content. Par exemple, si vous souhaitez créer un éditeur qui permettait à un utilisateur de manipuler des éléments tels que des tableaux, des mises en forme en italique et en RichTextBoxgras, etc., vous devez utiliser un.For example, if you wanted to create an editor that allowed a user to manipulate things like tables, italic and bold formatting, etc, you would use a RichTextBox. Pour plus d’informations, consultez vue d’ensemble de RichTextBox .See RichTextBox Overview for more information.

Notes

Le contenu dynamique à RichTextBox l’intérieur d’un ne se comporte pas exactement comme le contenu de Flow contenu dans d’autres contrôles.Flow content inside a RichTextBox does not behave exactly like flow content contained in other controls. Par exemple, il n’y a pas de RichTextBox colonnes dans un et, par conséquent, aucun comportement de redimensionnement automatique.For example, there are no columns in a RichTextBox and hence no automatic resizing behavior. En outre, les fonctionnalités généralement intégrées du contenu dynamique, telles que la recherche, le mode d’affichage, la navigation entre les pages RichTextBoxet le zoom, ne sont pas disponibles dans un.Also, the typically built in features of flow content like search, viewing mode, page navigation, and zoom are not available within a RichTextBox.

Création de contenu dynamiqueCreating Flow Content

Le contenu dynamique peut être complexe, constitué de différents éléments, notamment du texte, des images, UIElement des tables et même des classes dérivées telles que des contrôles.Flow content can be complex, consisting of various elements including text, images, tables, and even UIElement derived classes like controls. Pour comprendre comment créer du contenu dynamique complexe, les points suivants sont essentiels :To understand how to create complex flow content, the following points are critical:

  • Classes liées au Flow: Chaque classe utilisée dans le contenu dynamique a un objectif spécifique.Flow-related Classes: Each class used in flow content has a specific purpose. En outre, la relation hiérarchique entre les classes vous permet de comprendre comment elles sont utilisées.In addition, the hierarchical relation between flow classes helps you understand how they are used. Par exemple, les classes dérivées Block de la classe sont utilisées pour contenir d’autres objets, Inline tandis que les classes dérivées de contiennent des objets affichés.For example, classes derived from the Block class are used to contain other objects while classes derived from Inline contain objects that are displayed.

  • Schéma de contenu: Un document dynamique peut nécessiter un nombre important d’éléments imbriqués.Content Schema: A flow document can require a substantial number of nested elements. Le schéma du contenu indique les relations parent/enfant possibles entre les éléments.The content schema specifies possible parent/child relationships between elements.

Les sections suivantes décrivent en détail chacun des points ci-dessus.The following sections will go over each of these areas in more detail.

Le diagramme ci-dessous contient les objets les plus souvent utilisés avec du contenu dynamique :The diagram below shows the objects most typically used with flow content:

![Schémas Hiérarchie]de classe d’élément de contenu de Flow(./media/flow-class-hierarchy.png "Flow_Class_Hierarchy")Diagram: Flow content element class hierarchy

Pour faciliter la gestion du contenu dynamique, il existe deux catégories principales :For the purposes of flow content, there are two important categories:

  1. Classes dérivées de Block: Également appelé « éléments de contenu de bloc » ou simplement « éléments de bloc ».Block-derived classes: Also called "Block content elements" or just "Block Elements". Les éléments qui héritent de peuvent être utilisés pour regrouper des éléments sous un parent commun ou pour appliquer des Block attributs communs à un groupe.Elements that inherit from Block can be used to group elements under a common parent or to apply common attributes to a group.

  2. Classes dérivées de Inline: Également appelé « éléments de contenu Inline » ou simplement « éléments Inline ».Inline-derived classes: Also called "Inline content elements" or just "Inline Elements". Les éléments qui héritent de Inline sont contenus dans un élément de bloc ou un autre élément inline.Elements that inherit from Inline are either contained within a Block Element or another Inline Element. Les éléments Inline sont souvent utilisés comme conteneur direct du contenu restitué à l’écran.Inline Elements are often used as the direct container of content that is rendered to the screen. Par exemple, un Paragraph (élément Block) peut contenir un Run (élément Run Inline), mais contient en fait le texte qui est affiché à l’écran.For example, a Paragraph (Block Element) can contain a Run (Inline Element) but the Run actually contains the text that is rendered on the screen.

Chaque classe de ces deux catégories est brièvement décrite ci-dessous.Each class in these two categories is briefly described below.

Classes dérivées de BlockBlock-derived Classes

ParagraphParagraph

Paragraphest généralement utilisé pour regrouper du contenu dans un paragraphe.Paragraph is typically used to group content into a paragraph. L’utilisation la plus courante et la plus simple de Paragraph consiste à créer un paragraphe de texte.The simplest and most common use of Paragraph is to create a paragraph of text.

<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

Toutefois, vous pouvez également contenir d’autres éléments dérivés de Inline comme vous le verrez ci-dessous.However, you can also contain other inline-derived elements as you will see below.

SectionSection

Sectionest utilisé uniquement pour contenir d' Blockautres éléments dérivés de.Section is used only to contain other Block-derived elements. Il n’applique aucune mise en forme par défaut aux éléments qu’il contient.It does not apply any default formatting to the elements it contains. Toutefois, les valeurs de propriété définies sur Section un s’appliquent à ses éléments enfants.However, any property values set on a Section applies to its child elements. Une section vous permet également d’itérer par programmation dans sa collection enfant.A section also enables you to programmatically iterate through its child collection. Sectionest utilisé de la même façon que la <balise div > en html.Section is used in a similar manner to the <DIV> tag in HTML.

Dans l’exemple ci-dessous, trois paragraphes sont définis Sectionsous un.In the example below, three paragraphs are defined under one Section. La section a une Background valeur de propriété rouge, donc la couleur d’arrière-plan des paragraphes est également rouge.The section has a Background property value of Red, therefore the background color of the paragraphs is also red.

<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

BlockUIContainerBlockUIContainer

BlockUIContainerpermet UIElement aux éléments (c’est-à-dire a Button) d’être incorporés dans le contenu de fluide dérivé du bloc.BlockUIContainer enables UIElement elements (i.e. a Button) to be embedded in block-derived flow content. InlineUIContainer(voir ci-dessous) est utilisé UIElement pour incorporer des éléments dans le contenu de fluide dérivé de Inline.InlineUIContainer (see below) is used to embed UIElement elements in inline-derived flow content. BlockUIContaineret InlineUIContainer sont importants, car il n’existe pas d’autre moyen UIElement d’utiliser un dans le contenu dynamique, sauf s’il est contenu dans l’un de ces deux éléments.BlockUIContainer and InlineUIContainer are important because there is no other way to use a UIElement in flow content unless it is contained within one of these two elements.

L’exemple suivant montre comment utiliser l’élément BlockUIContainer pour héberger UIElement des objets dans le contenu dynamique.The following example shows how to use the BlockUIContainer element to host UIElement objects within flow content.

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

L’illustration suivante montre le rendu de cet exemple :The following figure shows how this example renders:

Capture d’écran montrant un UIElement incorporé dans le contenu dynamique.

ListList

Listest utilisé pour créer une liste à puces ou une liste numérique.List is used to create a bulleted or numeric list. Affectez MarkerStyle à la propriété TextMarkerStyle une valeur d’énumération pour déterminer le style de la liste.Set the MarkerStyle property to a TextMarkerStyle enumeration value to determine the style of the list. L’exemple ci-dessous montre comment créer une liste simple.The example below shows how to create a simple list.

<FlowDocument xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
  <List>
    <ListItem>
      <Paragraph>
        List Item 1
      </Paragraph>
    </ListItem>
    <ListItem>
      <Paragraph>
        List Item 2
      </Paragraph>
    </ListItem>
    <ListItem>
      <Paragraph>
        List Item 3
      </Paragraph>
    </ListItem>
  </List>
</FlowDocument>
using System;
using System.Windows;
using System.Windows.Media;
using System.Windows.Controls;
using System.Windows.Documents;

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

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

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

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

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

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

            this.Content = myFlowDocument;
        }
    }
}

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

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

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

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

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

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

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

            Me.Content = myFlowDocument
        End Sub
    End Class
End Namespace

Notes

Listest le seul élément de Flow qui utilise ListItemCollection le pour gérer les éléments enfants.List is the only flow element that uses the ListItemCollection to manage child elements.

TableTable

Tableest utilisé pour créer une table.Table is used to create a table. Tableest similaire à l' Grid élément, mais il a davantage de fonctionnalités et, par conséquent, nécessite une plus grande surcharge de ressources.Table is similar to the Grid element but it has more capabilities and, therefore, requires greater resource overhead. Étant Grid donné que UIElementest un, il ne peut pas être utilisé dans le contenu de fluide BlockUIContainer , InlineUIContainersauf s’il est contenu dans un ou.Because Grid is a UIElement, it cannot be used in flow content unless it is contained in a BlockUIContainer or InlineUIContainer. Pour plus d’informations Tablesur, consultez vue d’ensemble des tables.For more information on Table, see Table Overview.

Classes dérivées d’InlineInline-derived Classes

ExécuterRun

Runest utilisé pour contenir du texte non mis en forme.Run is used to contain unformatted text. Vous pouvez vous Run attendre à ce que les objets soient largement utilisés dans le contenu dynamique.You might expect Run objects to be used extensively in flow content. Toutefois, dans le balisage, Run les éléments ne doivent pas obligatoirement être utilisés explicitement.However, in markup, Run elements are not required to be used explicitly. Rundoit être utilisé lors de la création ou de la manipulation de documents de workflow à l’aide de code.Run is required to be used when creating or manipulating flow documents by using code. Par exemple, dans le balisage ci-dessous Paragraph , la Run première spécifie l’élément explicitement alors que le deuxième ne le fait pas.For example, in the markup below, the first Paragraph specifies the Run element explicitly while the second does not. Les deux paragraphes génèrent le même résultat.Both paragraphs generate identical output.

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

Notes

À partir du .NET Framework 4, la Text propriété de l' Run objet est une propriété de dépendance.Starting in the .NET Framework 4, the Text property of the Run object is a dependency property. Vous pouvez lier la Text propriété à une source de données, telle qu' TextBlockun.You can bind the Text property to a data source, such as a TextBlock. La Text propriété prend entièrement en charge la liaison unidirectionnelle.The Text property fully supports one-way binding. La Text propriété prend également en charge la liaison bidirectionnelle RichTextBox, à l’exception de.The Text property also supports two-way binding, except for RichTextBox. Pour obtenir un exemple, consultez Run.Text.For an example, see Run.Text.

SpanSpan

Spanregroupe d’autres éléments de contenu Inline.Span groups other inline content elements together. Aucun rendu inhérent n’est appliqué au contenu dans Span un élément.No inherent rendering is applied to content within a Span element. Toutefois, Span Italic les éléments qui héritent Hyperlinkde Boldincluant, Underline et appliquent la mise en forme au texte.However, elements that inherit from Span including Hyperlink, Bold, Italic and Underline do apply formatting to text.

Voici un exemple de Span qui est utilisé pour contenir du contenu Inline, notamment du texte, un Bold élément et Buttonun.Below is an example of a Span being used to contain inline content including text, a Bold element, and 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>

La capture d’écran suivante montre le rendu de cet exemple.The following screenshot shows how this example renders.

![Capture d’écran Exemple]d’étendue rendue(./media/flow-spanexample.gif "Flow_SpanExample")Screenshot: Rendered Span example

InlineUIContainerInlineUIContainer

InlineUIContaineractive UIElement les éléments (par exemple, un Buttoncontrôle comme) à incorporer Inline dans un élément de contenu.InlineUIContainer enables UIElement elements (i.e. a control like Button) to be embedded in an Inline content element. Cet élément est l’équivalent inline de BlockUIContainer décrit ci-dessus.This element is the inline equivalent to BlockUIContainer described above. Vous trouverez ci-dessous un InlineUIContainer exemple qui utilise Button pour insérer une inline dans un Paragraph.Below is an example that uses InlineUIContainer to insert a Button inline in a 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

Notes

InlineUIContainern’a pas besoin d’être utilisé explicitement dans le balisage.InlineUIContainer does not need to be used explicitly in markup. Si vous l’omettez, un InlineUIContainer est créé quand le code est compilé.If you omit it, an InlineUIContainer will be created anyway when the code is compiled.

Figure et FloaterFigure and Floater

Figureet Floater sont utilisés pour incorporer du contenu dans des documents dynamiques avec des propriétés de positionnement qui peuvent être personnalisées indépendamment du contenu principal.Figure and Floater are used to embed content in Flow Documents with placement properties that can be customized independent of the primary content flow. Figureles Floater éléments ou sont souvent utilisés pour mettre en surbrillance ou accentuer des parties de contenu, pour héberger des images de prise en charge ou d’autres contenus au sein du contenu de contenu principal, ou pour injecter du contenu étroitement lié, tel que des publications.Figure or Floater elements are often used to highlight or accentuate portions of content, to host supporting images or other content within the main content flow, or to inject loosely related content such as advertisements.

L’exemple suivant montre comment incorporer un Figure dans un paragraphe de texte.The following example shows how to embed a Figure into a paragraph of text.

<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

L’illustration suivante montre le rendu de cet exemple.The following illustration shows how this example renders.

![Capture d’écran Exemple]de figure(./media/flow-ovw-figure-example.png "Flow_Ovw_Figure_Example")Screenshot: Figure example

Figureet Floater diffèrent de plusieurs façons et sont utilisés pour différents scénarios.Figure and Floater differ in several ways and are used for different scenarios.

Figure :Figure:

  • Peut être positionné : Vous pouvez définir ses ancres horizontale et verticale pour l’ancrer par rapport à la page, au contenu, à la colonne ou au paragraphe.Can be positioned: You can set its horizontal and vertical anchors to dock it relative to the page, content, column or paragraph. Vous pouvez également utiliser ses HorizontalOffset propriétés VerticalOffset et pour spécifier des décalages arbitraires.You can also use its HorizontalOffset and VerticalOffset properties to specify arbitrary offsets.

  • Dimensionnable sur plusieurs colonnes : Vous pouvez définir Figure la hauteur et la largeur en multiples de la hauteur ou de la largeur de la page, du contenu ou de la colonne.Is sizable to more than one column: You can set Figure height and width to multiples of page, content or column height or width. Notez que, dans les deux premiers cas, les multiples supérieurs à 1 ne sont pas autorisés.Note that in the case of page and content, multiples greater than 1 are not allowed. Par exemple, vous pouvez définir la largeur d’un Figure sur « 0,5 page » ou « 0,25 content » ou « 2 Column ».For example, you can set the width of a Figure to be "0.5 page" or "0.25 content" or "2 Column". Vous pouvez également définir des valeurs en pixels absolues pour la hauteur et la largeur.You can also set height and width to absolute pixel values.

  • Ne pagine pas : Si le contenu à l' Figure intérieur d’un ne tient Figurepas dans le, il affiche le contenu qui est ajusté et le reste du contenu est perduDoes not paginate: If the content inside a Figure does not fit inside the Figure, it will render whatever content does fit and the remaining content is lost

Floater :Floater:

  • Non positionnable : cet élément s’affiche dans l’espace disponible, quel qu’il soit.Cannot be positioned and will render wherever space can be made available for it. Vous ne pouvez pas définir le décalage ou Floaterancrer un.You cannot set the offset or anchor a Floater.

  • Ne peut pas être dimensionné à plusieurs colonnes : Par défaut, Floater les tailles sont représentées dans une colonne.Cannot be sized to more than one column: By default, Floater sizes at one column. Elle possède une Width propriété qui peut être définie sur une valeur en pixels absolue, mais si cette valeur est supérieure à une largeur de colonne, elle est ignorée et le floater est dimensionné au niveau d’une colonne.It has a Width property that can be set to an absolute pixel value, but if this value is greater than one column width it is ignored and the floater is sized at one column. Vous pouvez la redimensionner sur moins d’une colonne en définissant la largeur en pixels correcte, mais le dimensionnement n’est pas relatif à la colonne, donc « colonne Floater 0.5 » n’est pas une expression valide pour la largeur.You can size it to less than one column by setting the correct pixel width, but sizing is not column-relative, so "0.5Column" is not a valid expression for Floater width. Floatern’a pas de propriété Height et sa hauteur ne peut pas être définie, sa hauteur dépend du contenuFloater has no height property and it's height cannot be set, it’s height depends on the content

  • Floaterpagine Si son contenu à la largeur spécifiée s’étend à plus de 1 hauteur de colonne, le floater s’interrompt et pagine sur la colonne suivante, la page suivante, etc.Floater paginates: If its content at its specified width extends to more than 1 column height, floater breaks and paginates to the next column, the next page, etc.

Figureest un emplacement idéal pour placer du contenu autonome dans lequel vous souhaitez contrôler la taille et le positionnement, et êtes sûr que le contenu sera adapté à la taille spécifiée.Figure is a good place to put standalone content where you want to control the size and positioning, and are confident that the content will fit in the specified size. Floaterest un bon endroit pour placer un contenu plus libre qui circule comme le contenu de la page principale, mais qui en est séparé.Floater is a good place to put more free-flowing content that flows similar to the main page content, but is separated from it.

LineBreakLineBreak

LineBreakprovoque l’apparition d’un saut de ligne dans le contenu dynamique.LineBreak causes a line break to occur in flow content. L'exemple suivant montre l'utilisation de LineBreak.The following example demonstrates the use of 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>

La capture d’écran suivante montre le rendu de cet exemple.The following screenshot shows how this example renders.

![Capture d’écran Exemple]de LineBreak(./media/flow-ovw-linebreakexample.png "Flow_Ovw_LineBreakExample")Screenshot: LineBreak example

Éléments de collection de fluxFlow Collection Elements

Dans la plupart des exemples ci-dessus BlockCollection , InlineCollection les et sont utilisés pour construire du contenu dynamique par programmation.In many of the examples above, the BlockCollection and InlineCollection are used to construct flow content programmatically. Par exemple, pour ajouter des éléments à Paragraphun, vous pouvez utiliser la syntaxe suivante :For example, to add elements to a Paragraph, you can use the syntax:

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

Cela ajoute un Run InlineCollection au du Paragraph.This adds a Run to the InlineCollection of the Paragraph. Il s’agit du même que celui Run trouvé implicite Paragraph dans un dans le balisage :This is the same as the implicit Run found inside a Paragraph in markup:

<Paragraph>
Some Text
</Paragraph>

En guise d’exemple d' BlockCollectionutilisation du, l’exemple suivant crée Section un nouveau, puis utilise la Section méthode Add pour ajouter Paragraph un nouveau au contenu.As an example of using the BlockCollection, the following example creates a new Section and then uses the Add method to add a new Paragraph to the Section contents.

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

En plus d’ajouter des éléments à une collection de flux, vous pouvez aussi en supprimer.In addition to adding items to a flow collection, you can remove items as well. L’exemple suivant supprime le dernier Inline élément Spande.The following example deletes the last Inline element in the Span.

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

L’exemple suivant efface tout le contenu (Inline éléments) Spande.The following example clears all of the contents (Inline elements) from the Span.

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

Quand vous utilisez du contenu dynamique par programmation, vous employez certainement très souvent ces collections.When working with flow content programmatically, you will likely make extensive use of these collections.

Le fait qu’un élément de InlineCollection Flow utilise un (Inline BlockCollection ) ou un (bloc) pour contenir ses éléments enfants dépend du type d’élémentsBlock enfants Inline(ou) qui peuvent être contenus par le parent.Whether a flow element uses an InlineCollection (Inlines) or BlockCollection (Blocks) to contain its child elements depends on what type of child elements (Block or Inline) can be contained by the parent. Les règles relatives à la relation contenant-contenu pour les éléments de contenu dynamique sont résumées dans le schéma du contenu présenté à la section suivante.Containment rules for flow content elements are summarized in the content schema in the next section.

Notes

Un troisième type de collection est utilisé avec le ListItemCollectioncontenu dynamique, mais cette collection est utilisée uniquement avec un. ListThere is a third type of collection used with flow content, the ListItemCollection, but this collection is only used with a List. En outre, plusieurs collections sont utilisées avec Table.In addition, there are several collections used with Table. Pour plus d’informations, consultez vue d’ensemble des tables .See Table Overview for more information.

Schéma du contenuContent Schema

Étant donné le nombre d’éléments de contenu dynamique, il est parfois difficile de savoir quel type d’éléments enfants peut être contenu dans un élément.Given the number of different flow content elements, it can be overwhelming to keep track of what type of child elements an element can contain. Le diagramme suivant récapitule les règles relatives à la relation contenant-contenu pour les éléments de contenu dynamique.The diagram below summarizes the containment rules for flow elements. Les flèches représentent les relations parent/enfant possibles.The arrows represent the possible parent/child relationships.

![Schémas Schéma]de relation contenant-contenu Flow(./media/flow-content-schema.png "Flow_Content_Schema")Diagram: Flow content containment schema

Comme vous pouvez le voir dans le diagramme ci-dessus, les enfants autorisés pour un élément ne sont pas nécessairement déterminés par Block le fait qu' Inline il s’agisse d’un élément ou d’un élément.As can be seen from the diagram above, the children allowed for an element are not necessarily determined by whether it is a Block element or an Inline element. Par exemple, un Span (un Inline élément) ne peut avoir Inline que des éléments enfants Figure tandis qu' Inline un (également un élément Block ) ne peut avoir que des éléments enfants.For example, a Span (an Inline element) can only have Inline child elements while a Figure (also an Inline element) can only have Block child elements. Un diagramme est donc utile pour déterminer rapidement quel élément peut être contenu dans un autre.Therefore, a diagram is useful for quickly determining what element can be contained in another. Par exemple, utilisons le diagramme pour déterminer comment construire le contenu dynamique d’un RichTextBox.As an example, let's use the diagram to determine how to construct the flow content of a RichTextBox.

1. Un RichTextBox doit contenir un FlowDocument qui doit à son tour contenir Blockun objet dérivé de.1. A RichTextBox must contain a FlowDocument which in turn must contain a Block-derived object. Voici le segment correspondant extrait du diagramme ci-dessus.Below is the corresponding segment from the diagram above.

![Schémas Règles]de relation contenant-contenu RichTextBox(./media/flow-ovw-schemawalkthrough1.png "Flow_Ovw_SchemaWalkThrough1")Diagram: RichTextBox containment rules

À ce stade, le balisage peut ressembler à ceci.Thus far, this is what the markup might look like.

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

2. D’après le diagramme, vous avez le Block choix Paragraphentre List Section Tableplusieurs éléments,,,, et BlockUIContainer (voir les classes dérivées de Block ci-dessus).2. According to the diagram, there are several Block elements to choose from including Paragraph, Section, Table, List, and BlockUIContainer (see Block-derived classes above). Supposons que nous voulons un Table.Let's say we want a Table. D’après le diagramme ci-dessus Table , un TableRowGroup contient TableRow un élément contenant des TableCell éléments qui contiennent des Blockéléments qui contiennent un objet dérivé de.According to the diagram above, a Table contains a TableRowGroup containing TableRow elements, which contain TableCell elements which contain a Block-derived object. Voici le segment Table correspondant pris dans le diagramme ci-dessus.Below is the corresponding segment for Table taken from the diagram above.

![Schémas Schéma/enfant parent pour la]table(./media/flow-ovw-schemawalkthrough2.png "Flow_Ovw_SchemaWalkThrough2")Diagram: Parent/child schema for Table

Le balisage correspondant est indiqué ci-dessous.Below is the corresponding markup.

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

3. Là encore, un ou Block plusieurs éléments sont requis sous TableCellun.3. Again, one or more Block elements are required underneath a TableCell. Pour simplifier, insérons du texte dans la cellule.To make it simple, let's place some text inside the cell. Nous pouvons le faire à l' Paragraph aide d' Run un avec un élément.We can do this using a Paragraph with a Run element. Voici les segments correspondants du Paragraph diagramme montrant qu’un peut accepter un Inline élément et qu’un Run (un Inline élément) ne peut prendre que du texte brut.Below is the corresponding segments from the diagram showing that a Paragraph can take an Inline element and that a Run (an Inline element) can only take plain text.

![Schémas Schéma/enfant parent pour le]paragraphe(./media/flow-ovw-schemawalkthrough3.png "Flow_Ovw_SchemaWalkThrough3")Diagram: Parent/child schema for Paragraph

Schémas Schéma/enfant parent pour RunDiagram: Parent/Child schema for Run

Le balisage de l’exemple complet est indiqué ci-dessous.Below is the entire example in markup.

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

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

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

Personnalisation du texteCustomizing Text

Généralement, le texte est le type de contenu le plus fréquent dans un document dynamique.Usually text is the most prevalent type of content in a flow document. Même si les objets décrits ci-dessus permettent de contrôler la plupart des aspects concernant la restitution du texte, il existe d’autres méthodes, décrites dans cette section, destinées à personnaliser le texte.Although the objects introduced above can be used to control most aspects of how text is rendered, there are some other methods for customizing text that is covered in this section.

Ornements de texteText Decorations

Les ornements de texte vous permettent d’appliquer au texte les effets suivants : souligné, ligne au-dessus, ligne de base et barré (consultez les images ci-dessous).Text decorations allow you to apply the underline, overline, baseline, and strikethrough effects to text (see pictures below). Ces décorations sont ajoutées à l' TextDecorations aide de la propriété qui est exposée par plusieurs Inlineobjets, TextBlocknotamment, TextBox Paragraph, et.These decorations are added using the TextDecorations property that is exposed by a number of objects including Inline, Paragraph, TextBlock, and TextBox.

L'exemple suivant montre comment définir la propriété TextDecorations d'un Paragraph.The following example shows how to set the TextDecorations property of a 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

La figure suivante montre le rendu de cet exemple.The following figure shows how this example renders.

![Capture d’écran Texte avec effet]barré par défaut(./media/inline-textdec-strike.png "Inline_TextDec_Strike")Screenshot: Text with default strikethrough effect

Les figures suivantes illustrent la façon dont les ornements de ligneet de ligne de basesont affichés respectivement.The following figures show how the Overline, Baseline, and Underline decorations render, respectively.

Capture d’écran Superline TextDecoratorScreenshot: Overline TextDecorator

![Capture d’écran Effet de ligne de base]par défaut sur le texte(./media/inline-textdec-base.png "Inline_TextDec_Base")Screenshot: Default baseline effect on text

![Capture d’écran Texte avec effet]de soulignement par défaut(./media/inline-textdec-under.png "Inline_TextDec_Under")Screenshot: Text with default underline effect

TypographieTypography

La Typography propriété est exposée par la plupart des contenus liés TextElementau Flow TextBlock, notamment TextBox, FlowDocument, et.The Typography property is exposed by most flow-related content including TextElement, FlowDocument, TextBlock, and TextBox. Cette propriété est utilisée pour contrôler les caractéristiques/variations typographiques de texte (en d’autres termes, petites ou grandes majuscules, exposants et indices, etc).This property is used to control typographical characteristics/variations of text (i.e. small or large caps, making superscripts and subscripts, etc).

L’exemple suivant montre comment définir l' Typography attribut à l’aide Paragraph de comme exemple d’élément.The following example shows how to set the Typography attribute, using Paragraph as the example element.

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

La figure suivante montre le rendu de cet exemple.The following figure shows how this example renders.

Capture d’écran Texte avec des de typographie modifiésScreenshot: Text with altered typography

Par contraste, l’illustration suivante montre comment s’affiche un exemple similaire avec des propriétés typographiques par défaut.In contrast, the following figure shows how a similar example with default typographic properties renders.

Capture d’écran Texte avec des de typographie modifiésScreenshot: Text with altered typography

L’exemple suivant montre comment définir la Typography propriété par programmation.The following example shows how to set the Typography property programmatically.

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

Pour plus d’informations sur la typographie, consultez typographie dans WPF .See Typography in WPF for more information on typography.

Voir aussiSee also