Merge pull request #214 from reactivemarbles/UpdateRichTextBox

Add FlowDocument and HTML support to RichTextBox

Author: ChrisPulman

src/CrissCross.Avalonia.UI.Gallery/Views/Pages/InputPageView.axaml

@@ -2,10 +2,18 @@
 // ReactiveUI Association Incorporated licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for full license information.
 
+using System;
+using System.IO;
+using System.Net.Http;
 using Avalonia;
 using Avalonia.Controls;
 using Avalonia.Controls.Documents;
+using Avalonia.Layout;
 using Avalonia.Media;
+using Avalonia.Media.Imaging;
+using Avalonia.Platform;
+using DocumentsInline = Avalonia.Controls.Documents.Inline;
+using DocumentsInlineUIContainer = Avalonia.Controls.Documents.InlineUIContainer;
 
 namespace CrissCross.Avalonia.UI.Controls;
 
@@ -17,8 +25,8 @@ public class FormattedTextPresenter : SelectableTextBlock
     /// <summary>
     /// Property for <see cref="Document"/>.
     /// </summary>
-    public static readonly StyledProperty<RichTextDocument?> DocumentProperty =
-        AvaloniaProperty.Register<FormattedTextPresenter, RichTextDocument?>(nameof(Document));
+    public static readonly StyledProperty<FlowDocument?> DocumentProperty =
+        AvaloniaProperty.Register<FormattedTextPresenter, FlowDocument?>(nameof(Document));
 
     /// <summary>
     /// Property for <see cref="DefaultForeground"/>.
@@ -32,6 +40,8 @@ public class FormattedTextPresenter : SelectableTextBlock
     public static readonly StyledProperty<double> DefaultFontSizeProperty =
         AvaloniaProperty.Register<FormattedTextPresenter, double>(nameof(DefaultFontSize), 14);
 
+    private static readonly HttpClient HttpClient = new();
+
     /// <summary>
     /// Initializes a new instance of the <see cref="FormattedTextPresenter"/> class.
     /// </summary>
@@ -44,7 +54,7 @@ public FormattedTextPresenter()
     /// <summary>
     /// Gets or sets the document to display.
     /// </summary>
-    public RichTextDocument? Document
+    public FlowDocument? Document
     {
         get => GetValue(DocumentProperty);
         set => SetValue(DocumentProperty, value);
@@ -80,45 +90,57 @@ public void UpdateInlines()
             return;
         }
 
-        Inlines ??= [];
-
         foreach (var segment in Document.Segments)
         {
-            var run = new Run(segment.Text)
+            if (segment.IsParagraphBreak)
             {
-                FontWeight = segment.FontWeight,
-                FontStyle = segment.FontStyle,
-            };
+                Inlines!.Add(new LineBreak());
+                Inlines.Add(new LineBreak());
+                continue;
+            }
 
-            // Apply text decorations
-            if (segment.TextDecorations is { } decorations)
+            if (segment.IsLineBreak)
             {
-                run.TextDecorations = decorations;
+                Inlines!.Add(new LineBreak());
+                continue;
             }
 
-            // Apply custom foreground
-            if (segment.Foreground is not null)
+            if (segment.IsImage)
             {
-                run.Foreground = segment.Foreground;
+                var imageInline = CreateImageInline(segment);
+                if (imageInline is not null)
+                {
+                    Inlines!.Add(imageInline);
+                }
+
+                continue;
             }
-            else if (DefaultForeground is not null)
+
+            if (!segment.HasRenderableText)
             {
-                run.Foreground = DefaultForeground;
+                continue;
             }
 
-            // Apply custom font size
-            if (segment.FontSize.HasValue)
+            var run = new Run(segment.Text)
             {
-                run.FontSize = segment.FontSize.Value;
+                FontWeight = segment.FontWeight,
+                FontStyle = segment.FontStyle,
+                FontSize = segment.FontSize ?? DefaultFontSize,
+                FontFamily = segment.FontFamily ?? FontFamily,
+            };
+
+            if (segment.TextDecorations is { } decorations)
+            {
+                run.TextDecorations = decorations;
             }
 
-            // Apply custom font family
-            if (segment.FontFamily is not null)
+            run.Foreground = segment.Foreground ?? DefaultForeground ?? Foreground;
+            if (segment.Background is not null)
             {
-                run.FontFamily = segment.FontFamily;
+                run.Background = segment.Background;
             }
 
-            Inlines.Add(run);
+            Inlines!.Add(run);
         }
     }
 
@@ -142,4 +164,160 @@ protected override void OnPropertyChanged(AvaloniaPropertyChangedEventArgs chang
             UpdateInlines();
         }
     }
