WebView.cs

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Data;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Reflection;
using System.IO;
using System.Diagnostics;
using Sage.ES.S50.WebView;

namespace Sage.ES.S50.WebView
{
    public partial class WebView : UserControl
    {
        #region Constantes
        private const string RUNTIMEWEBVIEW = "Runtime del WebView2 de Microsoft Edge";
        #endregion Constantes

        #region Propiedades privadas
        private Assembly _oAssemblyGetView2 = null;
        private dynamic _oWebView2 = null;
        private Type _oTypeWebView2 = null;
        private dynamic _oWebViewController = null;
        private Type _oTypeWebViewController = null;
        private bool _lScriptErrorsSuppressed = false;
        private bool _lOpenLinkDefaultBrowser = true;
        private bool _lOpenNewWindowDefaultBrowser = false;
        private bool _lCancelNewWindowRequested = false;
        private bool _lContextMenuEnabled = true;
        private bool _lAreBrowserAcceleratorKeysEnabled = true;
        private bool _lResponseReceived = false;
        private bool _lAutoRefreshDocument = false;
        private string _cUserDataFolder = string.Empty;
        private BackgroundWorker _oBackgroundWorker = null;
        private bool _lBackgroudWorkerIsRunning = false;
        private string _cPathRuntime = "";
        private string _cExecutableRuntime = "";
        private bool _lRuntimeInstalled = false;
        private bool _disposed = false;
        #endregion Propiedades privadas

        #region Eventos y delegados
        public event _NavigationStarting_Handler _NavigationStarting;

        public delegate void _NavigationStarting_Handler();

        public event _NavigationCompleted_Handler _NavigationCompleted;


        public delegate void _NavigationCompleted_Handler(string tcUrl, bool tlIsSuccess);

        public event _MouseUp_Handler _MouseUp;

        public delegate void _MouseUp_Handler(string tcTipo, string tcValue, string tcId);

        public event _MouseDown_Handler _MouseDown;

        public delegate void _MouseDown_Handler(string tcTipo, string tcValue);

        public event _MouseLeave_Handler _MouseLeave;

        public delegate void _MouseLeave_Handler();

        public event _WebResourceResponseReceived_Handler _WebResourceResponseReceived;

        public delegate void _WebResourceResponseReceived_Handler(int tnHttpResponseStatusCode);

        public event _KeyPress_Handler _KeyPress;

        public delegate void _KeyPress_Handler(KeyPressEventArgs e);

        public event _Click_Handler _ContentClick;

        public delegate void _Click_Handler(object sender, EventArgs e);

        public event _EndGetHTML_Handler _EndGetHTML;

        public delegate void _EndGetHTML_Handler(string tcHtml);

        public event _Log_Handler _Log;

        public delegate void _Log_Handler(string tcLog);

        public event _PrintBefore_Handler _PrintBefore;

        public delegate void _PrintBefore_Handler();

        public event _PrintAfter_Handler _PrintAfter;

        public delegate void _PrintAfter_Handler();
        #endregion Evenos y delegados

        #region Constructor
        public WebView()
        {
            _Inicializar();

            if (!DesignMode)
                InstanciarWebView();
        }

        public WebView(bool tlValidateRuntime)
        {
            _Inicializar();

            IsRunTimeInstalled();
        }
        #endregion Consctructor

        #region Propiedades públicas
        public string _Mensaje_Error = string.Empty;

