WPF WebBrowser - open links in default browser

Question

I am using a WPF System.Windows.Controls.WebBrowser control to show some HTML content that is downloaded from a service. Sometimes the HTML contains URLs ("a" elements) that should be clickable.

By default, when such an URL is clicked it opens in Internet Explorer. I want them to open in the default browser instead.

Note I am talking specifically about the WPF WebBrowser. There are tons of solutions for the WinForms browser, but they do not work for the WPF browser.

The most common "solution" is to handle the Navigating event, cancel it and then do your own thing with the URL. This does not work because the Navigating event is not called when I click a link in the HTML.

Another solution I found does seem to work, but only sometimes for some strange reason: https://stackoverflow.com/a/9111151/573249

I now have the following code, using the method from the link above:

private void WebBrowser_OnNavigating(object sender, NavigatingCancelEventArgs e)
{
    // Just for demonstration purposes
    // This is NOT CALLED when a link is clicked

    Debug.WriteLine("> Navigating called.");

    if (e.Uri == null)
    {
        Debug.WriteLine(">> URI was null.");
        return;
    }
    e.Cancel = true;
    Process.Start(e.Uri.AbsolutePath);
    Debug.WriteLine(">> Navigation cancelled and opened in default browser.");
}

private void WebBrowser_OnLoadCompleted(object sender, NavigationEventArgs e)
{
    Debug.WriteLine("> LoadCompleted called.");

    mshtml.HTMLDocument doc;
    doc = (mshtml.HTMLDocument) webBrowser.Document;
    mshtml.HTMLDocumentEvents2_Event iEvent;
    iEvent = (mshtml.HTMLDocumentEvents2_Event) doc;
    iEvent.onclick += new mshtml.HTMLDocumentEvents2_onclickEventHandler(ClickEventHandler);

    Debug.WriteLine("> LoadCompleted finished!");
    Debug.WriteLine("------");
}

private bool ClickEventHandler(mshtml.IHTMLEventObj e)
{
    // This finally opens the URL in the default browser
    // The method is called only 20% of the time.

    Debug.WriteLine(">> Click event handler called.");

    var a = (mshtml.HTMLAnchorElement) e.srcElement;
    Process.Start(a.href);
    return false;
}

When I click a link, it seems to work maybe 20% of the time. In those cases, "ClickEventHandler" is called, and the link is opened in the default browser. In the other 80% of the cases, "ClickEventHandler" is never called (and the link opens in IE), even though "OnLoadCompleted" finishes without exceptions.

There does not seem to be a pattern, although when it fails once it seems to keep failing forever on the same document until I re-load the HTML. After re-loading it is back to 20% chance of working.

What's going on?

Answer 1

Faced the issue of not firing "opening link" events at all. In my specific case, this was due to the attribute target set to _blank for all <a> elements indocument.

Solved by changing it to its default value _self in string representation just before calling NavigateToString.

From:

<a href="https://something.something" target="_blank">

To:

<a href="https://something.something" target="_self">

P.S. AFAIK, specifying the target as "_self" is redundant and in this case, the attribute can be omitted, but it's simpler to replace.

Answer 2

Hi I had exactly the same problem. OnMouseDown event was fired just sometimes. And I couldn't figure this out. I just gave up and used WinForm WebBrowser instead. Then you don't need reference for MSHTML but you need reference for System.Windows.Forms and System.Windows.Interactivity.

XAML

xmlns:wf="clr-namespace:System.Windows.Forms;assembly=System.Windows.Forms"

<WindowsFormsHost>
  <wf:WebBrowser x:Name="WbThumbs"/>
</WindowsFormsHost>

C#

public WMain() {
  System.Windows.Forms.Application.EnableVisualStyles();
  InitializeComponent();

  WbThumbs.DocumentCompleted += WbThumbsOnDocumentCompleted;
  WbThumbs.Navigate("www.blabla.com");
}

private void WbThumbsOnDocumentCompleted(object sender, System.Windows.Forms.WebBrowserDocumentCompletedEventArgs e) {
  if (WbThumbs.Document == null) return;
  WbThumbs.Document.Click += WbThumbs_Click;
}

private void WbThumbs_Click(object sender, System.Windows.Forms.HtmlElementEventArgs e) {
  var doc = WbThumbs.Document;
  var src = doc?.GetElementFromPoint(e.ClientMousePosition);
  if (src == null) return;
  //...
}

Answer 3