+
+    private static DocumentsInline? CreateImageInline(TextSegment segment)
+    {
+        if (string.IsNullOrWhiteSpace(segment.ImageSource))
+        {
+            return null;
+        }
+
+        if (!TryLoadImage(segment.ImageSource, out var bitmap))
+        {
+            return null;
+        }
+
+        var image = new Image
+        {
+            Source = bitmap,
+            Stretch = Stretch.Uniform,
+            HorizontalAlignment = segment.ImageAlignment,
+        };
+
+        if (segment.ImageWidth.HasValue)
+        {
+            image.Width = segment.ImageWidth.Value;
+        }
+
+        if (segment.ImageHeight.HasValue)
+        {
+            image.Height = segment.ImageHeight.Value;
+        }
+
+        return new DocumentsInlineUIContainer
+        {
+            Child = new Border
+            {
+                HorizontalAlignment = HorizontalAlignment.Stretch,
+                Child = image,
+            }
+        };
+    }
+
+    private static bool TryLoadImage(string source, out IImage? bitmap)
+    {
+        bitmap = null;
+
+        try
+        {
+            if (TryLoadDataUri(source, out bitmap))
+            {
+                return true;
+            }
+
+            if (Uri.TryCreate(source, UriKind.Absolute, out var absolute))
+            {
+                if (absolute.IsFile)
+                {
+                    var localPath = absolute.LocalPath;
+                    if (File.Exists(localPath))
+                    {
+                        using var fileStream = File.OpenRead(localPath);
+                        bitmap = CreateBitmapFromStream(fileStream);
+                        return true;
+                    }
+
+                    return false;
+                }
+
+                if (absolute.Scheme is "http" or "https")
+                {
+                    return TryLoadFromHttp(absolute, out bitmap);
+                }
+
+                using var assetStream = AssetLoader.Open(absolute);
+                bitmap = CreateBitmapFromStream(assetStream);
+                return true;
+            }
+
+            if (File.Exists(source))
+            {
+                using var fallbackFile = File.OpenRead(source);
+                bitmap = CreateBitmapFromStream(fallbackFile);
+                return true;
+            }
+        }
+        catch
+        {
+            bitmap = null;
+        }
+
+        return false;
+    }
+
+    private static bool TryLoadDataUri(string source, out IImage? bitmap)
+    {
+        bitmap = null;
+        if (!source.StartsWith("data:", StringComparison.OrdinalIgnoreCase))
+        {
+            return false;
+        }
+
+        var commaIndex = source.IndexOf(',');
+        if (commaIndex < 0)
+        {
+            return false;
+        }
+
+        var metadata = source[..commaIndex];
+        if (!metadata.Contains(";base64", StringComparison.OrdinalIgnoreCase))
+        {
+            return false;
+        }
+
+        var payload = source[(commaIndex + 1)..].Trim();
+        if (payload.Length == 0)
+        {
+            return false;
+        }
+
+        try
+        {
+            var bytes = Convert.FromBase64String(payload);
+            using var memory = new MemoryStream(bytes);
+            bitmap = new Bitmap(memory);
+            return true;
+        }
+        catch
+        {
+            bitmap = null;
+            return false;
+        }
+    }
+
+    private static bool TryLoadFromHttp(Uri uri, out IImage? bitmap)
+    {
+        bitmap = null;
+        try
+        {
+            using var response = HttpClient.GetAsync(uri, HttpCompletionOption.ResponseHeadersRead).GetAwaiter().GetResult();
+            response.EnsureSuccessStatusCode();
+            using var stream = response.Content.ReadAsStreamAsync().GetAwaiter().GetResult();
+            bitmap = CreateBitmapFromStream(stream);
+            return true;
+        }
+        catch
+        {
+            bitmap = null;
+            return false;
+        }
+    }
+
+    private static Bitmap CreateBitmapFromStream(Stream stream)
+    {
+        using var buffer = new MemoryStream();
+        stream.CopyTo(buffer);
+        buffer.Position = 0;
+        return new Bitmap(buffer);
+    }
 }

src/CrissCross.Avalonia.UI/Controls/RichTextBox/FlowDocument.cs

@@ -0,0 +1,80 @@
+// Copyright (c) 2019-2025 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System;
+using System.Globalization;
+using System.Net;
+using System.Text;
+
+namespace CrissCross.Avalonia.UI.Controls;
+
+internal static class HtmlClipboardUtilities
+{
+    public static string ExtractFragment(string html)
+    {
+        if (string.IsNullOrWhiteSpace(html))
+        {
+            return string.Empty;
+        }
+
+        var start = GetFragmentIndex(html, "StartFragment:");
+        var end = GetFragmentIndex(html, "EndFragment:");
+        if (start >= 0 && end > start && end <= html.Length)
+        {
+            return html[start..end];
+        }
+
+        const string startMarker = "<!--StartFragment-->";
+        const string endMarker = "<!--EndFragment-->";
+        var startMarkerIndex = html.IndexOf(startMarker, StringComparison.OrdinalIgnoreCase);
+        if (startMarkerIndex >= 0)
+        {
+            startMarkerIndex += startMarker.Length;
+            var endMarkerIndex = html.IndexOf(endMarker, startMarkerIndex, StringComparison.OrdinalIgnoreCase);
+            if (endMarkerIndex > startMarkerIndex)
+            {
+                return html[startMarkerIndex..endMarkerIndex];
+            }
+        }
+
+        return html;
+    }
+
+    public static string EncodePlainText(string? text)
+    {
+        if (string.IsNullOrEmpty(text))
+        {
+            return string.Empty;
+        }
+
+        var encoded = WebUtility.HtmlEncode(text);
+        return encoded.Replace("\r\n", "<br />", StringComparison.Ordinal)
+                      .Replace("\n", "<br />", StringComparison.Ordinal)
+                      .Replace("\r", "<br />", StringComparison.Ordinal);
+    }
+
+    private static int GetFragmentIndex(string html, string marker)
+    {
+        var markerIndex = html.IndexOf(marker, StringComparison.OrdinalIgnoreCase);
+        if (markerIndex < 0)
+        {
+            return -1;
+        }
+
+        var indexStart = markerIndex + marker.Length;
+        var indexEnd = indexStart;
+        while (indexEnd < html.Length && char.IsDigit(html[indexEnd]))
+        {
+            indexEnd++;
+        }
+
+        if (indexEnd > indexStart &&
+            int.TryParse(html[indexStart..indexEnd], NumberStyles.Integer, CultureInfo.InvariantCulture, out var value))
+        {
+            return value;
+        }
+
+        return -1;
+    }
+}