Initial commit

HtmlTextBlock/HtmlTextBlock.cs

@@ -0,0 +1,57 @@
+using System;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Documents;
+
+namespace Common.Wpf.HtmlTextBlock
+{
+    public class HtmlTextBlock : TextBlock
+    {
+        public static readonly DependencyProperty HtmlProperty = DependencyProperty.Register("Html", typeof(string), typeof(HtmlTextBlock), new UIPropertyMetadata("Html", OnHtmlChanged));
+
+        public static void OnHtmlChanged(DependencyObject s, DependencyPropertyChangedEventArgs e)
+        {
+            HtmlTextBlock htmlTextBlock = (HtmlTextBlock) s;
+
+            Parse(htmlTextBlock, e.NewValue as string);
+        }
+
+        private static void Parse(HtmlTextBlock control, string value)
+        {
+            try
+            {
+                control.Inlines.Clear();
+
+                TextParser parser = new TextParser();
+                var lines = parser.Parse(control, value);
+
+                foreach (TextLine line in lines)
+                {
+                    foreach (TextFragment fragment in line.FragmentList)
+                    {
+                        Run run = new Run(fragment.Text);
+
+                        run.FontStyle = fragment.Style;
+                        run.FontWeight = fragment.Weight;
+                        run.FontSize = fragment.Size;
+                        run.Foreground = fragment.Color;
+
+                        control.Inlines.Add(run);
+                    }
+                }
+            }
+            catch (Exception)
+            {
+                control.Inlines.Clear();
+
+                control.Text = value;
+            }
+        }
+
+        public string Html
+        {
+            get { return (string) GetValue(HtmlProperty); }
+            set { SetValue(HtmlProperty, value); }
+        }
+    }
+}

HtmlTextBlock/TextFragment.cs

@@ -0,0 +1,63 @@
+using System.Globalization;
+using System.Windows;
+using System.Windows.Media;
+
+namespace Common.Wpf.HtmlTextBlock
+{
+    public class TextFragment
+    {
+        private readonly HtmlTextBlock _parent;
+
+        public Brush Color { get; set; }
+        public FontStyle Style { get; set; }
+        public FontWeight Weight { get; set; }
+        public double Size { get; set; }
+        public string Text { get; set; }
+        public bool Underline { get; set; }
+
+        private Typeface _typeface;
+        public Typeface Typeface
+        {
+            get { return _typeface ?? (_typeface = new Typeface(_parent.FontFamily, Style, Weight, _parent.FontStretch)); }
+        }
+
+        private FormattedText _formattedText;
+        public FormattedText FormattedText
+        {
+            get
+            {
+                if (_formattedText == null)
+                {
+                    string measureText = (string.IsNullOrEmpty(Text) ? " " : Text);
+
+                    _formattedText = new FormattedText(measureText, CultureInfo.CurrentUICulture, FlowDirection.LeftToRight, Typeface, Size, Color);
+
+                    TextDecorationCollection textDecorationCollection = new TextDecorationCollection();
+
+                    if (Underline)
+                    {
+                        TextDecoration underlineDecoration = new TextDecoration { PenThicknessUnit = TextDecorationUnit.FontRecommended };
+
+                        textDecorationCollection.Add(underlineDecoration);
+                    }
+
+                    _formattedText.SetTextDecorations(textDecorationCollection);
+                }
+
+                return _formattedText;
+            }
+        }
+
+        public TextFragment(HtmlTextBlock parent)
+        {
+            _parent = parent;
+
+            Color = _parent.Foreground;
+            Style = _parent.FontStyle;
+            Weight = _parent.FontWeight;
+            Size = _parent.FontSize;
+            Text = string.Empty;
+            Underline = false;
+        }
+    }
+}

HtmlTextBlock/TextFragmentStyle.cs

@@ -0,0 +1,32 @@
+using System.Windows;
+using System.Windows.Media;
+
+namespace Common.Wpf.HtmlTextBlock
+{
+    public class TextFragmentStyle
+    {
+        public Brush Color { get; set; }
+        public FontStyle? Style { get; set; }
+        public FontWeight? Weight { get; set; }
+        public double? Size { get; set; }
+        public bool? Underline { get; set; }
+
+        public void Apply(TextFragment fragment)
+        {
+            if (Color != null)
+                fragment.Color = Color;
+
+            if (Style.HasValue)
+                fragment.Style = Style.Value;
+
+            if (Weight.HasValue)
+                fragment.Weight = Weight.Value;
+
+            if (Size.HasValue)
+                fragment.Size = Size.Value;
+
+            if (Underline.HasValue)
+                fragment.Underline = Underline.Value;
+        }
+    }
+}