        public HtmlDocument Document
        {
            get { return _oWebView2 != null ? _oWebView2.Document : null; }
        }

        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool ScriptErrorsSuppressed
        {
            get { return _lScriptErrorsSuppressed; }
            set
            {
                if (_oWebView2 != null)
                {
                    _oWebView2.ScriptErrorsSuppressed = value;
                    _lScriptErrorsSuppressed = value;
                }
            }
        }

        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool _OpenLinkDefaultBrowser
        {
            get { return _lOpenLinkDefaultBrowser; }
            set
            {
                _lOpenLinkDefaultBrowser = value;

                if (_oWebView2 != null)
                    _oWebView2._OpenLinkDefaultBrowser = value;
            }
        }


        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool _OpenNewWindowDefaultBrowser
        {
            get { return _lOpenNewWindowDefaultBrowser; }
            set {
                    _lOpenNewWindowDefaultBrowser = value;

                    if (_oWebView2 != null)
                        _oWebView2._OpenNewWindowDefaultBrowser = value;
            }
        }


        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool _CancelNewWindowRequested
        {
            get { return _lCancelNewWindowRequested; }
            set
            {
                _lCancelNewWindowRequested = value;

                if (_oWebView2 != null)
                    _oWebView2._CancelNewWindowRequested = value;
            }
        }

        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool _ContextMenuEnabled
        {
            get { return _lContextMenuEnabled; }
            set
            {
                _lContextMenuEnabled = value;

                if (_oWebView2 != null)
                    _oWebView2._ContextMenuEnabled = value;
            }
        }

        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool _AreBrowserAcceleratorKeysEnabled
        {
            get { return _lAreBrowserAcceleratorKeysEnabled; }
            set
            {
                _lAreBrowserAcceleratorKeysEnabled = value;

                if (_oWebView2 != null)
                    _oWebView2._AreBrowserAcceleratorKeysEnabled = value;
            }
        }

        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool _ResponseReceived
        {
            get { return _lResponseReceived; }
            set {
                _lResponseReceived = value;

                if (_oWebView2 != null)
                    _oWebView2._ResponseReceived = value;
                }
        }

        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool _AutoRefreshDocument
        {
            get { return _lAutoRefreshDocument; }
            set {
                _lAutoRefreshDocument = value;

                if (_oWebView2 != null)
                    _oWebView2._AutoRefreshDocument = value;
                }
        }

        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public string _UserDataFolder
        {
            get { return _cUserDataFolder; }
            set
            {
                _cUserDataFolder = value;

                if (_oWebView2 != null)
                    _oWebView2._UserDataFolder = value;
            }
        }

        private Dictionary<string, string> _dicVirtualHostNameMappings = new Dictionary<string, string>();

        public void AddVirtualHostNameMapping(string alias, string ruta)
        {
            if (string.IsNullOrWhiteSpace(alias) || string.IsNullOrWhiteSpace(ruta))
                return;

            if (_dicVirtualHostNameMappings.ContainsKey(alias))
                _dicVirtualHostNameMappings[alias] = ruta;
            else
                _dicVirtualHostNameMappings.Add(alias, ruta);
        }

        public bool _WebViewOk
        {
            get { return _oWebView2 != null; }
        }
        #endregion Propiedades públicas

        #region Métodos públicos
        public void _Initialize()
        {
            if (_oWebView2 != null)
                return;

            InstanciarWebView();
        }

        public void _RefreshDocument()
        {
            if (_oWebView2 != null)
                _oWebView2._RefreshDocument();
        }

        public void DisableElementById(string tcId)
        {
            if (_oWebView2 != null)
                _oWebView2.DisableElementById(tcId);
        }


        public void _Print(string tcTitulo = "")
        {
            _oWebView2?._Print(tcTitulo);
        }

        public dynamic _PrintAsync(string tcPrinterName, int tnCopies = 0, string tcTitulo = "")
        {
           return _oWebView2?._PrintAsync(tcPrinterName, tnCopies, tcTitulo);
        }


        #endregion Métodos públicos

        #region Métodos privados
        private void GetTypeWebView(Assembly toAssembly)
        {
            try
            {
                _oTypeWebView2 = toAssembly.GetType("Sage.ES.S50.WebView2.WebView2");

                if (_oWebView2 == null)
                    _oWebView2 = Activator.CreateInstance(_oTypeWebView2, null);
            }
            catch (Exception loEx)
            {
                _LogWebView($"Se ha producido un error al instanciar el componente WebView2 {loEx.Message}");
            }
        }

        private void GetTypeWebViewController(Assembly toAssembly)
        {
            try
            {
                _oTypeWebViewController = toAssembly.GetType("Sage.ES.S50.WebView2.WebViewController");

                if (_oWebViewController == null)
                    _oWebViewController = Activator.CreateInstance(_oTypeWebViewController, null);
            }
            catch (Exception loEx)
            {
                _LogWebView($"Se ha producido un error al instanciar el WebViewController {loEx.Message}");
            }
        }


