TextBlock kontrollen - indlejret formattering

I den sidste artikel så vi på den grundlæggende funktionalitet i TextBlock kontrollen: Visning af en simpel streng og ombrydning af den om nødvendigt. Vi brugte endda en anden farve end standard-farve til visning af teksten, men hvad nu, hvis du ønsker mere end blot at definere en statisk farve for al teksten i TextBlock kontrollen?

Heldigvis understøtter TextBlock kontrollen indlejret indhold. Disse små kontrol-lignende elementer nedarver alle fra Inline klassen, hvilket betyder, at de kan vises indlejret som en del af en større tekst. For nuværende inkluderer de understøttede elementer AnchoredBlock, Bold, HyperLink, InlineUIContainer, Italic, LineBreak, Run, Span og Underline. I de følgende eksempler vil vi se på de fleste af dem.

Bold, Italic og Underline

Disse er sandsynligvis de mest simple typer af indlejrede elementer. Navnene burde fortælle en del om hvad, de gør, men vi vil stadig give dig et hurtigt eksempel på deres anvendelse:

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

Ganske som i HTML omkranser du din tekst med et Bold tag for at få fed skrift og så videre. Dette gør det meget let at oprette og vise diverse tekster i dine applikationer.

Alle disse tre tags er blot underklasser af Span elementet, som hver især sætter en specifik egenskab på Span elementet for at skabe den ønskede effekt. For eksempel sætter Bold elementet kun FontWeight egenskaben på det underliggende Span element, Italic elementet sætter FontStyle og så videre.

LineBreak

Indsætter ganske simpelt et linjeskift i teksten. Se forrige afsnit for et eksempel, hvor vi bruger LineBreak elementet

Hyperlink

Hyperlink elementet giver dig mulighed for at have links i teksten. Det bliver vist med en stil, som passer med det aktuelle Windows tema, hvilket normalt vil være en slags understreget blå tekst med en rød hover effekt og en hånd-cursor. Du kan bruge NavigateUri egenskaben til at definere den URL, du ønsker at navigere til. Her er et eksempel:

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

Hyperlink bruges også inde i WPF Page's, hvor det kan bruges til at navigere mellem sider. I det tilfælde behøver du ikke specifikt håndtere RequestNavigate hændelsen, som vi gør i eksemplet, men for at starte eksterne URL's fra en regulær WPF applikation, har vi brug for lidt hjælp fra denne hændelse og Process klassen. Vi abonnerer på RequestNavigate hændelsen, som tillader os at starte den tilknyttede URL i brugerens standardbrowser med en simpel hændelses-håndtering som denne i code-behind filen:

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

Run

Run elementet tillader dig at formattere en streng ved hjælp af de tilgængelige egenskaber på Span elementet, men mens Span elementet kan indeholde andre indlejrede elementet, kan Run elementet kun indeholde ren tekst. Dette gør Span elementet mere fleksibelt og derfor det logiske valg i de fleste tilfælde

Span

Span elementet har ikke en specifik visning som standard, men tillader dig at sætte næsten en hvilken som helst specifik visning inklusive fontstørrelse, -stil og -vægt, baggrunds- og forgrundsfarve og så videre. Det fede ved Span elementet er, at det tillader andre indlejrede elementer inde i det, hvilket gør det let at lave selv avancerede kombinationer af tekst og formattering. I det følgende eksempel har jeg brugt mange Span elementer for at vise dig nogle af de mange muligheder ved brug af indlejrede Span elementer:

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

Så som du kan se, hvis ingen af de andre elementer giver mening i din situation eller du ønsker et blankt lærred fra start ved formattering af din tekst, er Span elementet et storartet valg.

Formattering af tekst fra C#/code-behind

Som du kan se, er formattering af tekst via XAML meget let, men i nogle tilfælde ønsker du eller har endda brug for at gøre det fra din C#/code-behind fil. Dette er lidt mere omstændeligt, men her er et eksempel på hvordan, du kan gøre det:

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

Det er godt at have muligheden, og det kan være nødvendigt at gøre det på denne måde i nogle tilfælde, men dette eksempel vil sikkert få dig til at værdsætte XAML endnu mere.