Added OnLinkClicked event.

azchohfi · michael-hawker · commit b41d8f0d405d · 2024-11-25T14:13:03.000-08:00
diff --git a/components/MarkdownTextBlock/samples/MarkdownTextBlockCustomSample.xaml.cs b/components/MarkdownTextBlock/samples/MarkdownTextBlockCustomSample.xaml.cs
@@ -604,8 +604,15 @@ public MarkdownTextBlockCustomSample()
     {
         this.InitializeComponent();
         _config = new MarkdownConfig();
+        _config.OnLinkClicked += this._config_OnLinkClicked;
         _liveConfig = new MarkdownConfig();
+        _liveConfig.OnLinkClicked += this._config_OnLinkClicked;
         _text = _markdown;
         MarkdownTextBox.Text = "# Hello World\n\n";
     }
+
+    private void _config_OnLinkClicked(object? sender, LinkClickedEventArgs e)
+    {
+        Debug.WriteLine($"Link Clicked: {e.Uri}");
+    }
 }
diff --git a/components/MarkdownTextBlock/src/HtmlWriter.cs b/components/MarkdownTextBlock/src/HtmlWriter.cs
@@ -33,11 +33,21 @@ public static void WriteHtml(WinUIRenderer renderer, HtmlNodeCollection nodes)
                     IAddChild hyperLink;
                     if (node.ChildNodes.Any(n => n.Name != "#text"))
                     {
-                        hyperLink = new MyHyperlinkButton(node, renderer.Config.BaseUrl);
+                        var myHyperlinkButton = new MyHyperlinkButton(node, renderer.Config.BaseUrl);
+                        myHyperlinkButton.ClickEvent += (sender, e) =>
+                        {
+                            renderer.Config.RaiseLinkClickedEvent(renderer, ((HyperlinkButton)sender).NavigateUri);
+                        };
+                        hyperLink = myHyperlinkButton;
                     }
                     else
                     {
-                        hyperLink = new MyHyperlink(node, renderer.Config.BaseUrl);
+                        var myHyperlink = new MyHyperlink(node, renderer.Config.BaseUrl);
+                        myHyperlink.ClickEvent += (sender, e) =>
+                        {
+                            renderer.Config.RaiseLinkClickedEvent(renderer, sender.NavigateUri);
+                        };
+                        hyperLink = myHyperlink;
                     }
                     renderer.Push(hyperLink);
                     WriteHtml(renderer, node.ChildNodes);
diff --git a/components/MarkdownTextBlock/src/LinkClickedEventArgs.cs b/components/MarkdownTextBlock/src/LinkClickedEventArgs.cs
@@ -0,0 +1,15 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace CommunityToolkit.Labs.WinUI.MarkdownTextBlock;
+
+public class LinkClickedEventArgs : EventArgs
+{
+    public Uri Uri { get; }
+
+    public LinkClickedEventArgs(Uri uri)
+    {
+        this.Uri = uri;
+    }
+}
diff --git a/components/MarkdownTextBlock/src/MarkdownConfig.cs b/components/MarkdownTextBlock/src/MarkdownConfig.cs
@@ -12,6 +12,8 @@ public record MarkdownConfig
     public IImageProvider? ImageProvider { get; set; }
     public ISVGRenderer? SVGRenderer { get; set; }
     public MarkdownThemes Themes { get; set; } = MarkdownThemes.Default;
+    public event EventHandler<LinkClickedEventArgs>? OnLinkClicked;
+    internal void RaiseLinkClickedEvent(object? sender, Uri uri) => OnLinkClicked?.Invoke(sender, new LinkClickedEventArgs(uri));
 
     public static MarkdownConfig Default = new();
 }
diff --git a/components/MarkdownTextBlock/src/Renderers/ObjectRenderers/Inlines/AutoLinkInlineRenderer.cs b/components/MarkdownTextBlock/src/Renderers/ObjectRenderers/Inlines/AutoLinkInlineRenderer.cs
@@ -26,6 +26,10 @@ protected override void Write(WinUIRenderer renderer, AutolinkInline link)
         }
 
         var autolink = new MyAutolinkInline(link);
