O controle TextBlock - Formatação inline

No último artigo, examinamos a funcionalidade principal do controle TextBlock: exibir uma string simples e ajusta-la, se necessário. Nós ainda usamos outra cor além daquela padrão para renderizar o texto, mas e se você quisesse fazer mais do que apenas definir uma cor estática para todo o texto no TextBlock?

Felizmente, o controle TextBlock suporta conteúdo in-line. Essas pequenas construções de controle herdam todas da classe Inline, o que significa que elas podem ser renderizadas em linha, como parte de um texto maior. Até o momento, os elementos suportados incluem AnchoredBlock, Bold, Hyperlink, InlineUIContainer, Itálico, LineBreak, Run, Span e Underline. Nos exemplos a seguir, vamos dar uma olhada na maioria deles.

Negrito, Itálico e Sublinhado

Estes são provavelmente os tipos mais simples de elementos inline. Os nomes devem dizer muito sobre o que eles fazem, mas ainda daremos um exemplo rápido de como usá-los:

<Window x:Class="WpfTutorialSamples.Basic_controls.TextBlockInlineSample"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="TextBlockInlineSample" Height="100" Width="300">
    <Grid>
		<TextBlock Margin="10" TextWrapping="Wrap">
			TextBlock with <Bold>bold</Bold>, <Italic>italic</Italic> and <Underline>underlined</Underline> text.
		</TextBlock>
    </Grid>
</Window>

Assim como no HTML, você apenas coloca seu texto em uma tag em negrito para obter texto em negrito e assim por diante. Isso torna muito fácil criar e exibir diversos textos em seus aplicativos.

Todas essas três tags são apenas classes filho do elemento Span, cada uma definindo uma propriedade específica no elemento Span para criar o efeito desejado. Por exemplo, a tag Negrito apenas define a propriedade FontWeight no elemento Span subjacente, o elemento Itálico define o FontStyle e assim por diante.

Quebra de linha

Simplesmente insere uma quebra de linha no texto. Por favor, veja o capítulo anterior para um exemplo em que usamos o elemento LineBreak.

Hyperlink

O elemento Hyperlink permite que você tenha links em seu texto. É renderizado com um estilo que se adapte ao seu tema atual do Windows, que geralmente será algum tipo de texto azul sublinhado com um efeito de foco vermelho e um cursor de mouse de mão. Você pode usar a propriedade NavigateUri para definir o URL que você deseja navegar. Aqui está um exemplo:

<Window x:Class="WpfTutorialSamples.Basic_controls.TextBlockHyperlinkSample"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="TextBlockHyperlinkSample" Height="100" Width="300">
	<Grid>
		<TextBlock Margin="10" TextWrapping="Wrap">
			This text has a <Hyperlink RequestNavigate="Hyperlink_RequestNavigate" NavigateUri="https://www.google.com">link</Hyperlink> in it.
		</TextBlock>
	</Grid>
</Window>

O hiperlink também é usado dentro de páginas do WPF, onde ele pode ser usado para navegar entre as páginas. Nesse caso, você não precisará manipular especificamente o evento RequestNavigate, como fazemos no exemplo, mas para acessar URLs externas de um aplicativo WPF comum, precisamos de um pouco de ajuda desse evento e da classe Process. Assinamos o evento RequestNavigate, que nos permite acessar a URL vinculada no navegador padrão dos usuários com um manipulador de eventos simples como este no código por trás do arquivo:

private void Hyperlink_RequestNavigate(object sender, System.Windows.Navigation.RequestNavigateEventArgs e)
{
	System.Diagnostics.Process.Start(e.Uri.AbsoluteUri);
}

Run

O elemento Run permite que você estilize uma string usando todas as propriedades disponíveis do elemento Span, mas enquanto o elemento Span pode conter outros elementos inline, um elemento Run só pode conter texto simples. Isso torna o elemento Span mais flexível e, portanto, a escolha lógica na maioria dos casos.

Span

O elemento Span não tem nenhuma renderização específica por padrão, mas permite que você defina praticamente qualquer tipo de renderização específica, incluindo tamanho da fonte, estilo e peso, cores de fundo e primeiro plano e assim por diante. O melhor do elemento Span é que ele permite outros elementos in-line, facilitando até mesmo combinações avançadas de texto e estilo. No exemplo a seguir, usei muitos elementos Span para mostrar algumas das muitas possibilidades ao usar elementos Span inline:

<Window x:Class="WpfTutorialSamples.Basic_controls.TextBlockSpanSample"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="TextBlockSpanSample" Height="100" Width="300">
    <Grid>
		<TextBlock Margin="10" TextWrapping="Wrap">
			This <Span FontWeight="Bold">is</Span> a
			<Span Background="Silver" Foreground="Maroon">TextBlock</Span>
			with <Span TextDecorations="Underline">several</Span>
			<Span FontStyle="Italic">Span</Span> elements,
			<Span Foreground="Blue">
				using a <Bold>variety</Bold> of <Italic>styles</Italic>
			</Span>.
		</TextBlock>
	</Grid>
</Window>

Então, como você pode ver, se na sua situação nenhum dos outros elementos fizer sentido ou se você apenas quiser uma tela em branco ao começar a formatar seu texto, o elemento Span é uma ótima escolha.

Formatando texto no Code-behind

Como você pode ver, a formatação de texto através de XAML é muito fácil, mas em alguns casos, você pode preferir ou até mesmo fazer isso a partir do seu arquivo Code-Behind. Isso é um pouco mais complicado, mas aqui está um exemplo de como você pode fazer isso:

<Window x:Class="WpfTutorialSamples.Basic_controls.TextBlockCodeBehindSample"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="TextBlockCodeBehindSample" Height="100" Width="300">
    <Grid></Grid>
</Window>

using System;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Media;

namespace WpfTutorialSamples.Basic_controls
{
	public partial class TextBlockCodeBehindSample : Window
	{
		public TextBlockCodeBehindSample()
		{
			InitializeComponent();
			TextBlock tb = new TextBlock();
			tb.TextWrapping = TextWrapping.Wrap;
			tb.Margin = new Thickness(10);
			tb.Inlines.Add("An example on ");
			tb.Inlines.Add(new Run("the TextBlock control ") { FontWeight = FontWeights.Bold });
			tb.Inlines.Add("using ");
			tb.Inlines.Add(new Run("inline ") { FontStyle = FontStyles.Italic });
			tb.Inlines.Add(new Run("text formatting ") { Foreground = Brushes.Blue });
			tb.Inlines.Add("from ");
			tb.Inlines.Add(new Run("Code-Behind") { TextDecorations = TextDecorations.Underline });
			tb.Inlines.Add(".");
			this.Content = tb;
		}
	}
}

É ótimo ter a possibilidade, e pode fazer isso se necessário em alguns casos, mas esse exemplo provavelmente fará você apreciar ainda mais o XAML.