        private Assembly LoadAssemblyWebView()
        {
            if (_oAssemblyGetView2 != null)
                return _oAssemblyGetView2;

            Assembly loAssembly = null;

            string lcDllWebView = "Sage.ES.S50.WebView2.dll";

            var assemblies = AppDomain.CurrentDomain.GetAssemblies();
            IEnumerable<Assembly> lstAssemblies = lstAssemblies = assemblies.Where(x => x.ManifestModule.ToString() == lcDllWebView).ToList();

            if (lstAssemblies != null && lstAssemblies.Count() == 1)
                loAssembly = lstAssemblies.First();
            else
            {
                string lcRuta = Path.GetDirectoryName(GetType().Assembly.Location); // Buscamos la ruta don de tenemos la dll de Modelos "sage.50.exe"
                string lcLibraryWebView = Path.Combine(lcRuta, lcDllWebView);

                if (File.Exists(lcLibraryWebView))
                    loAssembly = LoadAssembly(lcLibraryWebView);
                else
                    _LogWebView("No se ha encontrado la librería para la carga del navegador WebView2.");
            }

            _oAssemblyGetView2 = loAssembly;

            return loAssembly;
        }

        private Assembly LoadAssembly(string tcPathFileDll)
        {
            // Intentar cargar el ensamblado de las 3 formas que nos funcionan.
            Assembly addonAssembly = null;

            try
            {
                addonAssembly = Assembly.LoadFrom(tcPathFileDll);
            }
            catch (Exception)
            {
            }

            if (addonAssembly != null)
            {
                try
                {
                    var appDomain = AppDomain.CreateDomain(tcPathFileDll);
                    addonAssembly = appDomain.Load(File.ReadAllBytes(tcPathFileDll));
                }
                catch (Exception)
                {
                }
            }

            if (addonAssembly != null)
            {
                try
                {
                    addonAssembly = Assembly.LoadFile(tcPathFileDll);
                }
                catch (Exception)
                {
                }
            }

            return addonAssembly;
        }

        public bool _IsRunTimeInstalled()
        {
            return IsRunTimeInstalled();
        }

        private bool IsRunTimeInstalled()
        {
            bool llOk = false;

            try
            {
                LoadAssemblyWebView();

                if (_oAssemblyGetView2 != null)
                {
                    GetTypeWebViewController(_oAssemblyGetView2);

                    if (_oTypeWebViewController != null && _oWebViewController != null)
                    {
                        var loVersion = _oWebViewController._GetVersion();

                        llOk = (loVersion._RuntimeInstalado);

                        if (!llOk)
                            _LogWebView($"No se ha podido instanciar el componente WebViewController. Revise si tiene instalado el {RUNTIMEWEBVIEW} (3).");
                    }
                    else
                    {
                        if (string.IsNullOrWhiteSpace(_Mensaje_Error))
                            _LogWebView($"No se ha podido instanciar el componente WebViewController. Revise si es necesario instalar el {RUNTIMEWEBVIEW} (2).");
                    }
                }
                else
                    _LogWebView($"No se ha podido cargar el componente WebViewController. Revise si es necesario instalar {RUNTIMEWEBVIEW} (1).");
            }
            catch (Exception loEx)
            {
                _LogWebView($"No se ha podido cargar el componente WebViewController. Revise si es necesario instalar {RUNTIMEWEBVIEW} (4). {loEx.Message}.");
            }

            return llOk;
        }

        private bool InstanciarWebView()
        {
            bool llOk = false;

            LoadAssemblyWebView();

            if (_oAssemblyGetView2 != null)
            {
                llOk = IsRunTimeInstalled();

                if (llOk)
                {
                    GetTypeWebView(_oAssemblyGetView2);

                    if (_oTypeWebView2 != null)
                    {
                        Controls.Add(_oWebView2);

                        _oWebView2.Dock = DockStyle.Fill;
                        _oWebView2._UserDataFolder = _cUserDataFolder;

                        foreach (KeyValuePair<string,string> mapping in _dicVirtualHostNameMappings)
                        {
                            _oWebView2.AddVirtualHostNameMapping(mapping.Key, mapping.Value);
                        }

                        ExecuteWebViewEvents(true); // Nos desubscribimos de todos los eventos
                        llOk = ExecuteWebViewEvents();
                    }
                    else
                        _LogWebView("No se ha podido instanciar el componente WebView2.");
                }
                else
                    _LogWebView("No se encuentra la versión del Runtime necesaria para instanciar el componente WebView2.");
            }
            else
                _LogWebView("No se ha podido cargar el componente WebView2.");

            return llOk;
        }

