I used this answer for a WPF related question to come up with a Silverlight Behavior that can add simple formatting to a TextBlock in Silverlight. Formatting is done through Xml elements that work similar to how a TextBlock can be formatted within the element itself. Bold, Italic, Underline, and LineBreak elements can be used.
First, the behavior is defined as follows:
public static class FormattedTextBlockBehavior
{
public static string GetFormattedText(DependencyObject obj)
{
return (string) obj.GetValue(FormattedTextProperty);
}
public static void SetFormattedText(DependencyObject obj, string value)
{
obj.SetValue(FormattedTextProperty, value);
}
public static readonly DependencyProperty FormattedTextProperty =
DependencyProperty.RegisterAttached("FormattedText",
typeof (string),
typeof (FormattedTextBlockBehavior),
new PropertyMetadata("", FormattedTextChanged));
private static Inline Traverse(string value)
{
// Get the sections/inlines
string[] sections = SplitIntoSections(value);
// Check for grouping
if (sections.Length.Equals(1))
{
string section = sections[0];
string token; // E.g <Bold>
int tokenStart, tokenEnd; // Where the token/section starts and ends.
// Check for token
if (GetTokenInfo(section, out token, out tokenStart, out tokenEnd))
{
// Get the content to further examination
string content = token.Length.Equals(tokenEnd - tokenStart)
? null
: section.Substring(token.Length, section.Length - 1 - token.Length*2);
switch (token)
{
case "<Bold>":
var b = new Bold();
b.Inlines.Add(Traverse(content));
return b;
case "<Italic>":
var i = new Italic();
i.Inlines.Add(Traverse(content));
return i;
case "<Underline>":
var u = new Underline();
u.Inlines.Add(Traverse(content));
return u;
case "<LineBreak/>":
return new LineBreak();
case "<LineBreak />":
return new LineBreak();
default:
return new Run
{
Text = section
};
}
}
return new Run
{
Text = section
};
}
var span = new Span();
foreach (string section in sections)
span.Inlines.Add(Traverse(section));
return span;
}
/// <summary>
/// Examines the passed string and find the first token, where it begins and where it ends.
/// </summary>
/// <param name="value">The string to examine.</param>
/// <param name="token">The found token.</param>
/// <param name="startIndex">Where the token begins.</param>
/// <param name="endIndex">Where the end-token ends.</param>
/// <returns>True if a token was found.</returns>
private static bool GetTokenInfo(string value, out string token, out int startIndex, out int endIndex)
{
token = null;
endIndex = -1;
startIndex = value.IndexOf("<");
int startTokenEndIndex = value.IndexOf(">");
// No token here
if (startIndex < 0)
return false;
// No token here
if (startTokenEndIndex < 0)
return false;
token = value.Substring(startIndex, startTokenEndIndex - startIndex + 1);
// Check for closed token. E.g. <LineBreak/>
if (token.EndsWith("/>"))
{
endIndex = startIndex + token.Length;
return true;
}
string endToken = token.Insert(1, "/");
// Detect nesting;
int nesting = 0;
int pos = 0;
do
{
int tempStartTokenIndex = value.IndexOf(token, pos);
int tempEndTokenIndex = value.IndexOf(endToken, pos);
if (tempStartTokenIndex >= 0 && tempStartTokenIndex < tempEndTokenIndex)
{
nesting++;
pos = tempStartTokenIndex + token.Length;
}
else if (tempEndTokenIndex >= 0 && nesting > 0)
{
nesting--;
pos = tempEndTokenIndex + endToken.Length;
}
else // Invalid tokenized string
return false;
} while (nesting > 0);
endIndex = pos;
return true;
}
/// <summary>
/// Splits the string into sections of tokens and regular text.
/// </summary>
/// <param name="value">The string to split.</param>
/// <returns>An array with the sections.</returns>
private static string[] SplitIntoSections(string value)
{
var sections = new List<string>();
while (!string.IsNullOrEmpty(value))
{
string token;
int tokenStartIndex, tokenEndIndex;
// Check if this is a token section
if (GetTokenInfo(value, out token, out tokenStartIndex, out tokenEndIndex))
{
// Add pretext if the token isn't from the start
if (tokenStartIndex > 0)
sections.Add(value.Substring(0, tokenStartIndex));
sections.Add(value.Substring(tokenStartIndex, tokenEndIndex - tokenStartIndex));
value = value.Substring(tokenEndIndex); // Trim away
}
else
{
// No tokens, just add the text
sections.Add(value);
value = null;
}
}
return sections.ToArray();
}
private static void FormattedTextChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
{
var value = e.NewValue as string;
var textBlock = sender as TextBlock;
if (textBlock != null)
textBlock.Inlines.Add(Traverse(value));
}
Then, from the xaml itself, the behavior can be referenced as follows:
xmlns:Helpers="clr-namespace:Namespace.Helpers"
<TextBlock Grid.Row="0" Margin="10,10,10,10" TextWrapping="Wrap" FontSize="14" Helpers:FormattedTextBlockBehavior.FormattedText="{Binding ViewModel.Text}" />