+        autolink.ClickEvent += (sender, e) =>
+        {
+            renderer.Config.RaiseLinkClickedEvent(renderer, sender.NavigateUri);
+        };
 
         renderer.Push(autolink);
 
diff --git a/components/MarkdownTextBlock/src/Renderers/ObjectRenderers/Inlines/LinkInlineRenderer.cs b/components/MarkdownTextBlock/src/Renderers/ObjectRenderers/Inlines/LinkInlineRenderer.cs
@@ -30,11 +30,20 @@ protected override void Write(WinUIRenderer renderer, LinkInline link)
         {
             if (link.FirstChild is LinkInline linkInlineChild && linkInlineChild.IsImage)
             {
-                renderer.Push(new MyHyperlinkButton(link, renderer.Config.BaseUrl));
+                var myHyperlinkButton = new MyHyperlinkButton(link, renderer.Config.BaseUrl);
+                myHyperlinkButton.ClickEvent += (sender, e) =>
+                {
+                    renderer.Config.RaiseLinkClickedEvent(renderer, ((HyperlinkButton)sender).NavigateUri);
+                };
+                renderer.Push(myHyperlinkButton);
             }
             else
             {
                 var hyperlink = new MyHyperlink(link, renderer.Config.BaseUrl);
+                hyperlink.ClickEvent += (sender, e) =>
+                {
+                    renderer.Config.RaiseLinkClickedEvent(renderer, sender.NavigateUri);
+                };
 
                 renderer.Push(hyperlink);
             }
diff --git a/components/MarkdownTextBlock/src/TextElements/MyAutolinkInline.cs b/components/MarkdownTextBlock/src/TextElements/MyAutolinkInline.cs
@@ -12,6 +12,18 @@ internal class MyAutolinkInline : IAddChild
 
     public TextElement TextElement { get; private set; }
 
+    public event TypedEventHandler<Hyperlink, HyperlinkClickEventArgs>? ClickEvent
+    {
+        add
+        {
+            ((Hyperlink)TextElement).Click += value;
+        }
+        remove
+        {
+            ((Hyperlink)TextElement).Click -= value;
+        }
+    }
+
     public MyAutolinkInline(AutolinkInline autoLinkInline)
     {
         _autoLinkInline = autoLinkInline;
@@ -21,7 +33,6 @@ public MyAutolinkInline(AutolinkInline autoLinkInline)
         };
     }
 