        private bool EventhandlerWebView(dynamic toInstance, bool tlUnSubscribe = false, string tcMetodo = "", string tcEvento = "")
        {
            if (_oTypeWebView2 == null)
                return false;

            bool llOk = false;

            MethodInfo method = GetType().GetMethod(tcMetodo, BindingFlags.Static | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic); // Nos subscribiremos al método privado de la clase WebView
            EventInfo eventInfo = _oTypeWebView2.GetEvent(tcEvento); // Evento de la clase WebView2

            if (method != null && eventInfo != null)
            {
                try
                {
                    // Creamos el delegado se corresponde a `new EventHandler()
                    Delegate handler = Delegate.CreateDelegate(eventInfo.EventHandlerType, this, method);

                    if (handler != null) // Asignamos el eventhandler. Se corresponde a  `control._URLModelo += ...`.
                    {
                        if (tlUnSubscribe)
                            eventInfo.RemoveEventHandler(toInstance, handler);
                        else
                            eventInfo.AddEventHandler(toInstance, handler);

                        llOk = true;
                    }
                }
                catch (Exception)
                {
                    llOk = false;

                    if (!tlUnSubscribe) // De momento únicamente me interesa al subcribir
                        _LogWebView("No se ha podido subscribir al evento " + tcEvento + " del WebView2.");
                }
            }
            else
            {
                llOk = false;

                if (!tlUnSubscribe) // De momento únicamente me interesa al subcribir
                    _LogWebView("No se ha podido subscribir al evento " + tcEvento + " del WebView2.");
            }

            return llOk;
        }

        private bool ExecuteWebViewEvents(bool tlUnSubscribe = false)
        {
            bool llOk = false;

            llOk = EventhandlerWebView(_oWebView2, tlUnSubscribe, "_NavigationStartingWebView", "_NavigationStarting");
            llOk = EventhandlerWebView(_oWebView2, tlUnSubscribe, "_NavigationCompletedWebView", "_NavigationCompleted");
            llOk = EventhandlerWebView(_oWebView2, tlUnSubscribe, "_WebResourceResponseReceivedWebView", "_WebResourceResponseReceived");
            llOk = EventhandlerWebView(_oWebView2, tlUnSubscribe, "_MouseUpWebView", "_MouseUp");
            llOk = EventhandlerWebView(_oWebView2, tlUnSubscribe, "_MouseDownWebView", "_MouseDown");
            llOk = EventhandlerWebView(_oWebView2, tlUnSubscribe, "_MouseLeaveWebView", "_MouseLeave");
            llOk = EventhandlerWebView(_oWebView2, tlUnSubscribe, "_KeyPressWebView", "_KeyPress");
            llOk = EventhandlerWebView(_oWebView2, tlUnSubscribe, "_ContentClickWebView", "_ContentClick");
            llOk = EventhandlerWebView(_oWebView2, tlUnSubscribe, "_EndGetHTMWebView", "_EndGetHTML");
            llOk = EventhandlerWebView(_oWebView2, tlUnSubscribe, "_LogWebView", "_Log");
            llOk = EventhandlerWebView(_oWebView2, tlUnSubscribe, "_PrintBeforeWebView", "_PrintBefore");
            llOk = EventhandlerWebView(_oWebView2, tlUnSubscribe, "_PrintAfterWebView", "_PrintAfter");


            return llOk;
        }

        private void Visibility()
        {
            if (!Visible)
                Visible = true;
        }

        private void MensajeError(string tcMensaje_Error)
        {
            _Mensaje_Error = tcMensaje_Error;

            _LogWebView(tcMensaje_Error);
        }