HtmlTextBlock/TextLine.cs

@@ -0,0 +1,14 @@
+using System.Collections.ObjectModel;
+
+namespace Common.Wpf.HtmlTextBlock
+{
+    public class TextLine
+    {
+        public Collection<TextFragment> FragmentList { get; private set; }
+
+        public TextLine()
+        {
+            FragmentList = new Collection<TextFragment>();
+        }
+    }
+}

HtmlTextBlock/TextParser.cs

@@ -0,0 +1,140 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Globalization;
+using System.Windows;
+using System.Windows.Media;
+using System.Xml;
+
+namespace Common.Wpf.HtmlTextBlock
+{
+    public class TextParser
+    {
+        private HtmlTextBlock _parentControl;
+
+        public Collection<TextLine> Parse(HtmlTextBlock parentControl, string text)
+        {
+            _parentControl = parentControl;
+
+            text = text.Replace("&", "&amp;");
+
+            // Add a root tag so the parser is happy
+            text = string.Format(CultureInfo.InvariantCulture, "<body>{0}</body>", text);
+
+            // Normalize line endings
+            text = text.Replace("\r\n", "\n");
+
+            // Create an XML document and load it with the text
+            XmlDocument xmlDocument = new XmlDocument();
+            xmlDocument.PreserveWhitespace = true;
+            xmlDocument.LoadXml(text);
+
+            // Create a list of text lines
+            Collection<TextLine> lines = new Collection<TextLine>();
+
+            // Walk over the nodes and build up the fragment list
+            WalkNodes(xmlDocument.ChildNodes, lines);
+
+            return lines;
+        }
+
+        private readonly Stack<TextFragmentStyle> _attributeStack = new Stack<TextFragmentStyle>();
+
+        private void WalkNodes(XmlNodeList xmlNodeList, Collection<TextLine> textLines)
+        {
+            if (textLines.Count == 0)
+                textLines.Add(new TextLine());
+
+            foreach (XmlNode xmlNode in xmlNodeList)
+            {
+                TextFragmentStyle style;
+
+                switch (xmlNode.Name.ToUpperInvariant())
+                {
+                    case "#WHITESPACE":
+                    case "#TEXT":
+
+                        // Split the fragment and the line endings
+                        string[] lines = xmlNode.Value.Split('\n');
+
+                        bool firstLine = true;
+
+                        foreach (string line in lines)
+                        {
+                            TextLine textLine = (firstLine ? textLines[textLines.Count - 1] : new TextLine());
+
+                            // Create a new fragment and fill the style information
+                            TextFragment textFragment = new TextFragment(_parentControl);
+                            textFragment.Text = line;
+
+                            foreach (TextFragmentStyle s in _attributeStack)
+                            {
+                                s.Apply(textFragment);
+                            }
+
+                            // Add the fragment to the list
+                            textLine.FragmentList.Add(textFragment);
+
+                            if (!firstLine)
+                                textLines.Add(textLine);
+
+                            firstLine = false;
+                        }
+
+                        break;
+
+                    case "EM":
+                    case "B":
+
+                        style = new TextFragmentStyle { Weight = FontWeights.Bold };
+                        _attributeStack.Push(style);
+
+                        break;
+
+                    case "U":
+
+                        style = new TextFragmentStyle { Underline = true };
+                        _attributeStack.Push(style);
+
+                        break;
+
+                    case "CITE":
+
+                        style = new TextFragmentStyle { Style = FontStyles.Italic };
+                        _attributeStack.Push(style);
+
+                        break;
+
+                    case "FONT":
+                        style = new TextFragmentStyle();
+
+                        if (xmlNode.Attributes == null)
+                            break;
+
+                        foreach (XmlAttribute attribute in xmlNode.Attributes)
+                        {
+                            switch (attribute.Name.ToUpperInvariant())
+                            {
+                                case "SIZE":
+                                    style.Size = Convert.ToDouble(attribute.Value, CultureInfo.InvariantCulture);
+                                    break;
+
+                                case "COLOR":
+                                    style.Color = (Brush) new BrushConverter().ConvertFromString(attribute.Value);
+                                    break;
+                            }
+                        }
+
+                        _attributeStack.Push(style);
+                        break;
+                }
+
+                if (xmlNode.ChildNodes.Count > 0)
+                    WalkNodes(xmlNode.ChildNodes, textLines);
+
+                if (_attributeStack.Count > 0)
+                    _attributeStack.Pop();
+            }
+        }
+    }
+}