The TextBlock control - Inline formatting

पिछले लेख में हमने टेक्स्टब्लॉक नियंत्रण की मुख्य कार्यक्षमता को देखा: यदि आवश्यक हो तो एक साधारण स्ट्रिंग प्रदर्शित करना और इसे wrap करना । हमने पाठ को रेंडर करने के लिए डिफ़ॉल्ट की तुलना में एक और रंग का भी उपयोग किया, लेकिन क्या होगा यदि आप टेक्स्टब्लॉक के सभी text के लिए केवल एक स्थिर रंग को परिभाषित करना चाहते हैं?

Luckily the TextBlock control supports inline elements. These small control-like constructs all inherit from the Inline class, which means that they can be rendered inline, as a part of a larger text. As of writing, the supported elements include AnchoredBlock, Bold, Hyperlink, InlineUIContainer, Italic, LineBreak, Run, Span, and Underline. In the following examples, we'll have a look at most of them.

Bold, Italic and Underline

ये शायद सबसे सरल प्रकार के इनलाइन elements हैं। नाम आपको बताएंगे कि वे क्या करते हैं, लेकिन हम अभी भी आपको उनका उपयोग करने के तरीके के बारे में एक त्वरित उदाहरण देंगे:

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

बहुत कुछ HTML जैसा ही, आप केवल बोल्ड टैग और इतने पर पाने के लिए अपने टेक्स्ट को बोल्ड टैग के साथ घेरते हैं। यह आपके एप्लिकेशन में विविध text बनाने और प्रदर्शित करने के लिए बहुत आसान बनाता है।

All three of these tags are just child classes of the Span element, each setting a specific property on the Span element to create the desired effect. For instance, the Bold tag just sets the FontWeight property on the underlying Span element, the Italic element sets the FontStyle and so on.

LineBreak

बस text में एक पंक्ति विराम सम्मिलित करता है। कृपया पिछले अध्याय को एक उदाहरण के लिए देखें, जहाँ हम लाइनब्रेक तत्व का उपयोग करते हैं।

Hyperlink

The Hyperlink element allows you to have links in your text. It's rendered with a style that suits your current Windows theme, which will usually be some sort of underlined blue text with a red hover effect and a hand mouse cursor. You can use the NavigateUri property to define the URL that you wish to navigate to. Here's an example:

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

The Hyperlink is also used inside of WPF Page's, where it can be used to navigate between pages. In that case, you won't have to specifically handle the RequestNavigate event, like we do in the example, but for launching external URL's from a regular WPF application, we need a bit of help from this event and the Process class. We subscribe to the RequestNavigate event, which allows us to launch the linked URL in the users default browser with a simple event handler like this one in the code behind file:

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

Run

The Run element allows you to style a string using all the available properties of the Span element, but while the Span element may contain other inline elements, a Run element may only contain plain text. This makes the Span element more flexible and therefore the logical choice in most cases.

Span

The Span element doesn't have any specific rendering by default, but allows you to set almost any kind of specific rendering, including font size, style and weight, background and foreground colors and so on. The great thing about the Span element is that it allows for other inline elements inside of it, making it easy to do even advanced combinations of text and style. In the following example, I have used many Span elements to show you some of the many possibilities when using inline Span elements:

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

तो जैसा कि आप देख सकते हैं, यदि कोई अन्य तत्व आपकी स्थिति में कोई मतलब नहीं रखता है या यदि आप अपने पाठ को प्रारूपित करना शुरू करते समय सिर्फ एक खाली कैनवास चाहते हैं, तो स्पैन तत्व एक बढ़िया विकल्प है।

C # / कोड-पीछे से text formating

जैसा कि आप देख सकते हैं, XAML के माध्यम से पाठ को प्रारूपित करना बहुत आसान है, लेकिन कुछ मामलों में, आप अपनी सी # / कोड-बिहाइंड फ़ाइल से इसे पसंद कर सकते हैं या करने की आवश्यकता हो सकती है। यह थोड़ा अधिक बोझिल है, लेकिन यहाँ एक उदाहरण है कि आप इसे कैसे कर सकते हैं:

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

यह संभावना के लिए बहुत अच्छा है, और कुछ मामलों में ऐसा करना आवश्यक हो सकता है, लेकिन यह उदाहरण शायद आपको XAML की और भी अधिक सराहना करेगा।