        private bool InstallRuntime()
        {
            _LogWebView("Inicio de la instalación del Runtime del WebView2");

            bool llOk = false;

            Process loProcess = new Process();

            string lcPathFileNameServer = Path.Combine(_cPathRuntime, _cExecutableRuntime);

            if (!File.Exists(lcPathFileNameServer))
            {
                _LogWebView($"No se ha encontrado en el servidor el fichero para la instalación del {RUNTIMEWEBVIEW}.");
                return false;
            }

            string lcTempPath = Path.GetTempPath();
            string lcPathFileNameTemp = Path.Combine(lcTempPath, _cExecutableRuntime);

            if (File.Exists(lcPathFileNameTemp))  // Intentamos borrar el fichero del instalador si existe en el temp
                File.Delete(lcPathFileNameTemp);

            ProcessStartInfo loExe = new ProcessStartInfo(lcPathFileNameServer); // Lo ejecutamos a partir de la ruta del servidor

            loExe.WorkingDirectory = lcTempPath; // Se realizará la descarga en el temp d
            loExe.Arguments = @" /silent /install";
            loProcess.StartInfo = loExe;
            loProcess.StartInfo.CreateNoWindow = true;
            loProcess.EnableRaisingEvents = true;
            loExe.WindowStyle = ProcessWindowStyle.Hidden;

            try
            {
                llOk = loProcess.Start();
                loProcess.WaitForExit();

                if (loProcess.ExitCode == 0)
                    _LogWebView($"Ha finalizado la instalación del {RUNTIMEWEBVIEW}.");
                else
                    _LogWebView($"Se ha producido un error al instalar el {RUNTIMEWEBVIEW}." + Environment.NewLine + "Instale manualmente el {RUNTIMEWEBVIEW}. En el caso de dar error la instalación manual reinicie el ordenador antes de su instalación.");
            }
            catch (Exception loEx)
            {
                _LogWebView($"Se ha producido un error al instalar el {RUNTIMEWEBVIEW}.{Environment.NewLine}{loEx.Message }.");
                llOk = false;
            }

            return llOk;
        }

        private void DoInstallRuntime()
        {
            if (!_lBackgroudWorkerIsRunning)
            {
                _lBackgroudWorkerIsRunning = true;

                //Declaro un nuevo elemento
                _oBackgroundWorker = new BackgroundWorker();

                //Configuro
                _oBackgroundWorker.WorkerSupportsCancellation = true; // Permitimos realizar la cancelación
                _oBackgroundWorker.WorkerReportsProgress = false;

                //Declaro los procesos
                _oBackgroundWorker.DoWork += new DoWorkEventHandler(ExecuteRunWorker);
                _oBackgroundWorker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(RunWorkerCompleted);

                //Inicio la tarea asíncrona
                _oBackgroundWorker.RunWorkerAsync();
            }
        }

        private void ExecuteRunWorker(object sender, DoWorkEventArgs e)
        {
            try
            {
                WebviewResultadoBackgroundWorker loResult = new WebviewResultadoBackgroundWorker();
                loResult._Resultado = InstallRuntime();

                e.Result = loResult;
            }
            catch (Exception loEx)
            {
                _LogWebView($"Se ha producido un error al instalar {RUNTIMEWEBVIEW}.{Environment.NewLine}{loEx.Message }.");
            }
        }

        private void RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            if (e.Cancelled == false && e.Error == null && e.Result != null && e.Result is WebviewResultadoBackgroundWorker) //Sino he sido cancelado ni he registrado excepción
            {
                WebviewResultadoBackgroundWorker loWebviewResultadoBackgroundWorker = (WebviewResultadoBackgroundWorker)e.Result;

                _lRuntimeInstalled = loWebviewResultadoBackgroundWorker._Resultado;
            }

            _lBackgroudWorkerIsRunning = false;
        }
        #endregion Métodos privados

        #region Métodos protected internal
        protected internal void _NavigationStartingWebView()
        {
            _NavigationStarting?.Invoke();
        }

        public virtual void _WebResourceResponseReceivedWebView(int tnHttpResponseStatusCode)
        {
            _WebResourceResponseReceived?.Invoke(tnHttpResponseStatusCode);
        }

        protected internal void _NavigationCompletedWebView(string tcUrl, bool tlIsSuccess)
        {
            _NavigationCompleted?.Invoke(tcUrl, tlIsSuccess);
        }

        protected internal void _MouseUpWebView(string tcTipo, string tcValue, string tcId)
        {
            _MouseUp?.Invoke(tcTipo, tcValue, tcId);

            _MouseUpExecute(tcTipo, tcValue, tcId);
        }

        protected internal void _MouseDownWebView(string tcTipo, string tcValue)
        {
            _MouseDown?.Invoke(tcTipo, tcValue);
        }

        protected internal void _MouseLeaveWebView()
        {
            _MouseLeave?.Invoke();
        }

        protected internal void _LogWebView(string tcLog)
        {
            _Log?.Invoke(tcLog);

            _Mensaje_Error = tcLog;

            _Log_Analisis(tcLog);
        }

