O controle Label

O controle Label, em sua forma mais simples, será muito parecido com o TextBlock que usamos em outro artigo. Você notará rapidamente que, em vez de uma propriedade Text, o Label possui uma propriedade Content. A razão para isso é que o Label pode hospedar qualquer tipo de controle diretamente dentro dele, em vez de apenas texto. Este conteúdo também pode ser uma string, como você verá neste primeiro e bem básico exemplo:

<Window x:Class="WpfTutorialSamples.Basic_controls.LabelControlSample"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="LabelControlSample" Height="100" Width="200">
    <Grid>
		<Label Content="This is a Label control." />
	</Grid>
</Window>

Outra coisa que você pode notar é o fato de que o Label, por padrão, tem um pouco de padding, permitindo que o texto seja renderizado a alguns pixels de distância do canto superior esquerdo. Este não é o caso do controle TextBlock, onde você terá que especificá-lo manualmente.

Num caso simples como este, onde o conteúdo é simplesmente uma string, o Label criará um TextBlock internamente e mostrará sua string nele.

O controle Label vs. o controle TextBlock

Então, por que usar um Label? Bem, existem algumas diferenças importantes entre o Label e o TextBlock. O TextBlock só permite renderizar uma string de texto, enquanto o Label também permite:

• Especificar uma borda
• Renderizar outros controles por exemplo uma imagem
• Usar um template como conteúdo através da propriedade ContentTemplate
• Usar as teclas de atalhos para dar foco aos controles relacionados

O último ponto é na verdade, uma das principais razões para se usar um rótulo ao invés de um TextBlock. Sempre que você quiser apenas renderizar um texto simples, use o controle TextBlock, pois ele é mais claro e tem um desempenho melhor do que o Label na maioria dos casos.

Label e Teclas de Atalho (mnemônicos)

No Windows assim como em outros sistemas operacionais, é comum que você possa acessar os controles em uma caixa de diálogo mantendo pressionada a tecla [Alt] e, em seguida, pressionando um caractere que corresponda ao controle que você deseja acessar. O caractere a ser pressionado será destacado quando você pressionar a tecla [Alt]. Os controles TextBlock não suportam essa funcionalidade, mas o Label sim, portanto, para rótulos de controle, o controle Label geralmente é uma excelente opção. Vamos ver um exemplo disso em ação:

<Window x:Class="WpfTutorialSamples.Basic_controls.LabelControlSample"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="LabelControlSample" Height="180" Width="250">
	<StackPanel Margin="10">
		<Label Content="_Name:" Target="{Binding ElementName=txtName}" />
		<TextBox Name="txtName" />
		<Label Content="_Mail:" Target="{Binding ElementName=txtMail}" />
		<TextBox Name="txtMail" />
	</StackPanel>
</Window>

A imagem mostra nossa caixa de diálogo de exemplo e como ela fica quando a tecla Alt é pressionada. Tente executá-la, mantendo pressionada a tecla [Alt] e, em seguida, pressionando N e M. Você verá como o foco é movido entre as duas caixas de texto.

Então, aqui temos vários conceitos novos. Primeiro de tudo, definimos a tecla de atalho colocando um sublinhado (_) antes do caractere. Não precisa ser o primeiro caractere, pode ser antes de qualquer um dos caracteres no conteúdo da sua etiqueta. O normal é usar o primeiro caractere que ainda não foi usado como atalho para outro controle.

Usamos a propriedade Target para conectar o Label e o controle ao qual ele se refere. Usamos uma ligação padrão do WPF para isso, usando a propriedade ElementName, que iremos descrever mais adiante neste tutorial. A ligação é baseada no nome do controle, portanto, se você alterar esse nome, também precisará lembrar de alterar a ligação.

Usando controles como conteúdo do Label

Como já mencionado, o controle Label permite que você hospede outros controles, mantendo os outros benefícios. Vamos tentar um exemplo em que temos uma imagem e um texto dentro do rótulo, além de ter um atalho para cada um dos rótulos:

<Window x:Class="WpfTutorialSamples.Basic_controls.LabelControlAdvancedSample"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="LabelControlAdvancedSample" Height="180" Width="250">
	<StackPanel Margin="10">
		<Label Target="{Binding ElementName=txtName}">
			<StackPanel Orientation="Horizontal">
				<Image Source="http://cdn1.iconfinder.com/data/icons/fatcow/16/bullet_green.png" />
				<AccessText Text="_Name:" />
			</StackPanel>
		</Label>
		<TextBox Name="txtName" />
		<Label Target="{Binding ElementName=txtMail}">
			<StackPanel Orientation="Horizontal">
				<Image Source="http://cdn1.iconfinder.com/data/icons/fatcow/16/bullet_blue.png" />
				<AccessText Text="_Mail:" />
			</StackPanel>
		</Label>
		<TextBox Name="txtMail" />
	</StackPanel>
</Window>

Esta é apenas uma versão estendida do exemplo anterior - em vez de uma simples string de texto, nosso Label agora hospedará tanto uma imagem quanto um trecho de texto (dentro do controle AccessText, que nos permite ainda usar uma chave de acesso para o rótulo). Ambos os controles estão dentro de um StackPanel horizontal, já que o Label, assim como qualquer outro derivado do ContentControl, pode hospedar somente um controle filho direto.

O controle Image, descrito mais adiante neste tutorial, usa uma imagem remota - isso é APENAS para fins demonstrativos e NÃO é uma boa ideia para a maioria dos aplicativos da vida real.

Resumo

Na maioria das situações, o controle Label faz exatamente o que o nome indica: ele age como um rótulo de texto para outro controle. Este é o objetivo principal disso. Para a maioria dos outros casos, você provavelmente deve usar um controle TextBlock ou um dos outros contêineres de texto que o WPF oferece.