Nota
O acesso a esta página requer autorização. Pode tentar iniciar sessão ou alterar os diretórios.
O acesso a esta página requer autorização. Pode tentar alterar os diretórios.
Os documentos de fluxo são projetados para otimizar a visualização e a legibilidade. Em vez de serem definidos para um layout predefinido, os documentos de fluxo ajustam e refluem dinamicamente seu conteúdo com base em variáveis de tempo de execução, como tamanho da janela, resolução do dispositivo e preferências opcionais do usuário. Além disso, os documentos de fluxo oferecem recursos avançados de documentos, como paginação e colunas. Este tópico fornece uma visão geral dos documentos de fluxo e como criá-los.
O que é um documento de fluxo
Um documento de fluxo é projetado para "ajustar o conteúdo" dependendo do tamanho da janela, da resolução do dispositivo e de outras variáveis do ambiente. Além disso, os documentos de fluxo têm uma série de recursos integrados, incluindo pesquisa, modos de visualização que otimizam a legibilidade e a capacidade de alterar o tamanho e a aparência das fontes. Os documentos de fluxo são melhor utilizados quando a facilidade de leitura é o principal cenário de consumo de documentos. Por outro lado, os Documentos Fixos são projetados para ter uma apresentação estática. Os Documentos Fixos são úteis quando a fidelidade do conteúdo de origem é essencial. Consulte Documentos no WPF para obter mais informações sobre diferentes tipos de documentos.
A ilustração a seguir mostra um documento de fluxo de exemplo exibido em várias janelas de tamanhos diferentes. À medida que a área de exibição muda, o conteúdo ajusta-se para fazer o melhor uso do espaço disponível.
Como visto na imagem acima, o conteúdo de fluxo pode incluir muitos componentes, incluindo parágrafos, listas, imagens e muito mais. Esses componentes correspondem a elementos na marcação e objetos no código processual. Abordaremos essas classes em detalhes mais adiante na seção Classes relacionadas ao fluxo desta visão geral. Por enquanto, aqui está um exemplo de código simples que cria um documento de fluxo que consiste em um parágrafo com algum texto em negrito e uma lista.
<!-- 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
A ilustração abaixo mostra a aparência desse trecho de código.
Neste exemplo, o FlowDocumentReader controle é usado para hospedar o conteúdo do fluxo. Consulte Tipos de documento de fluxo para obter mais informações sobre controles de hospedagem de conteúdo de fluxo. Paragraph, List, ListItem, e Bold os elementos são usados para controlar a formatação de conteúdo, com base em sua ordem na marcação. Por exemplo, o Bold elemento se estende por apenas parte do texto no parágrafo, como resultado, apenas essa parte do texto está em negrito. Se você usou HTML, isso será familiar para você.
Como destacado na ilustração acima, há vários recursos incorporados aos Documentos de Fluxo:
Pesquisa: Permite ao usuário realizar uma pesquisa de texto completo de um documento inteiro.
Modo de visualização: O usuário pode selecionar seu modo de visualização preferido, incluindo um modo de visualização de página única (página de cada vez), um modo de visualização de duas páginas de cada vez (formato de leitura de livros) e um modo de visualização de rolagem contínua (sem fundo). Para obter mais informações sobre esses modos de exibição, consulte FlowDocumentReaderViewingMode.
Controles de navegação de página: Se o modo de exibição do documento usar páginas, os controles de navegação de página incluirão um botão para saltar para a próxima página (a seta para baixo) ou a página anterior (a seta para cima), bem como indicadores para o número de página atual e o número total de páginas. Folhear páginas também pode ser feito usando as teclas de seta do teclado.
Zoom: Os controles de zoom permitem que o usuário aumente ou diminua o nível de zoom clicando nos botões de mais ou menos, respectivamente. Os controles de zoom também incluem um controle deslizante para ajustar o nível de zoom. Para obter mais informações, consulte Zoom.
Esses recursos podem ser modificados com base no controle usado para hospedar o conteúdo do fluxo. A próxima seção descreve os diferentes controles.
Tipos de documentos de fluxo
A exibição do conteúdo do documento de fluxo e como ele aparece depende do objeto usado para hospedar o conteúdo do fluxo. Há quatro controles que oferecem suporte à visualização de conteúdo de fluxo: FlowDocumentReader, FlowDocumentPageViewer, RichTextBoxe FlowDocumentScrollViewer. Estes controlos são descritos sucintamente a seguir.
Observação
FlowDocument é necessário para hospedar diretamente o conteúdo de fluxo, por isso, todos estes controles de visualização consomem um FlowDocument para permitir a hospedagem de conteúdo de fluxo.
FlowDocumentReader
FlowDocumentReader Inclui recursos que permitem ao usuário escolher dinamicamente entre vários modos de visualização, incluindo um modo de visualização de página única (página de cada vez), um modo de visualização de duas páginas por vez (formato de leitura de livros) e um modo de visualização de rolagem contínua (sem fundo). Para obter mais informações sobre esses modos de exibição, consulte FlowDocumentReaderViewingMode. Caso não necessite da capacidade de alternar dinamicamente entre diferentes modos de visualização, FlowDocumentPageViewer e FlowDocumentScrollViewer fornecem visualizadores de conteúdo de fluxo mais leves que estão fixados num modo de visualização específico.
FlowDocumentPageViewer e FlowDocumentScrollViewer
FlowDocumentPageViewer mostra o conteúdo no modo de visualização de página por vez, enquanto FlowDocumentScrollViewer mostra o conteúdo no modo de rolagem contínua. Ambos FlowDocumentPageViewer e FlowDocumentScrollViewer são fixados a um modo de visualização específico. Compare com FlowDocumentReader, que inclui recursos que permitem ao usuário escolher dinamicamente entre vários modos de visualização (conforme fornecido pela FlowDocumentReaderViewingMode enumeração), ao custo de ser mais intensivo em recursos do que FlowDocumentPageViewer ou FlowDocumentScrollViewer.
Por padrão, uma barra de rolagem vertical é sempre mostrada e uma barra de rolagem horizontal torna-se visível, se necessário. A interface do usuário padrão para FlowDocumentScrollViewer não inclui uma barra de ferramentas, no entanto, a IsToolBarVisible propriedade pode ser usada para habilitar uma barra de ferramentas interna.
Caixa de Texto Rich (RichTextBox)
Você usa um RichTextBox quando deseja permitir que o usuário edite o conteúdo do fluxo. Por exemplo, se quisesse criar um editor que permitisse que um utilizador manipulasse elementos como tabelas, formatação em itálico e negrito, etc., usaria um RichTextBox. Consulte Visão geral do RichTextBox para obter mais informações.
Observação
O conteúdo de fluxo dentro de um RichTextBox não se comporta exatamente como o conteúdo de fluxo contido em outros controles. Por exemplo, não há colunas em um RichTextBox e, portanto, nenhum comportamento de redimensionamento automático. Além disso, os recursos normalmente incorporados do conteúdo de fluxo, como pesquisa, modo de visualização, navegação de página e zoom, não estão disponíveis em um RichTextBox.
Criando conteúdo de fluxo
O conteúdo de fluxo pode ser complexo, consistindo em vários elementos, incluindo texto, imagens, tabelas e até mesmo UIElement classes derivadas, como controles. Para entender como criar conteúdo de fluxo complexo, os seguintes pontos são críticos:
Classes relacionadas ao fluxo: Cada classe usada no conteúdo do fluxo tem uma finalidade específica. Além disso, a relação hierárquica entre classes de fluxo ajuda a entender como elas são usadas. Por exemplo, classes derivadas da Block classe são usadas para conter outros objetos, enquanto classes derivadas de Inline contêm objetos que são exibidos.
Esquema de conteúdo: um documento de fluxo pode exigir um número substancial de elementos aninhados. O esquema de conteúdo especifica possíveis relações pai/filho entre elementos.
As seções a seguir abordarão cada uma dessas áreas com mais detalhes.
Classes relacionadas ao fluxo
O diagrama abaixo mostra os objetos mais normalmente usados com conteúdo de fluxo:
Para efeitos de fluxo de conteúdo, existem duas categorias importantes:
Classes derivadas de blocos: também chamadas de "Elementos de conteúdo de bloco" ou apenas "Elementos de bloco". Os elementos que herdam de Block podem ser usados para agrupar elementos sob um pai comum ou para aplicar atributos comuns a um grupo.
Classes derivadas em linha: também chamadas de "elementos de conteúdo embutidos" ou apenas "elementos embutidos". Os elementos que herdam de Inline estão contidos em um elemento de bloco ou outro elemento embutido. Os elementos em linha são frequentemente usados como o contentor direto de conteúdo que é renderizado no ecrã. Por exemplo, um Paragraph (Block Element) pode conter um Run (Inline Element), mas o Run realmente contém o texto que é renderizado na tela.
Cada classe nestas duas categorias é descrita sucintamente abaixo.
Classes derivadas de blocos
N.º
Paragraph é normalmente usado para agrupar o conteúdo em um parágrafo. O uso mais simples e comum de Parágrafo é criar um parágrafo de texto.
<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
No entanto, você também pode conter outros elementos derivados de inline, como verá abaixo.
Seção
Section é usado apenas para conter outros Blockelementos derivados. Ele não aplica nenhuma formatação padrão aos elementos que contém. No entanto, quaisquer valores de propriedade definidos em um Section se aplicam aos seus elementos filho. Uma seção também permite que você itere programaticamente através de sua coleção filho. Section é usado semelhantemente à <tag DIV> em HTML.
No exemplo abaixo, três parágrafos são definidos em um Section. A seção tem um Background valor de propriedade de Vermelho, portanto, a cor de fundo dos parágrafos também é vermelha.
<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 permite que UIElement elementos (ou seja, um Button) sejam incorporados no conteúdo de fluxo derivado de blocos. InlineUIContainer (ver abaixo) é utilizado para incorporar UIElement elementos no conteúdo de fluxo derivado em linha. BlockUIContainer e InlineUIContainer são importantes porque não há outra maneira de usar um UIElement conteúdo em fluxo a menos que ele esteja contido em um desses dois elementos.
O exemplo a seguir mostra como usar o elemento para hospedar BlockUIContainer objetos dentro do UIElement conteúdo de fluxo.
<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>
A figura a seguir mostra como este exemplo é renderizado:
Lista
List é usado para criar uma lista numérica ou com marcadores. Defina a MarkerStyle propriedade como um TextMarkerStyle valor de enumeração para determinar o estilo da lista. O exemplo abaixo mostra como criar uma lista simples.
<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
Observação
List é o único elemento de fluxo que usa o ListItemCollection para gerenciar elementos filho.
Tabela
Table é usado para criar uma tabela. Table é semelhante ao Grid elemento, mas tem mais capacidades e, portanto, requer maior sobrecarga de recursos. Como Grid é um UIElement, ele não pode ser usado no conteúdo de fluxo, a menos que esteja contido em um BlockUIContainer ou InlineUIContainer. Para mais informações sobre Table, consulte a Visão geral da Tabela.
Classes derivadas em linha
Executar
Run é usado para conter texto não formatado. Pode esperar que os objetos Run sejam usados extensivamente no conteúdo de fluxo. No entanto, na marcação, não é necessário usar explicitamente os elementos Run. Run é necessário para ser usado ao criar ou manipular documentos de fluxo usando código. Por exemplo, na marcação abaixo, o primeiro Paragraph especifica o Run elemento explicitamente, enquanto o segundo não. Ambos os parágrafos geram resultados idênticos.
<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>
Observação
A partir do .NET Framework 4, a propriedade Text do objeto Run é uma propriedade de dependência. Você pode vincular a Text propriedade a uma fonte de dados, como um TextBlockarquivo . A Text propriedade suporta totalmente a vinculação unidirecional. A Text propriedade também suporta vinculação bidirecional, exceto para RichTextBox. Para obter um exemplo, consulte Run.Text.
Extensão
Span agrupa outros elementos de conteúdo embutidos. Nenhuma renderização inerente é aplicada ao conteúdo dentro de um Span elemento. No entanto, os elementos que herdam de Span incluindo Hyperlink, Bold, Italic e Underline aplicam formatação ao texto.
Abaixo está um exemplo de um Span ser usado para conter conteúdo embutido, incluindo texto, Bold elemento e um Button arquivo.
<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>
A captura de tela a seguir mostra como este exemplo é renderizado.
InlineUIContainer
InlineUIContainer permite que UIElement elementos (ou seja, um controle como Button) sejam incorporados em um Inline elemento de conteúdo. Este elemento é o equivalente embutido ao BlockUIContainer descrito acima. Abaixo está um exemplo que usa InlineUIContainer para inserir um Button em linha em um 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
Observação
InlineUIContainer não precisa ser usado explicitamente na marcação. Se omiti-lo, um InlineUIContainer será criado de qualquer forma quando o código for compilado.
Figura e elemento flutuante
Figure e Floater são usados para incorporar conteúdo em Documentos de Fluxo com propriedades de posicionamento que podem ser personalizadas independentemente do fluxo de conteúdo principal. Figure ou Floater elementos são frequentemente usados para destacar ou acentuar partes do conteúdo, para hospedar imagens de suporte ou outro conteúdo dentro do fluxo de conteúdo principal, ou para injetar conteúdo vagamente relacionado, como anúncios.
O exemplo a seguir mostra como incorporar um Figure em um parágrafo de texto.
<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
A ilustração a seguir mostra como este exemplo é renderizado.
Figure e Floater diferem de várias maneiras e são usados para diferentes cenários.
Figura:
Pode ser posicionado: você pode definir suas âncoras horizontais e verticais para encaixá-lo em relação à página, conteúdo, coluna ou parágrafo. Você também pode usar suas HorizontalOffset propriedades e VerticalOffset para especificar deslocamentos arbitrários.
Pode ser dimensionado para mais de uma coluna: é possível definir a altura e largura de Figure para múltiplos da altura ou largura da página, do conteúdo ou da coluna. Note que, no caso de página e conteúdo, não são permitidos múltiplos superiores a 1. Por exemplo, você pode definir a largura de um Figure como "0,5 página" ou "0,25 conteúdo" ou "2 colunas". Você também pode definir altura e largura para valores absolutos de pixel.
Não paginar: Se o conteúdo dentro de um Figure não se encaixar dentro do Figure, ele renderizará qualquer conteúdo que se encaixar e o conteúdo restante será perdido
Flutuador:
Não pode ser posicionado e renderizará onde quer que o espaço possa ser disponibilizado para ele. Não é possível definir o deslocamento ou ancorar um Floater.
Não pode ser dimensionado para mais de uma coluna: Por padrão, Floater é dimensionado para uma coluna. Tem uma Width propriedade que pode ser definida para um valor absoluto em pixels, mas se esse valor for maior que uma largura de coluna, será ignorado e o flutuador será ajustado para uma única coluna. Você pode dimensioná-lo para menos de uma coluna definindo a largura correta do pixel, mas o dimensionamento não é relativo à coluna, portanto, "0,5Coluna" não é uma expressão válida para Floater largura. Floater não tem propriedade height e sua altura não pode ser definida, sua altura depende do conteúdo
Floater pagina: Se o seu conteúdo na largura especificada se estender além de uma altura de coluna, o elemento flutuante quebra e pagina para a próxima coluna, para a próxima página, etc.
Figure é um bom lugar para colocar conteúdo autônomo onde você deseja controlar o tamanho e o posicionamento, e está confiante de que o conteúdo se encaixará no tamanho especificado. Floater é um bom lugar para colocar mais conteúdo de fluxo livre que flui de forma semelhante ao conteúdo da página principal, mas é separado dele.
Quebra de linha
LineBreak faz com que ocorra uma quebra de linha no conteúdo do fluxo. O exemplo a seguir demonstra o uso de 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>
A captura de tela a seguir mostra como este exemplo é renderizado.
Elementos de coleção de fluxo
Em muitos dos exemplos acima, o BlockCollection e InlineCollection são usados para construir conteúdo de fluxo programaticamente. Por exemplo, para adicionar elementos a um Paragraph, você pode usar a sintaxe:
myParagraph.Inlines.Add(new Run("Some text"));
Isso adiciona um Run ao InlineCollection do Paragraph. Isso é o mesmo que o implícito Run encontrado dentro de uma Paragraph numa marcação.
<Paragraph>
Some Text
</Paragraph>
Como exemplo de uso do BlockCollection, o exemplo a seguir cria um novo Section e, em seguida, usa o método Add para adicionar um novo Paragraph ao Section conteúdo.
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...")))
Além de adicionar itens a uma coleção de fluxo, você também pode remover itens. O exemplo a seguir exclui o último elemento Inline no Span.
spanx.Inlines.Remove(spanx.Inlines.LastInline);
spanx.Inlines.Remove(spanx.Inlines.LastInline)
O exemplo a seguir limpa todo o conteúdo (elementosInline) do Span.
spanx.Inlines.Clear();
spanx.Inlines.Clear()
Ao trabalhar com conteúdo de fluxo programaticamente, você provavelmente fará uso extensivo dessas coleções.
Se um elemento de fluxo usa um InlineCollection (Inlines) ou BlockCollection (Blocks) para conter seus elementos filho depende do tipo de elementos filho (Block ou Inline) que podem ser contidos pelo pai. As regras de contenção para elementos de conteúdo de fluxo são resumidas no esquema de conteúdo na próxima seção.
Observação
Há um terceiro tipo de coleção usado com conteúdo de fluxo, o ListItemCollection, mas essa coleção só é usada com um List. Além disso, existem várias coleções usadas com Table. Consulte Visão geral da tabela para obter mais informações.
Esquema de conteúdo
Dado o número de diferentes elementos de conteúdo de fluxo, pode ser difícil acompanhar os tipos de elementos filho que um elemento pode conter. O diagrama abaixo resume as regras de contenção para elementos de fluxo. As setas representam as possíveis relações pai/filho.
Diagrama 
Como pode ser visto no diagrama acima, os sub-elementos permitidos num elemento não são necessariamente determinados pelo facto de ser um elemento Block ou um elemento Inline. Por exemplo, um Span (um Inline elemento) só pode ter Inline elementos filho enquanto um Figure (também um Inline elemento) só pode ter Block elementos filho. Portanto, um diagrama é útil para determinar rapidamente qual elemento pode ser contido em outro. Como exemplo, vamos usar o diagrama para determinar como construir o conteúdo de fluxo de um RichTextBox.
1. A RichTextBox deve conter um FlowDocument que, por sua vez, deve conter um Blockobjeto derivado. Abaixo está o segmento correspondente do diagrama acima.
Diagrama 
Até agora, esta é a aparência que a marcação poderia ter.
<RichTextBox>
<FlowDocument>
<!-- One or more Block-derived object… -->
</FlowDocument>
</RichTextBox>
2. De acordo com o diagrama, há vários Block elementos para escolher, incluindo Paragraph, Section, Table, List, e BlockUIContainer (ver classes derivadas de blocos acima). Digamos que queremos um Table. De acordo com o diagrama acima, um Table contém um TableRowGroup que contém elementos TableRow, que contêm elementos TableCell que contêm um objeto derivado de Block. Abaixo está o segmento correspondente para Table retirado do diagrama acima.
Diagrama 
Abaixo está a marcação correspondente.
<RichTextBox>
<FlowDocument>
<Table>
<TableRowGroup>
<TableRow>
<TableCell>
<!-- One or more Block-derived object… -->
</TableCell>
</TableRow>
</TableRowGroup>
</Table>
</FlowDocument>
</RichTextBox>
3. Mais uma vez, um ou mais Block elementos são necessários por baixo de um TableCell. Para simplificar, vamos colocar algum texto dentro da célula. Podemos fazer isso usando um Paragraph com um elemento Run. Abaixo estão os segmentos correspondentes do diagrama mostrando que um Paragraph pode tomar um Inline elemento e que um Run (um Inline elemento) só pode ter texto simples.
Diagrama 
Diagrama 
Abaixo está o exemplo completo em linguagem de marcação.
<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>
Personalizando texto
Normalmente, o texto é o tipo de conteúdo mais prevalente em um documento de fluxo. Embora os objetos introduzidos acima possam ser usados para controlar a maioria dos aspetos de como o texto é renderizado, existem alguns outros métodos para personalizar o texto abordados nesta seção.
Decorações de Texto
As decorações de texto permitem aplicar os efeitos de sublinhado, sobrelinha, barra de base e riscado ao texto (veja as imagens abaixo). Essas decorações são adicionadas usando a TextDecorations propriedade que é exposta por vários objetos, incluindo Inline, Paragraph, TextBlock, e TextBox.
O exemplo a seguir mostra como configurar a TextDecorations propriedade de um 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
A figura a seguir mostra como este exemplo é renderizado.
As figuras a seguir mostram como as decorações Overline, Baseline e Underline são renderizadas, respectivamente.
Tipografia
A Typography propriedade é exposta pela maioria dos conteúdos relacionados ao fluxo, incluindo TextElement, FlowDocument, TextBlocke TextBox. Esta propriedade é usada para controlar as características tipográficas/variações do texto (ou seja, letras maiúsculas ou grandes, criação de sobrescritos e subscritos, etc.).
O exemplo a seguir mostra como definir o atributo Typography, usando Paragraph como o elemento de exemplo.
<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>
A figura a seguir mostra como este exemplo é renderizado.
Por outro lado, a figura a seguir mostra como um exemplo semelhante com propriedades tipográficas padrão é renderizado.
O exemplo a seguir mostra como definir a propriedade Typography programaticamente.
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
Consulte Tipografia no WPF para obter mais informações sobre tipografia.
Ver também
Colabore connosco no GitHub
A origem deste conteúdo pode ser encontrada no GitHub, onde também pode criar e rever problemas e pedidos Pull. Para mais informações, consulte o nosso guia do contribuidor.
.NET Desktop feedback