-
     public void AddChild(IAddChild child)
     {
         try
diff --git a/components/MarkdownTextBlock/src/TextElements/MyHyperlink.cs b/components/MarkdownTextBlock/src/TextElements/MyHyperlink.cs
@@ -14,6 +14,18 @@ internal class MyHyperlink : IAddChild
     private HtmlNode? _htmlNode;
     private string? _baseUrl;
 
+    public event TypedEventHandler<Hyperlink, HyperlinkClickEventArgs> ClickEvent
+    {
+        add
+        {
+            _hyperlink.Click += value;
+        }
+        remove
+        {
+            _hyperlink.Click -= value;
+        }
+    }
+
     public bool IsHtml => _htmlNode != null;
 
     public TextElement TextElement
diff --git a/components/MarkdownTextBlock/src/TextElements/MyHyperlinkButton.cs b/components/MarkdownTextBlock/src/TextElements/MyHyperlinkButton.cs
@@ -9,12 +9,24 @@ namespace CommunityToolkit.Labs.WinUI.MarkdownTextBlock.TextElements;
 
 internal class MyHyperlinkButton : IAddChild
 {
-    private HyperlinkButton? _hyperLinkButton;
+    private HyperlinkButton _hyperLinkButton;
     private InlineUIContainer _inlineUIContainer = new InlineUIContainer();
-    private MyFlowDocument? _flowDoc;
+    private MyFlowDocument _flowDoc;
     private string? _baseUrl;
     private LinkInline? _linkInline;
     private HtmlNode? _htmlNode;
+    
+    public event RoutedEventHandler? ClickEvent
+    {
+        add
+        {
+            _hyperLinkButton.Click += value;
+        }
+        remove
+        {
+            _hyperLinkButton.Click -= value;
+        }
+    }
 
     public bool IsHtml => _htmlNode != null;
 
@@ -24,43 +36,40 @@ public TextElement TextElement
     }
 
     public MyHyperlinkButton(LinkInline linkInline, string? baseUrl)
+        : this(linkInline.GetDynamicUrl != null ? linkInline.GetDynamicUrl() ?? linkInline.Url : linkInline.Url, baseUrl, null, linkInline)
     {
-        _baseUrl = baseUrl;
-        var url = linkInline.GetDynamicUrl != null ? linkInline.GetDynamicUrl() ?? linkInline.Url : linkInline.Url;
-        _linkInline = linkInline;
-        Init(url, baseUrl);
     }
 
     public MyHyperlinkButton(HtmlNode htmlNode, string? baseUrl)
+        : this(htmlNode.GetAttribute("href", "#"), baseUrl, htmlNode, null)
     {
-        _baseUrl = baseUrl;
-        _htmlNode = htmlNode;
-        var url = htmlNode.GetAttribute("href", "#");
-        Init(url, baseUrl);
     }
 
-    private void Init(string? url, string? baseUrl)
+    private MyHyperlinkButton(string? url, string? baseUrl, HtmlNode? htmlNode, LinkInline? linkInline)
     {
-        _hyperLinkButton = new HyperlinkButton()
+        _baseUrl = baseUrl;
+        _htmlNode = htmlNode;
+        _linkInline = linkInline;
+        _hyperLinkButton = new HyperlinkButton
         {
             NavigateUri = Extensions.GetUri(url, baseUrl),
         };
         _hyperLinkButton.Padding = new Thickness(0);
         _hyperLinkButton.Margin = new Thickness(0);
-        if (IsHtml && _htmlNode != null)
+        if (_htmlNode != null)
         {
             _flowDoc = new MyFlowDocument(_htmlNode);
         }
-        else if (_linkInline != null)
+        else
         {
-            _flowDoc = new MyFlowDocument(_linkInline);
+            _flowDoc = new MyFlowDocument(_linkInline!);
         }
         _inlineUIContainer.Child = _hyperLinkButton;
-        _hyperLinkButton.Content = _flowDoc?.RichTextBlock;
+        _hyperLinkButton.Content = _flowDoc.RichTextBlock;
     }
 
     public void AddChild(IAddChild child)
     {
-        _flowDoc?.AddChild(child);
+        _flowDoc.AddChild(child);
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -604,8 +604,15 @@ public MarkdownTextBlockCustomSample()`
`604`	`604`	`{`
`605`	`605`	`this.InitializeComponent();`
`606`	`606`	`_config = new MarkdownConfig();`
	`607`	`+ _config.OnLinkClicked += this._config_OnLinkClicked;`
`607`	`608`	`_liveConfig = new MarkdownConfig();`
	`609`	`+ _liveConfig.OnLinkClicked += this._config_OnLinkClicked;`
`608`	`610`	`_text = _markdown;`
`609`	`611`	`MarkdownTextBox.Text = "# Hello World\n\n";`
`610`	`612`	`}`
	`613`	`+`
	`614`	`+ private void _config_OnLinkClicked(object? sender, LinkClickedEventArgs e)`
	`615`	`+ {`
	`616`	`+ Debug.WriteLine($"Link Clicked: {e.Uri}");`
	`617`	`+ }`
`611`	`618`	`}`
Original file line number	Diff line number	Diff line change
`@@ -33,11 +33,21 @@ public static void WriteHtml(WinUIRenderer renderer, HtmlNodeCollection nodes)`
`33`	`33`	`IAddChild hyperLink;`
`34`	`34`	`if (node.ChildNodes.Any(n => n.Name != "#text"))`
`35`	`35`	`{`
`36`		`- hyperLink = new MyHyperlinkButton(node, renderer.Config.BaseUrl);`
	`36`	`+ var myHyperlinkButton = new MyHyperlinkButton(node, renderer.Config.BaseUrl);`
	`37`	`+ myHyperlinkButton.ClickEvent += (sender, e) =>`
	`38`	`+ {`
	`39`	`+ renderer.Config.RaiseLinkClickedEvent(renderer, ((HyperlinkButton)sender).NavigateUri);`
	`40`	`+ };`
	`41`	`+ hyperLink = myHyperlinkButton;`
`37`	`42`	`}`
`38`	`43`	`else`
`39`	`44`	`{`
`40`		`- hyperLink = new MyHyperlink(node, renderer.Config.BaseUrl);`
	`45`	`+ var myHyperlink = new MyHyperlink(node, renderer.Config.BaseUrl);`
	`46`	`+ myHyperlink.ClickEvent += (sender, e) =>`
	`47`	`+ {`
	`48`	`+ renderer.Config.RaiseLinkClickedEvent(renderer, sender.NavigateUri);`
	`49`	`+ };`
	`50`	`+ hyperLink = myHyperlink;`
`41`	`51`	`}`
`42`	`52`	`renderer.Push(hyperLink);`
`43`	`53`	`WriteHtml(renderer, node.ChildNodes);`
Original file line number	Diff line number	Diff line change
`@@ -12,6 +12,8 @@ public record MarkdownConfig`
`12`	`12`	`public IImageProvider? ImageProvider { get; set; }`
`13`	`13`	`public ISVGRenderer? SVGRenderer { get; set; }`
`14`	`14`	`public MarkdownThemes Themes { get; set; } = MarkdownThemes.Default;`
	`15`	`+ public event EventHandler<LinkClickedEventArgs>? OnLinkClicked;`
	`16`	`+ internal void RaiseLinkClickedEvent(object? sender, Uri uri) => OnLinkClicked?.Invoke(sender, new LinkClickedEventArgs(uri));`
`15`	`17`
`16`	`18`	`public static MarkdownConfig Default = new();`
`17`	`19`	`}`
Original file line number	Diff line number	Diff line change
`@@ -26,6 +26,10 @@ protected override void Write(WinUIRenderer renderer, AutolinkInline link)`
`26`	`26`	`}`
`27`	`27`
`28`	`28`	`var autolink = new MyAutolinkInline(link);`
	`29`	`+ autolink.ClickEvent += (sender, e) =>`
	`30`	`+ {`
	`31`	`+ renderer.Config.RaiseLinkClickedEvent(renderer, sender.NavigateUri);`
	`32`	`+ };`
`29`	`33`
`30`	`34`	`renderer.Push(autolink);`
`31`	`35`
Original file line number	Diff line number	Diff line change
`@@ -30,11 +30,20 @@ protected override void Write(WinUIRenderer renderer, LinkInline link)`
`30`	`30`	`{`
`31`	`31`	`if (link.FirstChild is LinkInline linkInlineChild && linkInlineChild.IsImage)`
`32`	`32`	`{`
`33`		`- renderer.Push(new MyHyperlinkButton(link, renderer.Config.BaseUrl));`
	`33`	`+ var myHyperlinkButton = new MyHyperlinkButton(link, renderer.Config.BaseUrl);`
	`34`	`+ myHyperlinkButton.ClickEvent += (sender, e) =>`
	`35`	`+ {`
	`36`	`+ renderer.Config.RaiseLinkClickedEvent(renderer, ((HyperlinkButton)sender).NavigateUri);`
	`37`	`+ };`
	`38`	`+ renderer.Push(myHyperlinkButton);`
`34`	`39`	`}`
`35`	`40`	`else`
`36`	`41`	`{`
`37`	`42`	`var hyperlink = new MyHyperlink(link, renderer.Config.BaseUrl);`
	`43`	`+ hyperlink.ClickEvent += (sender, e) =>`
	`44`	`+ {`
	`45`	`+ renderer.Config.RaiseLinkClickedEvent(renderer, sender.NavigateUri);`
	`46`	`+ };`
`38`	`47`
`39`	`48`	`renderer.Push(hyperlink);`
`40`	`49`	`}`
Original file line number	Diff line number	Diff line change
`@@ -9,12 +9,24 @@ namespace CommunityToolkit.Labs.WinUI.MarkdownTextBlock.TextElements;`
`9`	`9`
`10`	`10`	`internal class MyHyperlinkButton : IAddChild`
`11`	`11`	`{`
`12`		`- private HyperlinkButton? _hyperLinkButton;`
	`12`	`+ private HyperlinkButton _hyperLinkButton;`
`13`	`13`	`private InlineUIContainer _inlineUIContainer = new InlineUIContainer();`
`14`		`- private MyFlowDocument? _flowDoc;`
	`14`	`+ private MyFlowDocument _flowDoc;`
`15`	`15`	`private string? _baseUrl;`
`16`	`16`	`private LinkInline? _linkInline;`
`17`	`17`	`private HtmlNode? _htmlNode;`
	`18`	`+`
	`19`	`+ public event RoutedEventHandler? ClickEvent`
	`20`	`+ {`
	`21`	`+ add`
	`22`	`+ {`
	`23`	`+ _hyperLinkButton.Click += value;`
	`24`	`+ }`
	`25`	`+ remove`
	`26`	`+ {`
	`27`	`+ _hyperLinkButton.Click -= value;`
	`28`	`+ }`
	`29`	`+ }`
`18`	`30`
`19`	`31`	`public bool IsHtml => _htmlNode != null;`
`20`	`32`
`@@ -24,43 +36,40 @@ public TextElement TextElement`
`24`	`36`	`}`
`25`	`37`
`26`	`38`	`public MyHyperlinkButton(LinkInline linkInline, string? baseUrl)`
	`39`	`+ : this(linkInline.GetDynamicUrl != null ? linkInline.GetDynamicUrl() ?? linkInline.Url : linkInline.Url, baseUrl, null, linkInline)`
`27`	`40`	`{`
`28`		`- _baseUrl = baseUrl;`
`29`		`- var url = linkInline.GetDynamicUrl != null ? linkInline.GetDynamicUrl() ?? linkInline.Url : linkInline.Url;`
`30`		`- _linkInline = linkInline;`
`31`		`- Init(url, baseUrl);`
`32`	`41`	`}`
`33`	`42`
`34`	`43`	`public MyHyperlinkButton(HtmlNode htmlNode, string? baseUrl)`
	`44`	`+ : this(htmlNode.GetAttribute("href", "#"), baseUrl, htmlNode, null)`
`35`	`45`	`{`
`36`		`- _baseUrl = baseUrl;`
`37`		`- _htmlNode = htmlNode;`
`38`		`- var url = htmlNode.GetAttribute("href", "#");`
`39`		`- Init(url, baseUrl);`
`40`	`46`	`}`
`41`	`47`
`42`		`- private void Init(string? url, string? baseUrl)`
	`48`	`+ private MyHyperlinkButton(string? url, string? baseUrl, HtmlNode? htmlNode, LinkInline? linkInline)`
`43`	`49`	`{`
`44`		`- _hyperLinkButton = new HyperlinkButton()`
	`50`	`+ _baseUrl = baseUrl;`
	`51`	`+ _htmlNode = htmlNode;`
	`52`	`+ _linkInline = linkInline;`
	`53`	`+ _hyperLinkButton = new HyperlinkButton`
`45`	`54`	`{`
`46`	`55`	`NavigateUri = Extensions.GetUri(url, baseUrl),`
`47`	`56`	`};`
`48`	`57`	`_hyperLinkButton.Padding = new Thickness(0);`
`49`	`58`	`_hyperLinkButton.Margin = new Thickness(0);`
`50`		`- if (IsHtml && _htmlNode != null)`
	`59`	`+ if (_htmlNode != null)`
`51`	`60`	`{`
`52`	`61`	`_flowDoc = new MyFlowDocument(_htmlNode);`
`53`	`62`	`}`
`54`		`- else if (_linkInline != null)`
	`63`	`+ else`
`55`	`64`	`{`
`56`		`- _flowDoc = new MyFlowDocument(_linkInline);`
	`65`	`+ _flowDoc = new MyFlowDocument(_linkInline!);`
`57`	`66`	`}`
`58`	`67`	`_inlineUIContainer.Child = _hyperLinkButton;`
`59`		`- _hyperLinkButton.Content = _flowDoc?.RichTextBlock;`
	`68`	`+ _hyperLinkButton.Content = _flowDoc.RichTextBlock;`
`60`	`69`	`}`
`61`	`70`
`62`	`71`	`public void AddChild(IAddChild child)`
`63`	`72`	`{`
`64`		`- _flowDoc?.AddChild(child);`
	`73`	`+ _flowDoc.AddChild(child);`
`65`	`74`	`}`
`66`	`75`	`}`