I checked a lot of related responses on SO, but only thing that have worked for me is answer from noseratio https://stackoverflow.com/a/20902928 I used few years ago on other Project where I had IE integrated in WPF Application. Now I am using in with WebBrowser and for me it works like a charm. Here is my Code:

    [ComVisible(true)]
    [ClassInterface(ClassInterfaceType.None)]
    [ComDefaultInterface(typeof(DWebBrowserEvents2))]
    public class WebBrowserEventSink : DWebBrowserEvents2
    {
        System.Runtime.InteropServices.ComTypes.IConnectionPoint sinkCp;
        int sinkCookie = int.MaxValue;
    
        public void Connect(System.Windows.Controls.WebBrowser webBrowser)
        {
            if (sinkCookie != int.MaxValue)
                throw new InvalidOperationException();
    
            var activeXInstance = webBrowser.GetType().InvokeMember("ActiveXInstance",
                BindingFlags.GetProperty | BindingFlags.Instance | BindingFlags.NonPublic,
                null, webBrowser, new object[] { }) as WebBrowser;
    
            // ReSharper disable once SuspiciousTypeConversion.Global
            var cpc = (System.Runtime.InteropServices.ComTypes.IConnectionPointContainer)activeXInstance;
            var guid = typeof(DWebBrowserEvents2).GUID;
            if (cpc != null)
            {
                System.Runtime.InteropServices.ComTypes.IConnectionPoint cp;
                cpc.FindConnectionPoint(ref guid, out cp);
                cp.Advise(this, out sinkCookie);
            }
        }
    
        public void Connect(InternetExplorer webBrowser)
        {
            if (sinkCookie != int.MaxValue)
                throw new InvalidOperationException();
    
            // ReSharper disable SuspiciousTypeConversion.Global
            var activeXInstance = webBrowser as WebBrowser;
            var cpc = (System.Runtime.InteropServices.ComTypes.IConnectionPointContainer)activeXInstance;
            // ReSharper restore SuspiciousTypeConversion.Global
            var guid = typeof(DWebBrowserEvents2).GUID;
            if (cpc != null)
            {
                System.Runtime.InteropServices.ComTypes.IConnectionPoint cp;
                cpc.FindConnectionPoint(ref guid, out cp);
                cp.Advise(this, out sinkCookie);
            }
        }
    
        public void Disconnect()
        {
            if (sinkCookie == int.MaxValue)
                throw new InvalidOperationException();
            if (sinkCp != null)
            {
                sinkCp.Unadvise(sinkCookie);
                sinkCookie = int.MaxValue;
            }
            sinkCp = null;
        }
    
        #region SHDocVw.DWebBrowserEvents2
    
        public void StatusTextChange(string text)
        {
        }
    
        public void ProgressChange(int progress, int progressMax)
        {
        }
    
        public void CommandStateChange(int command, bool enable)
        {
        }
    
        public void DownloadBegin()
        {
        }
    
        public void DownloadComplete()
        {
        }
    
        public void TitleChange(string text)
        {
        }
    
        public void PropertyChange(string szProperty)
        {
        }
    
        public void BeforeNavigate2(object pDisp, ref object url, ref object flags, ref object targetFrameName, ref object postData, ref object headers, ref bool cancel)
        {
            InvokeBeforeNavigate2(pDisp, ref url, ref flags, ref targetFrameName, ref postData, ref headers, ref cancel);
        }
    
        public void NewWindow2(ref object ppDisp, ref bool cancel)
        {
        }
    
        public void NavigateComplete2(object pDisp, ref object url)
        {
        }
    
        public void DocumentComplete(object pDisp, ref object url)
        {
            InvokeDocumentComplete(pDisp, ref url);
        }
    
        public void OnQuit()
        {
        }
    
        public void OnVisible(bool visible)
        {
        }
    
        public void OnToolBar(bool toolBar)
        {
        }
    
        public void OnMenuBar(bool menuBar)
        {
        }
    
        public void OnStatusBar(bool statusBar)
        {
        }
    
        public void OnFullScreen(bool fullScreen)
        {
        }
    
        public void OnTheaterMode(bool theaterMode)
        {
        }
    
        public void WindowSetResizable(bool resizable)
        {
        }
    
        public void WindowSetLeft(int left)
        {
        }
    
        public void WindowSetTop(int top)
        {
        }
    
        public void WindowSetWidth(int width)
        {
        }
    
        public void WindowSetHeight(int height)
        {
        }
    
        public void WindowClosing(bool isChildWindow, ref bool cancel)
        {
        }
    
        public void ClientToHostWindow(ref int cx, ref int cy)
        {
        }
    
        public void SetSecureLockIcon(int secureLockIcon)
        {
        }
    
        public void FileDownload(bool activeDocument, ref bool cancel)
        {
        }
    
        public void NavigateError(object pDisp, ref object url, ref object frame, ref object statusCode, ref bool cancel)
        {
        }
    
        public void PrintTemplateInstantiation(object pDisp)
        {
        }
    
        public void PrintTemplateTeardown(object pDisp)
        {
        }
    
        public void UpdatePageStatus(object pDisp, ref object nPage, ref object fDone)
        {
        }
    
        public void PrivacyImpactedStateChange(bool bImpacted)
        {
        }
    
        public void NewWindow3(ref object ppDisp, ref bool cancel, uint dwFlags, string bstrUrlContext, string bstrUrl)
        {
            InvokeNewWindow3(ref ppDisp, ref cancel, dwFlags, bstrUrlContext, bstrUrl);
        }
    
        public void SetPhishingFilterStatus(int phishingFilterStatus)
        {
        }
    
        public void WindowStateChanged(uint dwWindowStateFlags, uint dwValidFlagsMask)
        {
        }
    
        public void NewProcess(int lCauseFlag, object pWb2, ref bool cancel)
        {
        }
    
        public void ThirdPartyUrlBlocked(ref object url, uint dwCount)
        {
        }
    
        public void RedirectXDomainBlocked(object pDisp, ref object startUrl, ref object redirectUrl, ref object frame, ref object statusCode)
        {
        }
    
        public void BeforeScriptExecute(object pDispWindow)
        {
        }
    
        public void WebWorkerStarted(uint dwUniqueId, string bstrWorkerLabel)
        {
        }
    
        public void WebWorkerFinsihed(uint dwUniqueId)
        {
        }
    
        #endregion
    
        #region events
    
        #region NewWindow3
    
        internal delegate void NewWindow3EventHandler(ref object ppDisp, ref bool cancel, uint dwFlags, string bstrUrlContext, string bstrUrl);
    
        internal event NewWindow3EventHandler NewWindow3Event;
    
        internal void InvokeNewWindow3(ref object ppDisp, ref bool cancel, uint dwFlags, string bstrUrlContext, string bstrUrl)
        {
            var handler = NewWindow3Event;
            if (handler != null)
                handler(ref ppDisp, ref cancel, dwFlags, bstrUrlContext, bstrUrl);
        }
    
        #endregion
    
        #region before navigate 2
    
        internal delegate void BeforeNavigate2EventHandler(object pDisp, ref object url, ref object flags, ref object targetFrameName, ref object postData, ref object headers, ref bool cancel);
    
        internal event BeforeNavigate2EventHandler BeforeNavigate2Event;
    
        internal void InvokeBeforeNavigate2(object pDisp, ref object url, ref object flags, ref object targetFrameName, ref object postData, ref object headers, ref bool cancel)
        {
            var handler = BeforeNavigate2Event;
            if (handler != null)
                handler(pDisp, ref url, ref flags, ref targetFrameName, ref postData, ref headers, ref cancel);
        }
    
        #endregion
    
        #region DocumentComplete
    
        internal delegate void DocumentCompleteEventHandler(object pDisp, ref object url);
    
        internal event DocumentCompleteEventHandler DocumentCompleteEvent;
    
        internal void InvokeDocumentComplete(object pDisp, ref object url)
        {
            var handler = DocumentCompleteEvent;
            if (handler != null)
                handler(pDisp, ref url);
        }
    
        #endregion
    
        #endregion
    }

And here is usage:

    public TextViewer()
    {
        Loaded += TextViewer_OnLoaded;
        InitializeComponent();
    }
    private void TextViewer_OnLoaded(object sender, RoutedEventArgs e)
    {
        if (brwHtml != null)
        {
            _sink = new WebBrowserEventSink();
            _sink.Connect(brwHtml);
            _sink.NewWindow3Event += Sink_OnNewWindow3Event;
        }
    }
    private void Sink_OnNewWindow3Event(ref object ppDisp, ref bool cancel, uint dwFlags, string bstrUrlContext, string bstrUrl)
    {
        cancel = true;
        System.Diagnostics.Process.Start(bstrUrl);
    }