        protected internal void _KeyPressWebView(KeyPressEventArgs e)
        {
            _KeyPress?.Invoke(e);
        }

        protected internal void _ContentClickWebView(object sender, EventArgs e)
        {
            _ContentClick?.Invoke(sender, e);
        }

        protected internal void _EndGetHTMWebView(string tcHtml)
        {
            _EndGetHTML?.Invoke(tcHtml);
        }

        protected internal void _PrintBeforeWebView()
        {
            _PrintBefore?.Invoke();
        }

        protected internal void _PrintAfterWebView()
        {
            _PrintAfter?.Invoke();
        }


        #endregion Métodos protected internal 

        #region Métodos protected
        protected void _GetHtml()
        {
            if (_oWebView2 != null)
                _oWebView2._GetHtml();
        }

        protected void _ReadOnlyEditor(bool tlReadOnly)
        {
            if (_oWebView2 != null)
                _oWebView2._ReadOnlyEditor(tlReadOnly);
        }

        protected void _FocusEditor()
        {
            if (_oWebView2 != null)
                _oWebView2._FocusEditor();
        }

        protected void _PutDataEditor(string tcData)
        {
            if (_oWebView2 != null)
                _oWebView2._PutDataEditor(tcData);
        }
        #endregion Métodos protected

        #region Métodos public
        public void _InstallRuntime(string tcPath, string tcExecutable = "MicrosoftEdgeWebview2Setup.exe")
        {
            _LogWebView($"Se va a realizar la instalación del {RUNTIMEWEBVIEW}. (_InstallRuntime)");

            _cPathRuntime = tcPath;
            _cExecutableRuntime = tcExecutable;

            if (File.Exists(Path.Combine(_cPathRuntime, _cExecutableRuntime)))
            {
                _LogWebView($"Se va a realizara la instalación del  {RUNTIMEWEBVIEW}. {_cPathRuntime}. (_InstallRuntime)");

                DoInstallRuntime();
            }
            else
                _LogWebView($"No existe el fichero de instalación del {RUNTIMEWEBVIEW} ({_cExecutableRuntime}) en la ruta {_cPathRuntime}.");
        }

        public void Navigate(string tcUrl)
        {
            if (_oWebView2 != null)
                _oWebView2.Navigate(tcUrl);
            else
            {
                Visibility();
                _LogWebView($"Se ha producido un error al navegar a la URL {tcUrl}.");
            }
        }

        public void NavigateToEditor(string tcUrl, string tcDataEditor)
        {
            if (_oWebView2 != null)
                _oWebView2.NavigateToEditor(tcUrl, tcDataEditor);
            else
            {
                Visibility();
                _LogWebView($"Se ha producido un error al navegar al a URL {tcUrl}. (NavigateEditor)");
            }
        }

        public void Navigate(Uri toUri)
        {
            if (_oWebView2 != null)
                _oWebView2.Navigate(toUri);
            else
            {
                Visibility();
                _LogWebView($"Se ha producido un error al navegar a la URL {toUri.AbsoluteUri}. ");
            }
        }

        public void NavigateToString(string tcHtmlContent)
        {
            if (_oWebView2 != null)
                _oWebView2.NavigateToString(tcHtmlContent);
            else
            {
                Visibility();
                _LogWebView("Se ha producido un error al cargar el HTML.");
            }
        }

        public void NavigateWithPost(string tcUrl, Stream toPostData, string tcHeaders = "Content-Type: application/x-www-form-urlencoded")
        {
            if (_oWebView2 != null)
                _oWebView2.NavigateWithPost(tcUrl, toPostData, tcHeaders);
            else
            {
                Visibility();
                _LogWebView($"Se ha producido un error al cargar la URL {tcUrl} por POST.");
            }

        }
        #endregion Métodos public

        #region Métodos protected virtual
        protected virtual void _Inicializar()
        {
        }
        #endregion Métodos protected virtual

        #region Métodos public virtual
        public virtual void _Log_Analisis(string tcLog)
        {
        }

        protected virtual bool _MouseUpExecute(string tcTipo, string tcValue, string tcIdOrName)
        {
            return true;
        }
        #endregion Métodos public virtual

        #region Estructura de resultados del BackGroundWorker
        public struct WebviewResultadoBackgroundWorker
        {
            public bool _Resultado;
        }
        #endregion Estructura de resultados del BackGroundWorker

    }
}