clsFormul.cs

using System;
using System.Collections.Generic;
using System.Windows.Forms;
using System.Xml;
using System.Drawing;
using System.Reflection;
using System.Runtime.InteropServices;
using System.ComponentModel;
using System.Data;

using sage.ew.functions;
using sage.ew.netvfp;
using sage.ew.global;
using sage.ew.ewbase;
using sage.ew.db;
using sage.ew.empresa;

// PE-86617. Botón en la barra de título
using sage.ew.formul.ButtonTittle;
using sage.ew.usuario;
using sage.ew.listados.Clases;
using sage.ew.formul.Forms;
using sage.ew.perfiles.Forms;
using sage.ew.interficies;
using sage.ew.objetos;
using sage.ew.txtbox.UserControls;
using Sage.ES.Onboarding.Interfaces;
using Sage.ES.Onboarding.Clases;
using Sage.ES.Onboarding.Forms;
using sage.ew.functions.Clases;
using Sage.ES.S50.Addons;
using System.Linq;
using sage.ew.ewbase.Clases;
using sage.ew.formul.Clases;
using System.Diagnostics;
using sage.ew.objetos.UserControls;
using sage.ew.images.Properties;
using sage.ew.botones;
using sage.ew.botones.UserControls;
using sage.ew.formul.UserControls;
using sage.ew.formul.ButtonsPanelSage;
using sage.ew.ewbase.Forms;
using mshtml;
using System.Web.Script.Serialization;

namespace sage.ew.formul
{
    #region ENUMERATIONS

    public enum TeclasRapidas
    {
        ninguna,
        Control_A,
        Control_B,
        Control_C,
        Control_D,
        Control_E,
        Control_F,
        Control_G,
        Control_H,
        Control_I,
        Control_J,
        Control_K,
        Control_L,
        Control_M,
        Control_N,
        Control_O,
        Control_P,
        Control_Q,
        Control_R,
        Control_S,
        Control_T,
        Control_U,
        Control_V,
        Control_X,
        Control_Y,
        Control_Z
    }

    public enum TeclasFuncion
    {
        ninguna,
        F1,
        F2,
        F3,
        F4,
        F5,
        F6,
        F7,
        F8,
        F9,
        Shift_F1,
        Shift_F2,
        Shift_F3,
        Shift_F4,
        Shift_F5,
        Shift_F6,
        Shift_F7,
        Shift_F8,
        Shift_F9,
        Control_F1,
        Control_F2,
        Control_F3,
        Control_F4,
        Control_F5,
        Control_F6,
        Control_F7,
        Control_F8,
        Control_F9,
        Alt_F1,
        Alt_F2,
        Alt_F3,
        Alt_F4,
        Alt_F5,
        Alt_F6,
        Alt_F7,
        Alt_F8,
        Alt_F9,
        Escape
    }

    public enum _TiposFormulario
    {
        Normal,
        Tactil
    }

    public enum _TiposAccesosPantalla
    {
        Denegado,
        SoloLectura,
        Completo,
        BajaSuscripcion
    }

    public enum _TiposAccesosMenu
    {
        Denegado,
        Completo
    }

    public enum eMotivoSoloLectura
    {
        Indeterminado = 0,
        Normal = 1,
        VersionDemo = 2
    }

    #endregion ENUMERATIONS

    [
        System.Drawing.ToolboxBitmap(typeof(System.Windows.Forms.Form)),
    ]
    public class FormBase : Form, IFormBase
    {
        #region Propiedades

        // PE-103236. Propiedad interna para que en caso de haber alguna irregularidad en la tabla Connect, sólo nos presente el mensaje de aviso una vez en cada pantalla
        private bool _lConnectFallido = false;

        private bool _lAutomatico = false;

        private eMotivoSoloLectura _motivoDeSoloLectura = eMotivoSoloLectura.Indeterminado;

        private Timer _oTimerProperties;

        private string _cPantalla = "";
        [
            Browsable(false),  // PE-87741
            Bindable(false),
            Category("Varios"),
            DefaultValue(typeof(string), ""),
            Description("Nombre del formulario equivalente de Eurowin."),
            Localizable(false)
        ]
        public virtual string _Pantalla
        {
            get { return _cPantalla; }
            set
            {
                bool llConstructor = (_cPantalla != value); // PARTE 92446. En gunas pantallas se ejecuta hasta 3 veces y presenta 3 mensajes si no tenemos acceso a la pantalla

                _cPantalla = value;

                // Asegurar que se controla el tema de accesos, readonly cuando se informe la pantalla correspondiente (PE-87996)
                // PE-87841 Se mira que no estemos en modo diseño ya que sino no se podía establecer la propiedad al crear formularios
                if (llConstructor && !string.IsNullOrWhiteSpace(_cPantalla) && !DesignMode)  // PARTE 92446
                    Constructor_Privado();
            }
        }

        public virtual string _IDScreen { get;}

        public Dictionary<string, object> _ValoresAccesoDirecto = new Dictionary<string, object>();

        //PE-105409    
        [Browsable(false),
        Bindable(false),
        Category("Varios"),
        DefaultValue(false),
        Description("Estilos revisados."),
        Localizable(false)]
        public virtual bool _EstiloRevisado
        {
            get { return estiloRevisado; }
            set { estiloRevisado = value; }
        }
        private bool estiloRevisado = false;

        public string _Sufijo
        {
            get { return _cSufijo; }
        }
        private string _cSufijo = string.Empty;

        public bool _SaveReuseFormSettings { get; set; } = true;

        protected bool _ReusingFormSettings { get; set; } = false;

        public Boolean _MostrarAcronimo
        {
            get
            {
                return _bMostrarAcronimo;
            }
            set
            {
                _bMostrarAcronimo = value;
                Revisar_Titulo_Formulario();
            }
        }
        private Boolean _bMostrarAcronimo = true;

        public Boolean _MostrarSufijo
        {
            get
            {
                return _bMostrarSufijo;
            }
            set
            {
                _bMostrarSufijo = value;
                Revisar_Titulo_Formulario();
            }
        }
        private Boolean _bMostrarSufijo = true;

        private String _Acronimo
        {
            get
            {
                String lcAcronimo = String.Empty;

                if (EW_GLOBAL._Empresa is Empresa && !String.IsNullOrEmpty(EW_GLOBAL._Empresa._Acronimo))
                {
                    lcAcronimo = String.Format("{0} |", EW_GLOBAL._Empresa._Acronimo);
                }
                return lcAcronimo;
            }
        }

        private InfoTooltip _oInfoToolTip = null;

        private InfoTooltip _InfoToolTip
        {
            get
            {
                if (_oInfoToolTip == null)
                {
                    _oInfoToolTip = new InfoTooltip();
                    _oInfoToolTip._Font = Font;
                    _oInfoToolTip.AutoPopDelay = 5000;
                    _oInfoToolTip.InitialDelay = 0;
                    _oInfoToolTip.ReshowDelay = 250;
                    _oInfoToolTip.ShowAlways = true;
                    _oInfoToolTip.Active = false;
                }

                return _oInfoToolTip;
            }
        }

        public String _ObtenerText(Boolean tlAcronimo)
        {
            String lcTitulo = Text;

            if ((_MostrarAcronimo && tlAcronimo) || (!_MostrarAcronimo && !tlAcronimo))
            {
                lcTitulo = Text;
            }
            else if (tlAcronimo)
            {
                lcTitulo = String.Format("{0} {1}", _Acronimo, Text);
            }
            else if (_MostrarAcronimo)
            {
                lcTitulo = _EliminarAcronimo(Text);
            }

            return lcTitulo;
        }

        [
            Browsable(false),
            Bindable(false),
            Category("Varios"),
            DefaultValue(true),
            Description("Obtiene o establece si el formulario debe controlar los permisos de usuario."),
            Localizable(false)
        ]
        public virtual bool _Gestionar_permisos
        {
            get { return _lGestionPermisos; }
            set { _lGestionPermisos = value; }
        }
        private bool _lGestionPermisos = true;

        [
            Browsable(false),
            Bindable(false),
            Category("Varios"),
            DefaultValue(false),
            Description("Obtiene o establece si se tiene acceso al formulario en modo Listas previas"),
            Localizable(false)
        ]
        public bool AccesoListasPrevias
        {
            get { return _lAccesoListasPrevias; }
            set { _lAccesoListasPrevias = value; }
        }
        private bool _lAccesoListasPrevias = false;

        //private PictureBox pbPantalla;
        private ContextMenuStrip contextMenuStripPantalla;
        private IContainer components;
        private ToolStripMenuItem nombreFormularioToolStripMenuItem;
        private ToolStripMenuItem gestiónDeFavoritosToolStripMenuItem;
        private ToolStripMenuItem gestiónDeAccesosToolStripMenuItem;
        private ToolStripMenuItem crearAccesoDirectoToolStripMenuItem;
        private ToolStripMenuItem crearApunteCalendarioItem;  //PE-96746
        private ToolStripMenuItem listadosPersonalizablesEditarItem;  //PE-103520
        private ToolStripMenuItem listadosPersonalizablesDuplicarItem;  //PE-103520
        private ToolStripMenuItem ayudaPantallaToolStripMenuItem; // PARTE 101745
        private ToolStripMenuItem crearTareaProgramadaItem;
        private ToolStripMenuItem configuracionesUsuarioItem;
        private ToolStripMenuItem toolConfiguracionesToolStripMenuItem;
        private ToolStripSeparator configuracionesUsuarioItemSeparator;
        private ToolStripMenuItem ShowPropertiesToolStripMenuItem;

        //private ToolStripMenuItem reordenarPantallasToolStripMenuItem;  // PE-102903,103085

        private oResultadoAyuda _oResultadoAyuda = new oResultadoAyuda();

        private List<Control> lstOpcionesMenuAddon = new List<Control>(); // Task 123210: Creación de botones en la barra de herramientas de los Mantes. Lista de controles para las opciones que se pueden añadir a los mantes y en el formulario de asientos

        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public ewcontextmenustrip _MenuContext_Opciones = new sage.ew.objetos.ewcontextmenustrip(); // Task 123210: Creación de botones en la barra de herramientas de los Mantes

        // PARTE 88665
        [
            Browsable(false),
            Bindable(false),
            Category("Varios"),
            DefaultValue(_TiposAccesosPantalla.Completo),
            Description("Nivel de acceso del usuario en el formulario actual."),
            Localizable(false)
        ]
        public virtual _TiposAccesosPantalla _NivelAcceso
        {
            get { return _nNivelAcceso; }
            set { _nNivelAcceso = value; }
        }
        private _TiposAccesosPantalla _nNivelAcceso = _TiposAccesosPantalla.Completo;
        // PARTE 88665

        [DllImport("user32.dll")]
        public static extern int SendMessage(IntPtr hWnd, Int32 wMsg, bool wParam, Int32 lParam);

        public objetos.ewErrorProvider _oErrorProvider;
        private const int WM_SETREDRAW = 11;

        [DllImport("user32.dll")]
        internal static extern bool EnableWindow(IntPtr hwnd, Boolean bEnable);

        [DllImport("user32.dll")]
        static extern bool SetWindowPos(IntPtr hWnd, IntPtr hWndInsertAfter, int X, int Y, int cx, int cy, uint uFlags);

        public _TiposFormulario _TipoFormulario
        {
            get { return _eTipoFormulario; }
            set { _eTipoFormulario = value; }
        }
        private _TiposFormulario _eTipoFormulario;

        public ConfigUserForm _ConfigUserForm
        {
            get { return _oConfigUserForm; }
            set { _oConfigUserForm = value; }
        }
        private ConfigUserForm _oConfigUserForm = null;

        public ConfigUserForm _ConfigUserFormPredet
        {
            get { return _oConfigUserFormPredet; }
            set { _oConfigUserFormPredet = value; }
        }
        private ConfigUserForm _oConfigUserFormPredet = null;

        private Dictionary<string, IConfigUserOption> dicAllConfigUserOptions = null;

        private Dictionary<string, Control> dicNoConfigUserOptions = null;

        private List<string> listConfigUserOptionsDisabled = null;

        private Color _eBackColor = SystemColors.Control, _eDefaultBackColor = SystemColors.Control;
        [
            Bindable(false),
            Category("Varios_Apariencia"),
            DefaultValue(typeof(Color), "Control"),
            Description("Obtiene o establece el color de fondo del control."),
            Localizable(false),
            DisplayName("Color del fondo")
        ]
        public Color _BackColor
        {
            get { return _eBackColor; }
            set
            {
                _eBackColor = value;
                _AplicarEstilo();
            }
        }

        protected bool _ConfigUserOptionsAllowed = false;

        protected bool _ConfigUserOptionsEditing = false;

        protected bool _ConfigUserOptionsLoading = false;

        // PE-69326. Guardamos el último control activo para asignarle el foco al activar el formulario
        //Control _oActiveControl = null;

        // PE-94010
        protected bool _CargandoEstilo = false;

        protected bool _CambiarFuente { get; set; } = true;

        protected List<string> _AddonsExtVisualCreacionAplazada = new List<string>();

        private bool _bAplicarEstilos = true;
        [
            Category("Varios_Apariencia"),
            DefaultValue(true),
            Description("Aplicar estilos visuales al control."),
            DisplayName("Aplicar estilos")
        ]
        public bool _AplicarEstilos
        {
            get { return _bAplicarEstilos; }
            set
            {
                _bAplicarEstilos = value;

                _AplicarEstilo();
            }
        }

        public virtual void _ResetAllProperties(bool tbRestablecer = false)
        {
            _BackColor = _eDefaultBackColor;

            // PE-
            if (tbRestablecer)
            {
                sage.ew.objetos.FUNCIONESESTILOS._RepintarObjectesForm(this, true);
            }
        }

        public Control _FindControl(string tcControlName)
        {
            Control loControl = null;

            Control[] loControls = this.Controls.Find(tcControlName, true);

            if (loControls.Length > 0)
            {
                loControl = loControls[0];
            }

            return loControl;
        }

        private ToolTip _oToolTip;
        [
            Bindable(false),
            Category("Varios"),
            DefaultValue(typeof(string), ""),
            Description("Permite asignar tooltips a los controles del formulario.\n Es necesario agregar una clase ToolTip al formulario y asignarla a esta propiedad."),
            Localizable(false),
            DisplayName("ToolTip")
        ]
        public ToolTip _ToolTip
        {
            get
            {
                if (_oToolTip == null) //Task 105418 Añadimos "lazy instantiation" para evitar errores de NullReferenceException
                    _oToolTip = new ToolTip();
                return _oToolTip;
            }
            set { _oToolTip = value; }
        }

        //PE-75827. Poder definir tecles ràpides als botons
        private Dictionary<string, object> ldicBotons = new Dictionary<string, object>();

        //PE-76605 : El objetivo de esta propiedad será dar al usuario (programador) si el formulario es de solo lectura.
        private bool _oReadOnly = false;
        [DefaultValue(false)]
        public virtual bool _ReadOnly
        {
            get { return _oReadOnly; }
            set
            {
                _oReadOnly = value;
                setReadOnly(this, _oReadOnly);
            }
        }

        private bool _bMenuOpcionesBoton = true;
        [
            Bindable(false),
            Category("Varios"),
            DefaultValue(false),
            Description("Muestra el botón opciones de pantalla en la barra de título del formulario."),
            Localizable(false),
            DisplayName("MenuOpcionesBoton")
        ]
        public bool _MenuOpcionesBoton
        {
            get { return _bMenuOpcionesBoton; }
            set
            {
                _bMenuOpcionesBoton = value;

                //if (EW_GLOBAL._EsEjecutable)
                //{
                //    _MostrarMenuOpcionesBoton();
                //}
            }
        }

        private bool _bMostrarAccesoFavoritos = true;
        [
            Bindable(false),
            Category("Varios"),
            DefaultValue(true),
            Description("Muestra el acceso a favoritos en el menú de opciones de la barra"),
            Localizable(false),
            DisplayName("MostrarAccesoFavoritos")
        ]
        public bool _MostrarAccesoFavoritos
        {
            get { return _bMostrarAccesoFavoritos; }
            set { _bMostrarAccesoFavoritos = value; }
        }

        private bool _bMostrarCrearAccesoDirecto = true;
        [
            Bindable(false),
            Category("Varios"),
            DefaultValue(true),
            Description("Muestra el acceso a crear accesos directos en el menú de opciones de la barra"),
            Localizable(false),
            DisplayName("MostrarCrearAccesoDirecto")
        ]
        public bool _MostrarCrearAccesoDirecto
        {
            get { return _bMostrarCrearAccesoDirecto; }
            set { _bMostrarCrearAccesoDirecto = value; }
        }

        private bool _bMostrarGestionAccesos = true;

        public bool _MostrarCrearTareaProgramada
        {
            get { return _bMostrarCrearTareaProgramada; }
            set { _bMostrarCrearTareaProgramada = value; }
        }
        private bool _bMostrarCrearTareaProgramada = false;

        public bool _MostrarDuplicarListado
        {
            get { return _bMostrarDuplicarListado; }
            set { _bMostrarDuplicarListado = value; }
        }
        private bool _bMostrarDuplicarListado = false;

        [
            Bindable(false),
            Category("Varios"),
            DefaultValue(true),
            Description("Muestra el acceso a gestión de accesos en el menú de opciones de la barra"),
            Localizable(false),
            DisplayName("MostrarGestionAccesos")
        ]
        public bool _MostrarGestionAccesos
        {
            get { return _bMostrarGestionAccesos; }
            set { _bMostrarGestionAccesos = value; }
        }


        [
            Bindable(false),
            Category("Varios"),
            DefaultValue(true),
            Description("Muestra el triangulo para titulo, favoritos, accesos"),
            Localizable(false),
            DisplayName("_TrianguloPantallaActivo")
        ]
        public bool _TrianguloPantallaActivo
        {
            get { return false; } // this.pbPantalla.Visible; }
            set
            {
                //this.pbPantalla.Visible = false;
                //this.pbPantalla.Enabled = false;
                //if (value)
                //    this.pbPantalla.SendToBack();
                //else
                //    this.pbPantalla.BringToFront();
            }
        }

        private eAyudaContextual botonayuda = eAyudaContextual.No;
        [
            Bindable(false),
            Category("Varios"),
            DefaultValue(true),
            Description("Muestra el botón ayuda en el título del formulario"),
            Localizable(false),
            DisplayName("_BotonAyuda")
        ]
        public eAyudaContextual _BotonAyuda
        {
            get { return botonayuda; }
            set
            {
                botonayuda = value;

                //if (EW_GLOBAL._EsEjecutable)
                //{
                //    _MostrarMenuOpcionesBoton();
                //}
            }
        }

        private bool mostrarayudaf1 = true;
        [
            Bindable(false),
            Category("Varios"),
            DefaultValue(true),
            Description("Muestrar la ayuda de Sage50 al pulsar F1"),
            Localizable(false),
            DisplayName("MostrarAyudaF1")
        ]
        public bool _MostrarAyudaF1
        {
            get { return mostrarayudaf1; }
            set { mostrarayudaf1 = value; }
        }

        //PE-86617. get an instance of IActiveMenu
        private IActiveMenu menu;

        // Para controlar que el mensaje de acceso sólo se muestre una vez
        private bool _lMensajeAccesoMostrado = false;

        public Dictionary<string, IDisposable> _BindForm
        {
            get { return _dictBindForm; }
        }
        private Dictionary<string, IDisposable> _dictBindForm = new Dictionary<string, IDisposable>();

        private FormSagePanel _oFormSagePanel = null;
        private FormSagePanel _FormSagePanel
        {
            get
            {
                if (!EsPantalla0 && _MenuOpcionesBoton && FormBorderStyle != FormBorderStyle.None)
                {
                    if (_oFormSagePanel == null) _oFormSagePanel = new FormSagePanel(this);
                    return _oFormSagePanel;
                }
                else
                {
                    return null;
                }
            }
        }

        public new FormWindowState WindowState
        {
            get
            {
                return base.WindowState;
            }
            set
            {
                if (value == FormWindowState.Maximized && _FormSagePanel is FormSagePanel) MaximumSize = _FormSagePanel._GetMaximunSize(this);
                base.WindowState = value;
            }
        }

        public bool _MessageBoxAutomatic
        {
            get { return _messageBoxAutomatic; }
        }
        protected bool _messageBoxAutomatic = false;

        #endregion Propiedades

        #region Eventos Messagebox

        public delegate void onMessageBoxBefore_Handler(ref MessageBoxParam toParam);

        public event onMessageBoxBefore_Handler onMessageBoxBefore;

        public delegate void onMessageBoxAfter_Handler(ref MessageBoxParam toParam);

        public event onMessageBoxAfter_Handler onMessageBoxAfter;

        public delegate void onMessageBoxInvalidate_Handler(ref MessageBoxParam toParam);

        public event onMessageBoxInvalidate_Handler onMessageBoxInvalidate;


        #endregion Eventos Messagebox

        #region Eventos y delegados

        const int WM_SYSCOMMAND = 0x112;

        public delegate bool _ExecuteCommandBeforeHandler(Form toForm, IntPtr toParam);

        public event _ExecuteCommandBeforeHandler _ExecuteCommandBefore;


        public delegate void GetOpciones_Handler(EventArgsOpciones toEnventArgOpciones);

        public event GetOpciones_Handler _GetOpciones;

        public delegate void GetOpcionesHerramientas_Handler(EventArgsOpciones toEnventArgOpciones);

        public event GetOpcionesHerramientas_Handler _GetOpcionesHerramientas;

        #endregion Eventos y delegados

        #region Métodos privados
        private void _MostrarMenuOpcionesBoton()
        {
            if (!_bMenuOpcionesBoton || this.FormBorderStyle == FormBorderStyle.None || IsDisposed || Disposing) return;

            // PE-90831. Volver a activar el botón´de opciones del titulo de las ventanas


            //PE-86617 IActiveMenu used to attach buttons to the form
            if (this is sage.ew.perfiles.Forms.frmGestionPerfil && !Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_sage50")))
            {
                // Res
            }
            else
            {
                if (this.FormBorderStyle != FormBorderStyle.None && !IsDisposed && !Disposing)
                {
                    // PARTE 92958. Las pantallas relacionadas con la pantalla de frmgestionPerfil se quedaban por detras en algunos casos                    
                    menu = ActiveMenu.GetInstance(this);

                    bool existeboton = false;

                    foreach (ActiveButton item in menu.Items)
                    {
                        if (item.Name == "MenuPantalla")
                        {
                            existeboton = true;

                            if (_bMenuOpcionesBoton == false)
                            {
                                menu.Items.Remove(item);
                            }

                            break;
                        }
                    }

                    if (_bMenuOpcionesBoton && existeboton == false && !EsPantalla0)
                    {
                        ActiveButtonAyuda buttonMenu = new ActiveButtonAyuda();
                        buttonMenu.Name = "MenuPantalla";
                        buttonMenu.Text = " ";
                        buttonMenu.Image = sage.ew.images.Properties.Resources.settings_16;
                        menu.ToolTip.SetToolTip(buttonMenu, "Opciones de pantalla ...");
                        buttonMenu.Click += new EventHandler(buttonMenu_Click);

                        // add the button to the menu
                        menu.Items.Add(buttonMenu);

                        // Configure colors
                        buttonMenu.ChangeColors();


                        ActiveButtonAyuda buttonHelp = new ActiveButtonAyuda();
                        buttonHelp.Name = "Help";
                        buttonHelp.Text = " ";
                        buttonHelp.Image = sage.ew.images.Properties.Resources.help_black_16;
                        menu.ToolTip.SetToolTip(buttonHelp, "Ayuda (F1)");
                        buttonHelp.Click += new EventHandler(buttonHelp_Click);

                        // add the button to the menu
                        menu.Items.Add(buttonHelp);

                        // Configure colors
                        buttonHelp.ChangeColors();
                    }

                    existeboton = false;

                    foreach (ActiveButton item in menu.Items)
                    {
                        if (item.Name == "Ayuda")
                        {
                            existeboton = true;

                            if (botonayuda != eAyudaContextual.Si)
                            {
                                menu.Items.Remove(item);
                            }

                            break;
                        }
                    }

                    if (botonayuda == eAyudaContextual.Si && existeboton == false && !EsPantalla0)
                    {
                        ActiveButtonAyuda buttonAyuda = new ActiveButtonAyuda();
                        buttonAyuda.Name = "Ayuda";
                        buttonAyuda.Text = " ";
                        buttonAyuda.Image = sage.ew.images.Properties.Resources.info_16;
                        menu.ToolTip.SetToolTip(buttonAyuda, "Panel de notificaciones");
                        buttonAyuda.Click += ButtonAyuda_Click;

                        // add the button to the menu
                        menu.Items.Add(buttonAyuda);

                        // Configure colors
                        buttonAyuda.ChangeColors();
                    }
                }
                else
                {
                    if (menu != null)
                        menu.Items.Clear();
                }
            }
            // FPARTE 92958
        }

        private Color GetPixel(Point position)
        {
            using (var bitmap = new Bitmap(1, 1))
            {
                using (var graphics = Graphics.FromImage(bitmap))
                {
                    graphics.CopyFromScreen(position, new Point(0, 0), new Size(1, 1));
                }
                return bitmap.GetPixel(0, 0);
            }
        }

        private void buttonHelp_Click(object sender, EventArgs e)
        {
            // Llamar al método para mostrar la ayuda
            _MostrarAyudaPantalla();
        }

        private void ButtonAyuda_Click(object sender, EventArgs e)
        {
            // Llamar al método para mostrar la ayuda de onboarding
            _MostrarAyuda();
        }

        public virtual void _MostrarAyuda()
        {
            MostrarAyuda();
        }

        public virtual void _MostrarCfgUsabilidad()
        {
            MostrarCfgUsabilidad();
        }

        private void buttonMenu_Click(object sender, EventArgs e)
        {
            Point loPoint;
            ActiveButton loButton = (ActiveButton)sender;
            ActiveMenuImpl loFrm = (ActiveMenuImpl)loButton.Parent;

            loPoint = new Point(loFrm.Location.X + loFrm.Size.Width, loFrm.Location.Y + loFrm.Size.Height);

            _MostrarOpcionesPantalla(loPoint);
        }

        public void _MostrarOpcionesPantalla(Point toLocation)
        {
            // Mostra el menú d'opcions del botó clicat

            // 92968 - 
            // Miro si el form està al diccionari
            if (!_PresentarGestionAccesos()) // PARTE 93077
                contextMenuStripPantalla.Items["gestiónDeAccesosToolStripMenuItem"].Visible = false;
            // fi 92698

            //PE-96200: Comprobamos si hay que mostrar el acceso a la gestión de favoritos
            if (!_PresentarAccesoFavoritos())
                contextMenuStripPantalla.Items["gestiónDeFavoritosToolStripMenuItem"].Visible = false;

            //PE-96746 Apuntes de calendario
            contextMenuStripPantalla.Items["crearApunteCalendarioItem"].Visible = _PresentarApunteCalendario();

            //Task 104592: Creacion de tarea programada
            contextMenuStripPantalla.Items["crearTareaProgramadaItem"].Visible = _PresentarTareaProgramada();

            // Ahora se muestra en una opción directa en la barra
            contextMenuStripPantalla.Items["ayudaPantallaToolStripMenuItem"].Visible = false;

            contextMenuStripPantalla.Items["ShowPropertiesToolStripMenuItem"].Visible = Debugger.IsAttached;

            GetOpcionesHerramientas();

            contextMenuStripPantalla.Show(toLocation, ToolStripDropDownDirection.Left);
        }

        private void GetOpcionesHerramientas()
        {
            if (_GetOpcionesHerramientas == null)
                return;

            // Preparamos la lista de opciones que se van a presentar en la pantalla
            List<ToolStripMenuItemBase> lstToolStripMenuItemsBase = new List<ToolStripMenuItemBase>();

            contextMenuStripPantalla.Items.OfType<ToolStripMenuItem>().ToList<ToolStripMenuItem>().
                    ForEach(item => lstToolStripMenuItemsBase.Add(new ToolStripMenuItemBase(item.Text, item.Name, item.ToolTipText)));

            GetOpcionesHerramientasInvoke(contextMenuStripPantalla, lstToolStripMenuItemsBase);
        }


        private void DisposeBindFormClass()
        {
            if (_dictBindForm == null)
                return;


            if (_dictBindForm.Count > 0)
            {
                try // Encapsulamos en un TRY por seguridad
                {
                    foreach (KeyValuePair<string, IDisposable> loClassIDisposable in _dictBindForm)
                        loClassIDisposable.Value.Dispose();

                    _dictBindForm.Clear();
                }
                catch (Exception) // NO gestionamos el posible error
                {
                }
            }

            _dictBindForm = null;

        }
        #endregion Métodos privados

        #region Métodos Protected

        // PARTE 93077
        protected bool _PresentarGestionAccesos()
        {
            //bool llShow = (EW_GLOBAL._GetFomsHera(this._Pantalla) != 1);            
            //return llShow;            

            //PE-95447: Cambiamos la comprobación de _GetFormsHera que permitía hacer salir o no la gestión de accesos para que el ToolStrip de Accesos salga siempre
            //return true;

            //PE-101487: Retornamos si se muestra o no la gestion de accesos
            return _bMostrarGestionAccesos;
        }

        protected virtual bool _PresentarTareaProgramada()
        {
            return _bMostrarCrearTareaProgramada;
        }

        // FPARTE 93077

        protected bool _PresentarAccesoFavoritos()
        {
            return _MostrarAccesoFavoritos;
        }

        protected bool _StateServiceForm(string tcPantalla = "")
        {
            bool llOk = true;
            string lcError = string.Empty;
            string lcPantalla = (string.IsNullOrWhiteSpace(tcPantalla) ? _Pantalla : tcPantalla).ToUpper();

            List<string> lstExluirPantallas = new List<string>() { "CENTRO_USUARIOS" };

            if (!string.IsNullOrWhiteSpace(lcPantalla) && !lstExluirPantallas.Contains(lcPantalla))
                llOk = FUNCTIONS._StateServiceForm(lcPantalla, out lcError);

            lstExluirPantallas.Clear();
            lstExluirPantallas = null;

            if (!llOk)
            {
                Opacity = 0;
                Close();
            }

            return llOk;
        }

        private bool ControlReadOnly(Control loCtrl)
        {
            Type loType = loCtrl.GetType();
            List<Type> loListTypes = new List<Type>() { typeof(ewlabel), typeof(ewSello), typeof(btNavegacion), typeof(ewWebBrowser), typeof(WebBrowser), typeof(EditorHTML), typeof(btDocSalir), typeof(btSalir), typeof(btDocCancelar) };
            List<string> loListNameTypes = new List<string>() { "Sage.ES.S50.Modelos.UserWebBrowserModelo", "sage.addons.gestdoc.Visual.UserControls.usercontrolGestDoc" };

            return !(loListTypes.Any(f => f == loType || f.IsAssignableFrom(loType)) || loListNameTypes.Any(f => f == loType.FullName));

        }

        private bool FormularioExcluidoReadOnly()
        {
            bool llExcluido = false;

            // PE-87996. Saltar el seteo de sólo lectura en los formularios de tipo frmGestionPerfil
            // Bug 199355 => Primera ejecución con asistente no debe bloquearlo
            // Bug 205406 => La consola de administración no se debe bloquear para poder cambiar licencia,...
            if ((this is sage.ew.perfiles.Forms.frmGestionPerfil) ||
                (this is sage.ew.usuario.Forms.frmAsistenteNuevoUsuario) ||
                (this is sage._50.Forms.frmConsolaAdmin))
            {
                llExcluido = true;
            }

            return llExcluido;
        }

        protected void setReadOnly(Control toControl, bool tbReadOnly)
        {
            bool llPropOk = false;

            // Excluimos algunos formularios del control de readonly
            if (FormularioExcluidoReadOnly())
                tbReadOnly = false;

            // PE-80756. Bloqueamos los controles
            foreach (Control loCtrl in toControl.Controls)
            {
                llPropOk = false;

                if (!ControlReadOnly(loCtrl))
                    continue;

                PropertyInfo propInfo = loCtrl.GetType().GetProperty("_ReadOnly");
                if (propInfo != null)
                {
                    propInfo.SetValue(loCtrl, tbReadOnly, null);

                    // PE-87966
                    if (loCtrl.HasChildren && loCtrl is sage.ew.objetos.ewtablelayoutpanel) setReadOnly(loCtrl, tbReadOnly);
                }
                else
                {
                    //PE-97998 : Hay algun control que nos da AmbiguousMatchException al intentar recuperar la propiedad "Controls".
                    //Tratamos la excepcion como un caso especial
                    try
                    {
                        propInfo = loCtrl.GetType().GetProperty("Controls");   // , BindingFlags.DeclaredOnly);  PE-87103. Que tambien tenga en cuenta los controles heredados
                        llPropOk = (propInfo != null);
                    }
                    catch (Exception loEx)
                    {
                        if (loEx is AmbiguousMatchException)
                        {
                            if (loCtrl.Controls.Count > 0) llPropOk = true;
                        }
                        else throw loEx;
                    }
                    //FI PE-97998


                    if (llPropOk && loCtrl.Controls.Count > 0)
                    {
                        setReadOnly(loCtrl, tbReadOnly);
                    }
                    else
                    {
                        propInfo = loCtrl.GetType().GetProperty("ReadOnly");
                        if (propInfo != null)
                        {
                            propInfo.SetValue(loCtrl, tbReadOnly, null);
                        }
                        else
                        {
                            propInfo = null;
                            propInfo = loCtrl.GetType().GetProperty("Enabled");
                            if (propInfo != null && !(loCtrl is TabPage))
                            {
                                propInfo.SetValue(loCtrl, !tbReadOnly, null);
                            }
                        }
                    }
                }
            }
        }

        //Task 152825 => Encapsulamos el método de evaluación para informar un eventual motivo de solo lectura
        protected _TiposAccesosPantalla EvaluarNivelAccesoFormularioPorCantidadDeRegistrosEn(string nombreTabla, int maxRegistros = -1)
        {
            //Acceso base
            _TiposAccesosPantalla nivelDeAcceso = _nNivelAcceso;
            _motivoDeSoloLectura = eMotivoSoloLectura.Normal;

            if (TengoAccesoCompleto())
            {
                if (EvaluarRegistrosTabla(nombreTabla, maxRegistros))
                {
                    nivelDeAcceso = _TiposAccesosPantalla.SoloLectura;
                    _motivoDeSoloLectura = eMotivoSoloLectura.VersionDemo;
                }
            }
            return nivelDeAcceso;
        }

        protected _TiposAccesosPantalla EvaluarNivelAccesoDocumentosPorCantidadDeRegistros(dynamic documento)
        {
            //Acceso base
            _TiposAccesosPantalla nivelDeAcceso = _nNivelAcceso;
            _motivoDeSoloLectura = eMotivoSoloLectura.Normal;

            if (TengoAccesoCompleto())
            {
                if (documento._Es_Version_Evaluacion())
                {
                    nivelDeAcceso = _TiposAccesosPantalla.SoloLectura;
                    _motivoDeSoloLectura = eMotivoSoloLectura.VersionDemo;
                }
            }
            return nivelDeAcceso;
        }

        #endregion Métodos Protected


        private bool EvaluarRegistrosTabla(string nombreTabla, int registros = -1)
        {
            if (registros > 0)
            {
                return FUNCTIONS._Es_Version_Evaluacion(nombreTabla, tnRegistros: registros, tlPresentarMensaje: false);
            }
            //Evaluacion sin especificar registros
            return FUNCTIONS._Es_Version_Evaluacion(nombreTabla, tlPresentarMensaje: false);
        }

        public bool FormularioDeSoloLecturaPorSerUnaDemo()
        {
            return _motivoDeSoloLectura == eMotivoSoloLectura.VersionDemo;
        }

        private bool TengoAccesoCompleto()
        {
            return _nNivelAcceso == _TiposAccesosPantalla.Completo;
        }

        public virtual void _AddonsAddCustomObject(Control objeto)
        {
            throw new Exception("Este formulario no se permite la personalización para Add-ons");
        }


        #region Constructor

        public FormBase()
            : this(false)
        {
        }

        public FormBase(bool tlPrincipal = false)
        {
            InitializeComponent();

            if (!DesignMode)
            {
                //if (tlPrincipal)
                //{
                //    Text = EW_GLOBAL._nHandleVfp.ToString();
                //    EW_GLOBAL._nHandleNet = (long)Handle;
                //}

                //Eventos que se declaraban en la capa visual
                SuscripcionEventosVisuales();

                if (EW_GLOBAL._EsEjecutable) //PE-97646 Añado condición _EsEjecutable para evitar errores en tiempo de diseño de formularios derivados
                {
                    SuscripcionEventosDeEjecutable();
                }
            }
        }

        #endregion Constructor


        protected override void OnCreateControl()
        {
            _AfterConstructorBase();
            base.OnCreateControl();
        }

        private void _AfterConstructorBase()
        {
            if (EW_GLOBAL._EsEjecutable)
            {
                _CargarEstilo();
                _AplicarEstilo();
            }

            if (EW_GLOBAL._EsEjecutable) //PE-97646 Añado condición _EsEjecutable para evitar errores en tiempo de diseño de formularios derivados
            {
                if (EW_GLOBAL._Moneda == null)
                {
                    EW_GLOBAL._Moneda = new Divisa();
                    EW_GLOBAL._Moneda._Codigo = Convert.ToString(EW_GLOBAL._GetVariable("wc_moneda"));   //el codigo ja fa el load                  
                }

                //PE81699
                if (EW_GLOBAL._Empresa == null)
                {
                    EW_GLOBAL._Empresa = new Empresa(Convert.ToString(EW_GLOBAL._GetVariable("wc_empresa")));
                }

                //Bug 102910: Si la empresa ha cambiado tenemos que recargar el objeto _Empresa
                if (((Empresa)EW_GLOBAL._Empresa)._Codigo != Convert.ToString(EW_GLOBAL._GetVariable("wc_empresa")))
                {
                    ((Empresa)EW_GLOBAL._Empresa)._Codigo = Convert.ToString(EW_GLOBAL._GetVariable("wc_empresa"));
                    //EW_GLOBAL._Empresa = new Empresa(Convert.ToString(EW_GLOBAL._GetVariable("wc_empresa")));
                }

                // PE-94362. Inicializamos una instancia de la clase Terminal
                if (EW_GLOBAL._Terminal == null)
                {
                    EW_GLOBAL._Terminal = new tpv.Clases.Terminal();
                }

                Constructor_Privado();

                if (WindowState == FormWindowState.Maximized && _FormSagePanel is FormSagePanel && !_ReusingFormSettings)
                {
                    WindowState = FormWindowState.Normal;
                    MaximumSize = _FormSagePanel._GetMaximunSize(this);
                    WindowState = FormWindowState.Maximized;
                }
            }
        }

        // Flag: Has Dispose already been called?
        bool disposed = false;

        protected override void Dispose(bool disposing)
        {
            if (disposed)
                return;

            if (disposing)
            {
                // Free any other managed objects here.
                CancelarSuscripcionEventosDeEjecutable();
                CancelarSuscripcionEventosVisuales();

                //if (timer is Timer)
                //{
                //    timer.Tick -= timer_Tick;
                //    timer.Dispose();
                //    timer = null;
                //}

                if (_oTimerProperties is Timer)
                {
                    _oTimerProperties.Tick -= _oTimerProperties_Tick;
                    _oTimerProperties.Dispose();
                    _oTimerProperties = null;
                }

                DisposeToolStripMenuItems();

                lstOpcionesMenuAddon?.Clear();
                lstOpcionesMenuAddon = null;

                _ToolStripMenuItemsBase?.Clear();
                _ToolStripMenuItemsBase = null;

                _MenuContext_Opciones.Items.Clear();
                _MenuContext_Opciones.Dispose();
                _MenuContext_Opciones = null;

                _AddonsExtVisualCreacionAplazada?.Clear();
                _AddonsExtVisualCreacionAplazada = null;

                ldicBotons?.Clear();
                ldicBotons = null;

                if (menu != null)
                {
                    menu.Items.Clear();
                    menu = null;
                }

                if (contextMenuStripPantalla != null)
                {
                    contextMenuStripPantalla.Items.Clear();
                    contextMenuStripPantalla?.Dispose();
                    contextMenuStripPantalla = null;
                }

                //El tooltip es un control propicio a generar memory leaks ya que mantiene referencias a los controles
                _oToolTip?.Dispose();
                _oToolTip = null;
                _oErrorProvider?.Dispose();
                _oBackgroundWorker?.Dispose();
                _oBackgroundWorker = null;

                if (_oFormAyuda != null)
                    _oFormAyuda._RefreshNoticiasPendientes -= FormAyuda__RefreshNoticiasPendientes;

                _oFormAyuda?.Dispose();
                _oFormAyuda = null;

                if (_ConfigUserOptionsAllowed && _ConfigUserOptionsEditing) _SubcripcionEventosEdicionOpcionesUsuario(false);

                DisposeBindFormClass();
            }

            // Free any unmanaged objects here.
            //

            disposed = true;
            // Call base class implementation.
            base.Dispose(disposing);
        }


        private void SuscripcionEventosDeEjecutable()
        {
            Load += FormBase_Load;
            KeyUp += FormBase_KeyUp;
            Activated += FormBase_Activated;
            FormClosed += FormBase_FormClosed;
            FormClosing += FormBase_FormClosing;
            Shown += FormBase_Shown;
            TextChanged += FormBase_TextChanged;
            Activated += Ayuda_Activated;
            Deactivate += Ayuda_Deactivate;
        }

        private void CancelarSuscripcionEventosDeEjecutable()
        {
            Load -= FormBase_Load;
            KeyUp -= FormBase_KeyUp;
            Activated -= FormBase_Activated;
            FormClosed -= FormBase_FormClosed;
            FormClosing -= FormBase_FormClosing;
            Shown -= FormBase_Shown;
            TextChanged -= FormBase_TextChanged;
            Activated -= Ayuda_Activated;
            Deactivate -= Ayuda_Deactivate;
        }

        private void SuscripcionEventosVisuales()
        {
            contextMenuStripPantalla.Opening += new CancelEventHandler(contextMenuStripPantalla_Opening);
            nombreFormularioToolStripMenuItem.Click += nombreFormularioToolStripMenuItem_Click;
            gestiónDeFavoritosToolStripMenuItem.Click += gestiónDeFavoritosToolStripMenuItem_Click;
            gestiónDeAccesosToolStripMenuItem.Click += gestiónDeAccesosToolStripMenuItem_Click;
            crearAccesoDirectoToolStripMenuItem.Click += crearAccesoDirectoToolStripMenuItem_Click;
            crearApunteCalendarioItem.Click += crearApunteCalendarioItem_Click;
            listadosPersonalizablesEditarItem.Click += listadosPersonalizablesEditarItem_Click;
            listadosPersonalizablesDuplicarItem.Click += listadosPersonalizablesDuplicarItem_Click;
            ayudaPantallaToolStripMenuItem.Click += ayudaPantallaToolStripMenuItem_Click;
            crearTareaProgramadaItem.Click += crearTareaProgramadaItem_Click;
            toolConfiguracionesToolStripMenuItem.Click += ConfiguracionesUsuarioItem_Click;
            ShowPropertiesToolStripMenuItem.Click += ShowPropertiesToolStripMenuItem_Click;
        }

        private void CancelarSuscripcionEventosVisuales()
        {
            contextMenuStripPantalla.Opening -= new CancelEventHandler(contextMenuStripPantalla_Opening);
            nombreFormularioToolStripMenuItem.Click -= nombreFormularioToolStripMenuItem_Click;
            gestiónDeFavoritosToolStripMenuItem.Click -= gestiónDeFavoritosToolStripMenuItem_Click;
            gestiónDeAccesosToolStripMenuItem.Click -= gestiónDeAccesosToolStripMenuItem_Click;
            crearAccesoDirectoToolStripMenuItem.Click -= crearAccesoDirectoToolStripMenuItem_Click;
            crearApunteCalendarioItem.Click -= crearApunteCalendarioItem_Click;
            listadosPersonalizablesEditarItem.Click -= listadosPersonalizablesEditarItem_Click;
            listadosPersonalizablesDuplicarItem.Click -= listadosPersonalizablesDuplicarItem_Click;
            ayudaPantallaToolStripMenuItem.Click -= ayudaPantallaToolStripMenuItem_Click;
            crearTareaProgramadaItem.Click -= crearTareaProgramadaItem_Click;
            toolConfiguracionesToolStripMenuItem.Click -= ConfiguracionesUsuarioItem_Click;
        }

        private void DisposeToolStripMenuItems()
        {
            nombreFormularioToolStripMenuItem?.Dispose();
            nombreFormularioToolStripMenuItem = null;

            gestiónDeFavoritosToolStripMenuItem?.Dispose();
            gestiónDeFavoritosToolStripMenuItem = null;

            gestiónDeAccesosToolStripMenuItem?.Dispose();
            gestiónDeAccesosToolStripMenuItem = null;

            crearAccesoDirectoToolStripMenuItem?.Dispose();
            crearAccesoDirectoToolStripMenuItem = null;

            listadosPersonalizablesEditarItem?.Dispose();
            listadosPersonalizablesEditarItem = null;

            listadosPersonalizablesDuplicarItem?.Dispose();
            listadosPersonalizablesDuplicarItem = null;

            ayudaPantallaToolStripMenuItem?.Dispose();
            ayudaPantallaToolStripMenuItem = null;

            configuracionesUsuarioItem?.Dispose();
            configuracionesUsuarioItem = null;

            configuracionesUsuarioItemSeparator?.Dispose();
            configuracionesUsuarioItemSeparator = null;

            crearApunteCalendarioItem?.Dispose();
            crearApunteCalendarioItem = null;

            crearTareaProgramadaItem?.Dispose();
            crearTareaProgramadaItem = null;

            crearTareaProgramadaItem?.Dispose();
            crearTareaProgramadaItem = null;

            ShowPropertiesToolStripMenuItem?.Dispose();
            ShowPropertiesToolStripMenuItem = null;
        }

        // 99599
        private void FormBase_TextChanged(object sender, EventArgs e)
        {
            if (!String.IsNullOrWhiteSpace(_Sufijo) || !String.IsNullOrWhiteSpace(_Acronimo))
            {
                Revisar_Titulo_Formulario();
            }
        }

        private void Revisar_Titulo_Formulario()
        {
            // Obtener el título del formulario sólo, sin acrónimo ni sufijos.
            if (!Text.Contains("(") && !Text.Contains(")") && (!_MostrarAcronimo || (_MostrarAcronimo && ((!string.IsNullOrWhiteSpace(_Acronimo) && !Text.Contains(_Acronimo)) || string.IsNullOrWhiteSpace(_Acronimo)))))
            {
                _cTituloFormulario = Text.Trim();
            }
            else //Listados de balances anuales etc tienen paréntesis en el título. Trato de repescarlos
            {
                if (_cTituloFormulario.Equals("FormFiltro")) //Nombre por defecto de un listado => Doy por bueno lo que sea que tenga en text
                    _cTituloFormulario = Text.Trim();
            }


            // Revisión de acrónimo y sufijos 
            bool llRevisarAcronimo = (!Text.StartsWith(_Acronimo) && _MostrarAcronimo) || (Text.StartsWith(_Acronimo) && !_MostrarAcronimo);
            bool llRevisarSufijo = (!Text.Contains(_Sufijo) && _MostrarSufijo) || (Text.Contains(_Sufijo) && !_MostrarSufijo);

            if (llRevisarAcronimo || llRevisarSufijo)
            {
                // Desmonto el event handler
                TextChanged -= new EventHandler(FormBase_TextChanged);

                // Revisar el acronimo y sufijo en el caption del formulario                
                Text = String.Format("{0}{1}{2}", _MostrarAcronimo ? _Acronimo + " " : "", _cTituloFormulario, _MostrarSufijo ? _Sufijo : "");

                // Vuelvo a montar el event handler
                TextChanged += new EventHandler(FormBase_TextChanged);
            }
        }
        // fi 99599

        private void FormBase_Shown(object sender, EventArgs e)
        {
          
            if (!string.IsNullOrWhiteSpace(_Pantalla) && !_StateServiceForm())
                return;

            //if (timer != null) // Si el Timer es null es que ya se ha ejecutado una vez y se ha realizado el Dispose ... Si se ha programado en un buble que va presentando el formulario no es neceasrio la gestión de la ayuda, refresco del caption ....
            //{
            //    // PE-99611. Retardem mostrar el menú de pantalla per evitar efectes raros            
            //    timer.Enabled = false;
            //    timer.Interval = 300;
            //    timer.Tick += new EventHandler(timer_Tick);
            //    timer.Enabled = true;
            //}

            Text = Text.Trim();

            if (!_cSufijo.Contains("(SQL_LOG)") && Convert.ToString(EW_GLOBAL._GetVariable("wc_sql_log")).Trim().ToUpper() == "SI")
            {
                _cSufijo += " (SQL_LOG)";
                Revisar_Titulo_Formulario();
            }

            if (!_lAutomatico) //Bug 206971: Sólo llamamos a AyudaOnBoarding() si no estamos en modo de tarea automática/acceso directo
                AyudaOnBoarding();

            // PE-102586. En sage50 hacemos que al abrir un formulario se muestre encima de todo
            if (Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_sage50")))
            {
                TopMost = true;
                Focus();
                BringToFront();
                TopMost = false;
            }
        }

        // PE-99611. Retardem mostrar el menú de pantalla per evitar efectes raros
        private Timer timer = new Timer();
        private void timer_Tick(object sender, EventArgs e)
        {
            timer.Enabled = false;
            timer.Dispose();
            timer = null;

            if (EW_GLOBAL._EsEjecutable && !IsDisposed && !Disposing) //PE-99878 Añado control de destruido por si no se llega a completar la carga (pe. no tiene perfil)
            {
                SuspendLayout();
                _MostrarMenuOpcionesBoton();
                //PE-94935 : Añadir la etiqueta del SQL_LOG al titulo del formulario
                Text = Text.Trim();

                if (!_cSufijo.Contains("(SQL_LOG)") && Convert.ToString(EW_GLOBAL._GetVariable("wc_sql_log")).Trim().ToUpper() == "SI")
                {
                    _cSufijo += " (SQL_LOG)";
                    Revisar_Titulo_Formulario();
                }

                AyudaOnBoarding();

                ResumeLayout();
            }
        }

        //PE-88499
        #region Asignar ErrorProvider a los controles

        //PE-88499
        protected override void OnLoad(EventArgs e)
        {
            base.OnLoad(e);

            _Asignar_ErrorProvider();

            // Configuraciones de pantalla
            ConfigUserOptionsUpdatePredet();
            ConfigUserOptionsLoad(ConfigUserOptionsGetPantalla());

        }

        private void _Asignar_ErrorProvider()
        {
            foreach (Control loControl in Controls)
            {
                _Asignar_ErrorProvider_Recursivo(loControl);
            }
        }

        //PE-88499
        private void _Asignar_ErrorProvider_Recursivo(Control toControl)
        {
            //Busco la propiedad _oErrorProvider
            PropertyInfo loPropiedad = toControl.GetType().GetProperty("_ErrorProvider", BindingFlags.Instance | BindingFlags.NonPublic);
            if (loPropiedad != null)
            {
                loPropiedad.SetValue(toControl, _oErrorProvider, null);
            }

            //Si el control contiene otros controles
            if (toControl.HasChildren)
            {
                //Por cada control hijo
                foreach (Control loChildControl in toControl.Controls)
                {
                    _Asignar_ErrorProvider_Recursivo(loChildControl); //me llamo recursivamente
                }
            }
        }

        #endregion Asignar ErrorProvider a los controles


        // PE-79517.
        public virtual void _CargarEstilo()
        {
            if (!EW_GLOBAL._EsEjecutable) return;

            _CargandoEstilo = true;

            // PE-86800. Forzar el tipo base para pintar el fondo del formulario
            XmlNode loNode = FUNCIONESESTILOS._Get_Aparence_Config(typeof(FormBase), "sage.ew.formul.FormBase");

            // Si em trobat node, apliquem les propietats
            Color loColor;
            string lcColor;

            if (loNode != null)
            {
                foreach (XmlElement element in loNode)
                {
                    PropertyInfo propInfo = GetType().GetProperty(element.Name);
                    if (propInfo != null)
                    {
                        // Anem assignant els valors a les propietats
                        switch (element.Name)
                        {
                            case "_AplicarEstilos":
                                _AplicarEstilos = element.InnerText.Trim().ToLower() == "true";
                                break;

                            case "_BackColor":
                                // Parsejem el valor per a assignar el RGB
                                lcColor = element.InnerText;
                                loColor = Name_To_Color(lcColor);
                                _BackColor = loColor;
                                break;
                        }
                    }
                }
            }
            else
            {
                // PE-95175. Si no hi ha node, forcem _AplicarEstilos a false
                _AplicarEstilos = false;
            }

            _CargandoEstilo = false;
        }

        // PE-93830.
        public virtual void _AplicarEstilo()
        {
            if (!EW_GLOBAL._EsEjecutable) return;

            if (_CargandoEstilo) return;

            if (_AplicarEstilos)
            {
                BackColor = _BackColor;
            }
            else
            {
                BackColor = _eDefaultBackColor;
            }
        }

        private void FormBase_FormClosing(object sender, FormClosingEventArgs e)
        {
            if (_SaveReuseFormSettings && Usuario._This._PosicionFormulario)
            {
                using (FormManagerProperties loFormManagerProperties = new FormManagerProperties(this))
                {
                    loFormManagerProperties._Save();
                }
            }

            FormBase_FormClosed_MenuItemsClear();


            // PE-79119. Antes de que la pantalla principal tome el foco, la activamos
            if (Application.OpenForms.Count == 2)
            {
                EnableWindow((IntPtr)EW_GLOBAL._nHandleVfp, true);
            }

            // Guardar configuraciones actuales de usuario
            if (_ConfigUserOptionsAllowed)
                ConfigUserOptionsUpdateLastValues();

            // Liberar memoria
            GC.Collect();
        }

        protected override void OnFormClosing(FormClosingEventArgs e)
        {
            base.OnFormClosing(e);

            if (!e.Cancel)
                FormBase_FormCling_OpemForms();
        }

        private void FormBase_FormClosed(object sender, FormClosedEventArgs e)
        {
            FUNCTIONS._GarbageCollect();

            // PE-79119. Activar la ventana principal
            if (Name == "frmDocVentaTpv" || Name == "frmGestionPerfil" || Name == "frmDocVentaPed" || Name == "frmPerfilSeleccion" || Name == "frmSincroniza")
            {
                EnableWindow((IntPtr)EW_GLOBAL._nHandleVfp, true);
            }
        }

        private void FormBase_FormClosed_MenuItemsClear()
        {
            // PE-86617. Limpiar el menu de la barra de títulos
            if (this is frmGestionPerfil)
            {
                // PE-90831. No mostramos el botón en los formularios basados en frmGestionPerfil
            }
            else
            {
                // PE-91209. Controla null
                if (menu != null)
                    menu.Items.Clear();
            }
        }

        private void FormBase_FormCling_OpemForms()
        {
            // PE-100744. Eliminar de la pila la referencia del último formulario abierto
            if (EW_GLOBAL._OpenForms.Count > 1) // PE-100977, 101030 -> No quitar de la pila el formulario principal para evitar errores ya que es el primer formulario                
            {
                List<Form> loOpenForms = EW_GLOBAL._OpenForms.AsEnumerable().Reverse().ToList();
                EW_GLOBAL._OpenForms.Clear();
                loOpenForms.Where(f => f != this).ToList().ForEach(f => EW_GLOBAL._OpenForms.Push(f));

                // PE-103236. Actualizar la tabla CONNECT sólo en caso de quedar frmPrincipal, el resto ya se tratan des del Activated.
                if (EW_GLOBAL._OpenForms.Count == 1 && !_lConnectFallido)
                {
                    if (!Usuario._This._Revisar_Connect_Formulario((FormBase)EW_GLOBAL._OpenForms.Peek()))
                    {
                        // PE-103711. Mostrar el mensaje desde fuera de la clase de negocio para no interferir en el funcionamiento
                        MessageBox.Show(Usuario._This._Error_Message, Convert.ToString(EW_GLOBAL._GetVariable("wc_nameproducto")), MessageBoxButtons.OK, MessageBoxIcon.Warning, MessageBoxDefaultButton.Button1);
                    }
                }
            }
        }


        private void FormBase_Activated(object sender, EventArgs e)
        {
            // PE-103236. Revisar y actualizar tabla CONNECT

            if (!_lConnectFallido && !Usuario._This._Revisar_Connect_Formulario(this))
            {
                _lConnectFallido = true;

                // PE-103711. Mostrar el mensaje desde fuera de la clase de negocio para no interferir en el funcionamiento
                MessageBox.Show(Usuario._This._Error_Message, Convert.ToString(EW_GLOBAL._GetVariable("wc_nameproducto")), MessageBoxButtons.OK, MessageBoxIcon.Warning, MessageBoxDefaultButton.Button1);

                if (Name != "frmPrincipal")
                    Close();
            }

            // En caso de sage50 no hay que hacer nada (PE-93758)
            if (!Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_sage50")))
            {
                long lnHandle;
                lnHandle = (long)Handle;

                // PE-79119. No pasar el Handle de la pantalla principal
                if (Name == "frmDocVentaTpv" || Name == "frmGestionPerfil" || Name == "frmDocVentaPed" || Name == "frmPerfilSeleccion" || Name == "frmSincroniza")
                {
                    // PE-79276. Forcem a primer pla la pantalla de selcció de perfils perque si s'obre un segon perfil (damunt d'un obert ja) quedava per sota
                    if (Name == "frmPerfilSeleccion")
                    {
                        IntPtr HWND_TOPMOST = new IntPtr(-1);
                        const UInt32 SWP_NOSIZE = 0x0001;
                        const UInt32 SWP_NOMOVE = 0x0002;
                        const UInt32 SWP_SHOWWINDOW = 0x0040;

                        // Call this way:
                        SetWindowPos(Handle, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW);
                    }

                    // Només activar les pantalles principals
                    EnableWindow((IntPtr)EW_GLOBAL._nHandleNet, true);
                    EnableWindow((IntPtr)EW_GLOBAL._nHandleVfp, true);
                    return;
                }

                // PE-79498. Fem una copia dels paràmetres que hi havia abans per curar-nos en salut
                Dictionary<string, object> loParTmp;
                loParTmp = NETVFP._Parametros;
                // FI PE-79498

                // Enviem el Handle de la finestra filla a Fox per a que es pugui bloquejar
                NETVFP._Parametros["responder"] = false;
                NETVFP._Parametros["opcion"] = "newhandle";
                NETVFP._Parametros["tipo"] = "valor";
                NETVFP._Parametros["valor"] = lnHandle;
                NETVFP._Parametros["paradi1"] = "";
                NETVFP._Parametros["paradi2"] = "";
                NETVFP._Parametros["paradi3"] = "";

                NETVFP._SendMessageToVfp();
                NETVFP._Parametros.Clear();

                NETVFP._Parametros = loParTmp; //  Restaurem els paràmetres que hi havia inicialment
            }
        }

        private void FormBase_KeyUp(object sender, KeyEventArgs e)
        {
            // PARTE 79873. Si estamos en edición de perfiles salimos
            if (EW_GLOBAL._EdicionPerfiles)
                return;

            // Analitzo la tecla pitjada
            string lcTecla = "";

            // Task 144651. Capturamos la tecla F1 para mostrar siempre la ayuda
            if (e.KeyCode == Keys.F1)
            {
                _MostrarAyudaPantalla();
            }

            // PE-87855. Capturamos las teclas de función
            if (e.KeyCode == Keys.F2 ||
                e.KeyCode == Keys.F3 ||
                e.KeyCode == Keys.F4 ||
                e.KeyCode == Keys.F5 ||
                e.KeyCode == Keys.F6 ||
                e.KeyCode == Keys.F7 ||
                e.KeyCode == Keys.F8 ||
                e.KeyCode == Keys.F9 ||
                e.KeyCode == Keys.Escape)
            {
                if (e.Shift)
                    lcTecla = "Shift_" + e.KeyCode.ToString();
                else if (e.Control)
                    lcTecla = "Control_" + e.KeyCode.ToString();
                else if (e.Alt)
                    lcTecla = "Alt_" + e.KeyCode.ToString();
                else
                    lcTecla = e.KeyCode.ToString();
            }
            else if (e.Control && !e.Alt)   // CCR-104926. Comprobar que no se hay pulsado AltGr
            {
                lcTecla = "Control_" + e.KeyCode.ToString();
            }

            if (!string.IsNullOrWhiteSpace(lcTecla))
            {
                // Miro si la tecla està al diccionari
                if (ldicBotons.ContainsKey(lcTecla))
                {
                    object loCtrl = ldicBotons[lcTecla];

                    //PE-83434 Teclas rapida a un control de tipus codi de barres
                    if (loCtrl is UserControls.ctBusCodBarras)
                    {
                        ((UserControls.ctBusCodBarras)loCtrl)._Focus();
                    }
                    //FPE-83434
                    else
                    {
                        ewbutton loewButton = (ewbutton)ldicBotons[lcTecla];
                        loewButton._ClickFrom = ewbutton.ClickFrom.TeclaFuncion;

                        //loewButton.Focus(); // PARTE 79873. Pasamos el foco

                        //if (loewButton.Focused) // PARTE 105207. Si el botón no tiene el foco no ejecutamos el click
                        loewButton.PerformClick();

                        loewButton._ClickFrom = ewbutton.ClickFrom.MouseClick;
                    }
                }
            }
        }

        public void Capturar_TeclesRapides(Control toCtrl, Boolean tlBuidar)
        {

            try
            {
                if (tlBuidar)
                {
                    ldicBotons.Clear();
                }

                foreach (Control loCtrl in toCtrl.Controls)
                {
                    if (loCtrl.Controls.Count > 0)
                    {
                        Capturar_TeclesRapides(loCtrl, false);
                    }
                    else
                    {
                        // Teclas rápidas
                        PropertyInfo propInfo = loCtrl.GetType().GetProperty("_TeclaRapida");
                        if (propInfo != null)
                        {
                            // Té tecla ràpida, l'afegim al diccionari
                            object loTecla = propInfo.GetValue(loCtrl, null);

                            if (loTecla != null)
                            {
                                string lcTecla = loTecla.ToString();
                                if (lcTecla != TeclasRapidas.ninguna.ToString())
                                {
                                    if (!ldicBotons.ContainsKey(loTecla.ToString()))
                                    {
                                        ldicBotons.Add(loTecla.ToString(), loCtrl);

                                        // PE-75821. Comprovar que s'hagi assignat l'objecte tooltip al formulari
                                        if (_ToolTip != null)
                                        {
                                            // Afegim al tooltip la tecla ràpida
                                            string lcToolTop = _ToolTip.GetToolTip(loCtrl);
                                            if (!string.IsNullOrWhiteSpace(lcToolTop))
                                            {
                                                string lcTeclaCtrl = " (" + lcTecla.Trim().Replace("Control_", "Ctrl+") + ")";
                                                // PE-77988. És possible que ja la tingui assignada
                                                if (lcToolTop.Substring(lcToolTop.Length - lcTeclaCtrl.Length) != lcTeclaCtrl)
                                                {
                                                    lcToolTop = lcToolTop + " (" + lcTecla.Trim().Replace("Control_", "Ctrl+") + ")";
                                                    _ToolTip.SetToolTip(loCtrl, lcToolTop);
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }

                        // PE-87855 Teclas de funcion
                        propInfo = loCtrl.GetType().GetProperty("_TeclaFuncion");
                        if (propInfo != null)
                        {
                            // Té tecla de funció, l'afegim al diccionari
                            object loTecla = propInfo.GetValue(loCtrl, null);

                            if (loTecla != null)
                            {
                                string lcTecla = loTecla.ToString();
                                if (lcTecla != TeclasFuncion.ninguna.ToString())
                                {
                                    if (!ldicBotons.ContainsKey(loTecla.ToString()))
                                    {
                                        ldicBotons.Add(loTecla.ToString(), loCtrl);

                                        // PE-75821. Comprovar que s'hagi assignat l'objecte tooltip al formulari
                                        if (_ToolTip != null)
                                        {
                                            // Afegim al tooltip la tecla ràpida
                                            string lcToolTop = _ToolTip.GetToolTip(loCtrl);
                                            if (!string.IsNullOrWhiteSpace(lcToolTop))
                                            {
                                                string lcTeclaCtrl = " (" + lcTecla.Trim() + ")";
                                                lcTeclaCtrl = lcTeclaCtrl.Replace("Control_", "Ctrl + ");
                                                lcTeclaCtrl = lcTeclaCtrl.Replace("Shift_", "Mayús. + ");
                                                lcTeclaCtrl = lcTeclaCtrl.Replace("Alt_", "Alt + ");

                                                // PE-77988. És possible que ja la tingui assignada
                                                if (lcToolTop.Length <= lcTeclaCtrl.Length || lcToolTop.Substring(lcToolTop.Length - lcTeclaCtrl.Length) != lcTeclaCtrl)
                                                {
                                                    lcToolTop = lcToolTop + lcTeclaCtrl;
                                                    _ToolTip.SetToolTip(loCtrl, lcToolTop);
                                                }
                                            }
                                        }
                                    }
                                }
                            }

                        }
                    }
                }
            }
            catch (Exception loEx)
            {
                DB.Registrar_Error(loEx);
                throw;
            }
        }


        public virtual bool _Controles_En_Formulario_De_Solo_Lectura()
        {
            return _ReadOnly;
        }

        public virtual void _CellContentClick(object sender, DataGridViewCellEventArgs e)
        {
            DataGridView loTemp = (DataGridView)sender;
            loTemp.CommitEdit(DataGridViewDataErrorContexts.Commit);
        }

        protected virtual void FormBase_Load(object sender, EventArgs e)
        {
            FUNCTIONS._GarbageCollect();

            // PE-81566,81700. Sino es ejecutable que no haga nada ya que peta el modo visual de Visual Studio y no permite diseñar los formularios
            if (EW_GLOBAL._EsEjecutable)
                Load_Privado();
            // FI PE-81566,81700

            if (!(this is frmGestionPerfil))
                _Addons_BindForms();

            // PE-100744. Añadir a la pila la referencia del formulario abierto
            EW_GLOBAL._OpenForms.Push(this);

        }

        protected String _cConfigUserOptionsPantalla = "";

        protected virtual String ConfigUserOptionsGetPantalla()
        {
            return String.IsNullOrEmpty(_cConfigUserOptionsPantalla) ? _Pantalla : _cConfigUserOptionsPantalla;
        }

        private void ConfigUserOptionsUpdatePredet()
        {
            if (_ConfigUserOptionsAllowed)
            {
                // Crear/Actualizar configuración predeterminada por defecto
                _oConfigUserFormPredet = new ConfigUserForm(Usuario._This._Codigo, ConfigUserOptionsGetPantalla(), ConfigUserForm.ConfigUserType.PredetValuesConfig.__GetDescription());

                if (!_ConfigUserOptionsEditing)
                {
                    // Crear diccionarios con controles configurables
                    ConfigUserOptionsGetDictionaries();

                    // Obtener valores configurados actualmente
                    Dictionary<string, ConfigUserOption> dicUserOptionsAct = _ConfigUserOptionsGetCurrent();

                    // Guardar configuración predeterminada
                    _oConfigUserFormPredet._Save(dicUserOptionsAct, true);
                }
            }
        }

        private void ConfigUserOptionsUpdateLastValues()
        {
            if (!_ConfigUserOptionsAllowed || _ConfigUserOptionsEditing)
                return;

            // Actualizar "Última configuración" 
            ConfigUserForm loLast = new ConfigUserForm(Usuario._This._Codigo, ConfigUserOptionsGetPantalla(), ConfigUserForm.ConfigUserType.LastValuesConfig.__GetDescription());

            // Obtener valores configurados actualmente
            Dictionary<string, ConfigUserOption> dicUserOptionsAct = _ConfigUserOptionsGetCurrent();

            // Guardar configuración 
            loLast._Save(dicUserOptionsAct, false, false);
            loLast = null;
        }

        protected virtual void ConfigUserOptionsLoad(string tcPantalla)
        {
            if (!_ConfigUserOptionsAllowed)
                return;

            _cConfigUserOptionsPantalla = tcPantalla;

            // Obtener controles actuales
            ConfigUserOptionsGetDictionaries();

            // Cargar negocio para las configuraciones
            _oConfigUserForm = new ConfigUserForm(Usuario._This._Codigo, tcPantalla);

            // Cargar configuraciones actuales
            _ConfigUserOptionsLoad(_oConfigUserForm._dicOpciones);
        }

        private void ConfigUserOptionsDisabled(List<string> listOptionsDisabled)
        {
            listConfigUserOptionsDisabled = new List<string>();

            // Añadir a la lista los controles desactivados para el formulario actual    
            if (listOptionsDisabled != null && listOptionsDisabled.Count > 0)
                listConfigUserOptionsDisabled = listConfigUserOptionsDisabled.Concat(listOptionsDisabled).ToList();

            // Añadir a la lista los controles desactivados para el formulario actual desde Addons
            List<string> listOptionsAddonsDisabled = AddonsController.Instance.Methods.ConfigUserOptionsDisabled(this);
            if (listOptionsAddonsDisabled != null && listOptionsAddonsDisabled.Count > 0)
                listConfigUserOptionsDisabled = listConfigUserOptionsDisabled.Concat(listOptionsAddonsDisabled).ToList();
        }

        private void ConfigUserOptionsGetDictionaries()
        {
            // Obtener lista de controles desactivados en la pantalla actual            
            ConfigUserOptionsDisabled(_ConfigUserOptionsDisabled());

            // Antes de empezar, guardamos en un diccionario todos los controles configurables del formulario actual. 
            // Para optimizar el recorrido por estos controles en las distintas operativas.
            dicAllConfigUserOptions = new Dictionary<string, IConfigUserOption>();
            dicNoConfigUserOptions = new Dictionary<string, Control>();
            ConfigUserOptionsGetAll(this);
        }

        public virtual List<string> _ConfigUserOptionsDisabled()
        {
            return null;
        }

        public virtual void _ConfigUserOptionsLoad(Dictionary<string, ConfigUserOption> dicUserOptions)
        {
            if (!this._ConfigUserOptionsAllowed)
                return;

            // Si no tenemos ninguna opción configurada, no hay que hacer nada más
            if (dicUserOptions == null)
                return;

            // Marcamos que estamos cargando configuraciones
            _ConfigUserOptionsLoading = true;

            Dictionary<string, ConfigUserOption> loDicConfigUserOptionPredet;

            loDicConfigUserOptionPredet = _oConfigUserFormPredet._dicOpciones;

            foreach (KeyValuePair<string, ConfigUserOption> loOption in dicUserOptions)
            {
                try
                {
                    IConfigUserOption loConfigControl;

                    if (dicAllConfigUserOptions.TryGetValue(loOption.Key, out loConfigControl))
                    {
                        ConfigUserOption loConfigUserOption;

                        loConfigUserOption = loOption.Value;

                        if (_ConfigUserForm._Tipo == ConfigUserForm.ConfigUserType.UserValuesConfig && loConfigControl._EsOpcionalConfigUser && !loConfigUserOption.UserOptionalValue)
                        {
                            loConfigUserOption = loDicConfigUserOptionPredet[loOption.Key];
                        }


                        loConfigControl._SetValueUserOption(loConfigUserOption.Value);
                        loConfigControl._UsuarioPermiteConfigUser = loConfigUserOption.UserOptionalValue;
                    }
                }
                catch (Exception loEx)
                {
                    DB.Registrar_Error(loEx);
                }
            }

            Dictionary<string, object> loDic = (from loOption in dicUserOptions.Values
                                                select loOption).ToDictionary(f => f.Key, f => f.Value);

            // Extensión Addons para la carga de configuraciones
            AddonsController.Instance.Methods.ConfigUserFormLoad(this, loDic);

            // Marcamos que hemos terminado la carga de configuraciones
            _ConfigUserOptionsLoading = false;
        }

        protected bool IsConfigUserOptionsLoadedValues()
        {
            return !_ConfigUserOptionsAllowed || (_ConfigUserOptionsAllowed && _ConfigUserForm is ConfigUserForm);
        }

        public virtual void _ConfigUserOptionsLoad(IConfigUserOption toConfigUserOption)
        {
            string lcName;

            lcName = ((Control)toConfigUserOption).Name;

            if (_ConfigUserForm._dicOpciones.ContainsKey(lcName))
            {
                ConfigUserOption loOption = _ConfigUserForm._dicOpciones[lcName];
                toConfigUserOption._SetValueUserOption(loOption.Value);
            }
        }

        protected void _ConfigUserOptionsReLoad(string tcPantalla)
        {
            ConfigUserOptionsLoad(tcPantalla);
        }

        public virtual void _ConfigUserOptionsSave(Dictionary<string, ConfigUserOption> dicUserOptions)
        {
            if (!this._ConfigUserOptionsAllowed)
                return;

            // Guardar configuraciones en BD
            _oConfigUserForm._Save(dicUserOptions);


            Dictionary<string, object> loDic = (from loOption in dicUserOptions.Values
                                                select loOption).ToDictionary(f => f.Key, f => f.Value);

            // Extensión Addons para guardar configuraciones
            AddonsController.Instance.Methods.ConfigUserFormSave(this, loDic);
        }

        public void _ConfigUserOptionsSaveCurrent()
        {
            if (this._ConfigUserOptionsAllowed) _ConfigUserOptionsSave(_ConfigUserOptionsGetCurrent());
        }

        public Dictionary<string, ConfigUserOption> _ConfigUserOptionsGetCurrent()
        {
            ConfigUserOption loConfigUserOption;
            Dictionary<string, ConfigUserOption> dicUserOptionsAct = new Dictionary<string, ConfigUserOption>();

            foreach (KeyValuePair<string, IConfigUserOption> loOption in dicAllConfigUserOptions)
            {
                IConfigUserOption loConfigUser = (IConfigUserOption)loOption.Value;
                loConfigUserOption = new ConfigUserOption(loOption.Key, loConfigUser._GetValueUserOption(), loConfigUser._UsuarioPermiteConfigUser);

                dicUserOptionsAct.Add(loOption.Key, loConfigUserOption);
            }

            return dicUserOptionsAct;
        }

        public virtual void _ConfigUserOptionsEdit(bool tlEditar)
        {
            if (!_ConfigUserOptionsAllowed)
                return;

            _ConfigUserOptionsEditing = tlEditar;

            foreach (IConfigUserOption loConfigControl in dicAllConfigUserOptions.Values)
            {
                if (loConfigControl._PermitirConfigUser)
                    loConfigControl._EditMode = tlEditar;

                // Los controles que no permiten configuración y tienen una descripción de error, también los ponemos en modo edición 
                // para mostrar sólo este mensaje en modo edición.
                if (!loConfigControl._PermitirConfigUser && !string.IsNullOrWhiteSpace(loConfigControl._DescripcionError))
                    loConfigControl._EditMode = tlEditar;
            }

            if (tlEditar) _SubcripcionEventosEdicionOpcionesUsuario();

        }

        private void _SubcripcionEventosEdicionOpcionesUsuario(bool tbSubscribirse = true)
        {
            if (_ConfigUserOptionsAllowed)
            {
                // Recorrido por los controles que no se configuran en la pantalla actual
                // De momento sólo tratamos ewbutton y ewTabPage de forma nativa para invalidar el click y acceso en modo edición.
                foreach (Control loControl in dicNoConfigUserOptions.Values)
                {
                    if (loControl is ewbutton)
                    {
                        ((ewbutton)loControl).OnClickInvalidate -= FormBase_OnClickInvalidate;
                        if (tbSubscribirse) ((ewbutton)loControl).OnClickInvalidate += FormBase_OnClickInvalidate;
                    }
                    else if (loControl is TabPage)
                    {
                        Control loTabControl = ((TabPage)loControl).Parent;
                        if (loTabControl is TabControl)
                        {
                            ((TabControl)loTabControl).Selecting -= FormBase_SelectingTabPage;
                            if (tbSubscribirse) ((TabControl)loTabControl).Selecting += FormBase_SelectingTabPage;
                        }
                    }
                    else if (loControl is ewcombobox)
                    {
                        ((ewcombobox)loControl).DropDown -= FormBase_DropDownComboBox;
                        if (tbSubscribirse) ((ewcombobox)loControl).DropDown += FormBase_DropDownComboBox;
                    }
                }

                List<IConfigUserOption> loList = (from loConfigUser in dicAllConfigUserOptions.Values
                                                  where loConfigUser._EsOpcionalConfigUser
                                                  select loConfigUser).ToList();

                foreach (IConfigUserOption loControl in loList)
                {
                    loControl.OnConfigUserValueChanged -= FormBase_OnConfigUserValueChanged;
                    if (tbSubscribirse) loControl.OnConfigUserValueChanged += FormBase_OnConfigUserValueChanged;
                }
            }
        }


        private void FormBase_OnConfigUserValueChanged(object sender, EventArgs e)
        {
            IConfigUserOption loConfig;

            if (sender is IConfigUserOption && !_ConfigUserOptionsLoading)
            {
                loConfig = (IConfigUserOption)sender;
                loConfig._UsuarioPermiteConfigUser = DialogResult.Yes == _MessageBox(loConfig._DescripcionOpcional, MessageBoxButtons.YesNo, MessageBoxIcon.Question, MessageBoxDefaultButton.Button2, DialogResult.No);

                _ConfigUserOptionsLoading = true;

                if (!loConfig._UsuarioPermiteConfigUser) _ConfigUserOptionsLoad(loConfig);

                _ConfigUserOptionsLoading = false;

            }
        }

        private void FormBase_DropDownComboBox(object sender, EventArgs e)
        {
            _MessageBox("Control no operativo en modo edición.", "Configuraciones de usuario", MessageBoxButtons.OK, MessageBoxIcon.Information, MessageBoxDefaultButton.Button1);
            ((ewcombobox)sender).DropDownHeight = 1;
            ((ewcombobox)sender).Enabled = false;
        }

        private void FormBase_SelectingTabPage(object sender, TabControlCancelEventArgs e)
        {
            if (listConfigUserOptionsDisabled.Contains(e.TabPage.Name))
            {
                _MessageBox("Página no operativa en modo edición.", "Configuraciones de usuario", MessageBoxButtons.OK, MessageBoxIcon.Information, MessageBoxDefaultButton.Button1);
                e.Cancel = true;
            }
        }

        private void FormBase_OnClickInvalidate(ewbutton toButton, ref bool tlCancel)
        {
            _MessageBox("Control no operativo en modo edición.", "Configuraciones de usuario", MessageBoxButtons.OK, MessageBoxIcon.Information, MessageBoxDefaultButton.Button1);
            tlCancel = true;
        }

        private void ConfigUserOptionsGetAll(Control toContainer)
        {
            string lcName = "";

            foreach (Control loControl in toContainer.Controls)
            {
                lcName = loControl.Name;

                // Añadimos los ewbuttons y los controles desactivados en esta pantalla en el diccionario de controles no configurables.
                if ((loControl is ewbutton || listConfigUserOptionsDisabled.Contains(lcName)) && !dicNoConfigUserOptions.ContainsKey(lcName))
                    dicNoConfigUserOptions.Add(lcName, loControl);

                // Si un control es configurable o está en la lista de controles desactivados, los posibles controles que tena dentro no hay que configurarlos                
                if (!(loControl is IConfigUserOption || listConfigUserOptionsDisabled.Contains(lcName)))
                    ConfigUserOptionsGetAll(loControl);

                // Añadir el resto de los controles configurables al diccionario
                if (loControl is IConfigUserOption && !dicAllConfigUserOptions.ContainsKey(lcName) && !listConfigUserOptionsDisabled.Contains(lcName))
                    dicAllConfigUserOptions.Add(lcName, (IConfigUserOption)loControl);
            }
        }

        // PE-103321
        public void _Addons_BindForms()
        {
            AddonsController.Instance.Methods.BindForm(this, Name, _AddonsExtVisualCreacionAplazada, false);
            // PE-96322. Recorrer los addons para enviarles una referencia del form
            //foreach (KeyValuePair<string, object> loModulo in AddonsController.Instance.AddonsManager.GetAddons())
            //{
            // Si no se ha especificado en el formulario (propiedad _AddonsExtVisualCreacionAplazada) que la extensión visual del Addon se cargue de forma aplazada 
            // (frmclientes p.e.) la cargo ahora mismo. 
            // 
            // Las extensiones visuales de addons con carga aplazada se cargaran desde el propio formulario cuando se llame a form._Addons_BindForms_CargaAplazada()
            // según lo prepare el programador y en el punto en que lo decida el programador.
            //
            // El comportamiento por defecto es que todos las extensiones visuales de addons, si no se especifica lo contrario en el formulario en 
            // la propiedad _AddonsExtVisualCreacionAplazada, se cargan en el arranque de la pantalla y ésto es lo que se hace aquí.
            //
            //    if (!_AddonsExtVisualCreacionAplazada.Contains(Convert.ToString(loModulo.Key)))
            //    {
            //        ((IModulo)loModulo.Value)._BindForm(Name, this);
            //    }
            //}
        }

        public void _Addons_BindForms_CargaAplazada()
        {
            //  Recorrer los addons.
            AddonsController.Instance.Methods.BindForm(this, Name, _AddonsExtVisualCreacionAplazada, true);
            //foreach (KeyValuePair<string, object> loModulo in AddonsController.Instance.AddonsManager.GetAddons())
            //{
            //    // Si es un addon cuya extensión visual para este formulario es de carga aplazada la cargo ahora en la llamada a este método que lo que hace es precisamente eso.
            //    // Las extension visual de addons que no son de carga aplazada ya se ejecutaron en la carga de la pantalla desde FormBase.
            //    if (_AddonsExtVisualCreacionAplazada.Contains(Convert.ToString(loModulo.Key)))
            //    {
            //        ((IModulo)loModulo.Value)._BindForm(Name, this);
            //    }
            //}
        }

        public void _AddBindFormClass(IDisposable toClass)
        {
            if (!_dictBindForm.ContainsValue(toClass))
            {
                try
                {
                    _dictBindForm.Add(System.Guid.NewGuid().ToString(), toClass); // De momento no es necesario añadir el nombre de la clase. Podemos tener instancias con el mismo nombre...
                }
                catch (Exception)
                {
                }
            }
        }

        private void Load_Privado()
        {
            // PE- Volver a capturar las teclas aquí para los formularios que no son frmGestionPerfil            
            Capturar_TeclesRapides(this, true);
        }

        private void Constructor_Privado()
        {
            if (!EW_GLOBAL._EsEjecutable)
                return;

            try
            {
                // PE-74827
                // Comprobamos el tipo de acceso que tiene el usuario activo en esta pantalla (0 restringido, 1 solo lectura, 2 total, 3 Baja suscripción)            
                //sage.ew.usuario.Usuario loUsuario = new sage.ew.usuario.Usuario();
                if (!string.IsNullOrEmpty(_Pantalla))
                {
                    // PARTE 88665. Asignamos el acceso a la propiedad del formulario, para poder utilizarla posteriormente si nos interesa
                    determinarNivelAccesoDelUsuario();  // PE-92757. Usamos Usuario estático

                    if (tengoElAccesoDenegadoParaEstaPantalla())
                    {
                        // FPARTE 88665

                        // PE-80758. Mostrem missatge i sortim                        
                        string lcDescripcio = Usuario._This._Descripcion_Pantalla(_Pantalla);  // PE-79824 // PE-92757

                        //PE-97302
                        if (!_lMensajeAccesoMostrado)
                        {
                            string lcMessage = string.Format("El usuario {0}  no tiene acceso a {1}. Consulte con su supervisor.", Usuario._This._Nombre, lcDescripcio);
                            FUNCTIONS._MessageBox(lcMessage, MessageBoxButtons.OK, MessageBoxIcon.Stop, MessageBoxDefaultButton.Button1, DialogResult.OK);
                            _lMensajeAccesoMostrado = true;
                        }

                        //PE-97667 Descomentamos el codigo de Santi, ya que si cerrarmos el formulario en plena ejecución se pueden producen errores
                        Load += (s, e) => Close();
                        //this.Close();

                        AccesoListasPrevias = false;

                        return;
                    }

                    // PE-80965. Solo si es solo lectura, ponemos el texto y bloqueamos
                    if (!_cSufijo.Contains("(Sólo lectura)") && tengoElAccesoDeSoloLecturaParaEstaPantalla())
                    {
                        // Bloqueamos la pantalla
                        _cSufijo += " (Sólo lectura)";
                        Revisar_Titulo_Formulario();
                        _ReadOnly = true;
                    }

                    // PE-87103. Si tiene acceso BajaSuscripción, modificar caption y bloquear como si fuera de sólo lectura
                    if (!_cSufijo.Contains("(Baja suscripción)") && tengoElAccesoEnBajaSuscripcionParaEstaPantalla())
                    {
                        _cSufijo += " (Baja suscripción)";
                        Revisar_Titulo_Formulario();
                        _ReadOnly = true;
                    }
                    // FI PE-87103

                    AccesoListasPrevias = true;
                }
                else
                {
                    //Miro si debe gestionar los permisos (se hace por la propiedad pública para que tenga en cuenta las sobreescrituras de las clases deribadas
                    //durante la evalución de la base
                    if (!_Gestionar_permisos) _ReadOnly = false;
                    else
                    {
                        // Mirar si hay formulario padre y obtener de ahí el estado de sólo lectura (PE-79824)
                        FormBase loFrm = (FormBase)FindForm();

                        if (loFrm != null)
                            _ReadOnly = loFrm._ReadOnly;
                        else
                            _ReadOnly = false;
                    }
                }
            }
            catch (Exception loEx)
            {
                db.DB.Registrar_Error(loEx);
                throw;
            }

        }

        private bool tengoElAccesoEnBajaSuscripcionParaEstaPantalla()
        {
            return _NivelAcceso == _TiposAccesosPantalla.BajaSuscripcion;
        }

        private bool tengoElAccesoDeSoloLecturaParaEstaPantalla()
        {
            return _NivelAcceso == _TiposAccesosPantalla.SoloLectura;
        }

        private bool tengoElAccesoDenegadoParaEstaPantalla()
        {
            return _NivelAcceso == _TiposAccesosPantalla.Denegado;
        }

        private void determinarNivelAccesoDelUsuario()
        {
            if (!DesignMode)
                _NivelAcceso = Usuario._This._Acceso(this._Pantalla.Trim().ToUpper());
            else
                _NivelAcceso = _TiposAccesosPantalla.Completo;
        }

        private Color Name_To_Color(string tcNomColor)
        {
            Color loColor;

            // Primer mirem si és un SystemColor
            if (tcNomColor.Substring(0, 1) == "#")
                loColor = ColorTranslator.FromHtml(tcNomColor);
            else
                loColor = Color.FromName(tcNomColor);

            return loColor;
        }


        public void _ShowMessageBoxAutomatic(PanelAvisoRespAuto.TipoAviso toTipoAviso, string tcTitulo, string tcPregunta, string tcRespuesta,
                                             string tcId, int tnSegundos=15, int tnAnchoMaxCampoPregunta = 600)
        {
            try
            {
                Form loForm = this.FindForm();
                
                if (loForm != null)
                {
                    PanelAvisoRespAuto loMensajePopUp;

                    // Detectar si tenemos el usercontrol de mensaje respuesta automática ya en pantalla pero oculto.
                    //
                    Control loControlMensajePopUp = loForm.__FindControlRecursive("oMensajePopUpAvisoRespAuto");
                    if (loControlMensajePopUp == null)
                    {
                        loMensajePopUp = new PanelAvisoRespAuto(toTipoAviso, tcTitulo, tcPregunta, tcRespuesta, tcId, tnSegundos, tnAnchoMaxCampoPregunta);
                        loMensajePopUp.Name = "oMensajePopUpAvisoRespAuto";
                        loForm.Controls.Add(loMensajePopUp);
                    }
                    else
                    {
                        loMensajePopUp = (PanelAvisoRespAuto)loControlMensajePopUp;
                        loMensajePopUp._TipoAviso = toTipoAviso;
                        loMensajePopUp._TextoTitulo = tcTitulo;
                        loMensajePopUp._TextoPregunta = tcPregunta;
                        loMensajePopUp._TextoRespuesta = tcRespuesta;
                        loMensajePopUp._IdPregunta = tcId;
                        loMensajePopUp._Segundos = tnSegundos;
                        loMensajePopUp._AnchoMaxPregunta = tnAnchoMaxCampoPregunta;

                    }
                    // El mensaje popup se muestra ajustado al borde derecho del formulario, a 10 pixels aproximadamente del .Top del
                    // mismo.
                    //
                    loMensajePopUp.Location = new Point(this.Width - loMensajePopUp.Width - 25, 10);
                    loMensajePopUp.Visible = true;
                    loMensajePopUp.BringToFront();
                }
            }
            catch (Exception e)
            {
                DB.Registrar_Error(e);
            }

            return;
        }

        public DialogResult _MessageBox(String tcMensaje, MessageBoxButtons toBotones, MessageBoxIcon toIcono,
                                        MessageBoxDefaultButton toBotonDefecto, DialogResult toResultadoDefecte)
        {
            DialogResult toResultado;
            MessageBoxAutomatico pantalla = new MessageBoxAutomatico();


            toResultado = _MessageBox(tcMensaje, toBotones, toIcono, toBotonDefecto, toResultadoDefecte, pantalla);


            return toResultado;
        }

        public DialogResult _MessageBox(String tcMensaje, MessageBoxButtons toBotones, MessageBoxIcon toIcono,
                                        MessageBoxDefaultButton toBotonDefecto, DialogResult toResultadoDefecte, MessageBoxAutomatico toPantalla)
        {
            DialogResult toResultado;

            if (Application.OpenForms.Count > 0 || Debugger.IsAttached)
            {
                //PE-88559
                string lcTitulo = "";
                if (!Text.__IsNumeric()) lcTitulo = Text;

                // PE-87573. Cridem a la següent sobrecàrrega
                toResultado = _MessageBox(tcMensaje, lcTitulo, toBotones, toIcono, toBotonDefecto, toPantalla);
            }
            else
            {
                Exception ex = new Exception("Se ha lanzado este mensaje visual: '" + tcMensaje + "'");
                throw ex;
            }

            return toResultado;
        }

        public DialogResult _MessageBox(String tcMensaje, MessageBoxButtons toBotones, MessageBoxIcon toIcono,
                                        MessageBoxDefaultButton toBotonDefecto, DialogResult toResultadoDefecte,
                                        Link toLink)
        {
            DialogResult toResultado;
            MessageBoxAutomatico pantalla = new MessageBoxAutomatico();

            toResultado = _MessageBox(tcMensaje, toBotones, toIcono, toBotonDefecto, toResultadoDefecte, toLink, pantalla);

            return toResultado;
        }

        public DialogResult _MessageBox(String tcMensaje, MessageBoxButtons toBotones, MessageBoxIcon toIcono,
                                        MessageBoxDefaultButton toBotonDefecto, DialogResult toResultadoDefecte,
                                        Link toLink, MessageBoxAutomatico toPantalla)
        {
            DialogResult toResultado;

            if (Application.OpenForms.Count > 0 || Debugger.IsAttached)
            {
                //PE-88559
                string lcTitulo = "";
                if (!Text.__IsNumeric()) lcTitulo = Text;

                // PE-87573. Cridem a la següent sobrecàrrega
                toResultado = _MessageBox(tcMensaje, lcTitulo, toBotones, toIcono, toBotonDefecto, toLink, toPantalla);
            }
            else
            {
                Exception ex = new Exception("Se ha lanzado este mensaje visual: '" + tcMensaje + "'");
                throw ex;
            }

            return toResultado;
        }

        public DialogResult _MessageBox(String tcMensaje, MessageBoxButtons toBotones, MessageBoxIcon toIcono,
                                        MessageBoxDefaultButton toBotonDefecto, DialogResult toResultadoDefecte,
                                        Dictionary<eBotonesMessagebox, string> tdicLiteralesBoton)
        {
            DialogResult toResultado;
            MessageBoxAutomatico pantalla = new MessageBoxAutomatico();

            toResultado = _MessageBox(tcMensaje, toBotones, toIcono, toBotonDefecto, toResultadoDefecte, tdicLiteralesBoton, pantalla);

            return toResultado;
        }

        public DialogResult _MessageBox(String tcMensaje, MessageBoxButtons toBotones, MessageBoxIcon toIcono,
                                        MessageBoxDefaultButton toBotonDefecto, DialogResult toResultadoDefecte,
                                        Dictionary<eBotonesMessagebox, string> tdicLiteralesBoton, MessageBoxAutomatico toPantalla)
        {
            DialogResult toResultado;

            if (Application.OpenForms.Count > 0 || Debugger.IsAttached)
            {
                //PE-88559
                string lcTitulo = "";
                if (!this.Text.__IsNumeric()) lcTitulo = this.Text;

                // PE-87573. Cridem a la següent sobrecàrrega
                toResultado = _MessageBox(tcMensaje, lcTitulo, toBotones, toIcono, toBotonDefecto, tdicLiteralesBoton, toPantalla);
            }
            else
            {
                Exception ex = new Exception("Se ha lanzado este mensaje visual: " + tcMensaje);
                throw ex;
            }

            return toResultado;
        }

        public DialogResult _MessageBox(String tcMensaje, MessageBoxButtons toBotones, MessageBoxIcon toIcono,
                                        MessageBoxDefaultButton toBotonDefecto, DialogResult toResultadoDefecte,
                                        Dictionary<eBotonesMessagebox, string> tdicLiteralesBoton,
                                        Dictionary<eBotonesMessagebox, Image> tdicImagenesBoton)
        {
            DialogResult toResultado;
            MessageBoxAutomatico pantalla = new MessageBoxAutomatico();

            toResultado = _MessageBox(tcMensaje, toBotones, toIcono, toBotonDefecto, toResultadoDefecte, tdicLiteralesBoton, tdicImagenesBoton, pantalla);

            return toResultado;
        }

        public DialogResult _MessageBox(String tcMensaje, MessageBoxButtons toBotones, MessageBoxIcon toIcono,
                                        MessageBoxDefaultButton toBotonDefecto, DialogResult toResultadoDefecte,
                                        Dictionary<eBotonesMessagebox, string> tdicLiteralesBoton,
                                        Dictionary<eBotonesMessagebox, Image> tdicImagenesBoton, MessageBoxAutomatico toPantalla)
        {
            DialogResult toResultado;

            if (Application.OpenForms.Count > 0 || Debugger.IsAttached)
            {
                string lcTitulo = "";
                if (!Text.__IsNumeric()) lcTitulo = Text;

                toResultado = _MessageBox(tcMensaje, lcTitulo, toBotones, toIcono, toBotonDefecto, tdicLiteralesBoton, tdicImagenesBoton, toPantalla);
            }
            else
            {
                Exception ex = new Exception("Se ha lanzado este mensaje visual: " + tcMensaje);
                throw ex;
            }

            return toResultado;
        }

        public DialogResult _MessageBox(string text, string caption, MessageBoxButtons buttons, MessageBoxIcon icon,
                                        MessageBoxDefaultButton defaultButton)
        {
            // Evento before
            MessageBoxParam loParam = new MessageBoxParam(text, caption, buttons, icon, defaultButton, new DialogResult());
            MessageBoxAutomatico pantalla = new MessageBoxAutomatico();

            loParam._DialogResult = _MessageBox(text, caption, buttons, icon, defaultButton, pantalla);

            return loParam._DialogResult;
        }

        public DialogResult _MessageBox(string text, string caption, MessageBoxButtons buttons, MessageBoxIcon icon,
                                        MessageBoxDefaultButton defaultButton, MessageBoxAutomatico toPantalla)
        {
            // Evento before
            MessageBoxParam loParam = new MessageBoxParam(text, caption, buttons, icon, defaultButton, new DialogResult());

            if (Application.OpenForms.Count > 0 || Debugger.IsAttached)
            {
                onMessageBoxBefore?.Invoke(ref loParam);

                // Si hay algún mensaje durante la carga de opciones de configuración, lo evitamos
                if (_ConfigUserOptionsLoading)
                    return loParam._DialogResultDefecto;

                // Si aún no hemos realizado el login de usuario, para evitar problemas de mensajes en blanco con windows 10,... utilizamos el messagebox nativo.
                if (!EW_GLOBAL._lLoginFinalizado)
                {
                    loParam._DialogResult = MessageBox.Show(loParam._Mensaje, loParam._Caption, loParam._Botones, loParam._Icono, loParam._BotonDefecto);
                    return loParam._DialogResult;
                }

                // Evento invalidate
                onMessageBoxInvalidate?.Invoke(ref loParam);
                if (loParam._Cancel)
                    return loParam._DialogResultDefecto;

                DialogResult dialogResult = new DialogResult();
                if (_RespuestaEncontrada(toPantalla, ref dialogResult))
                {
                    loParam._DialogResult = dialogResult;
                }
                else
                {
                    //PE-90150 : Todos los message box deben pasar por MessageBoxTactil
                    using (MessageBoxTactil frmMessage = new MessageBoxTactil())
                    {
                        // Bug 213372 Si la pantalla que lanza el mensaje no debe sacar mensajes automaticos ponemos a null el parametro _toPantalla para que no salga el check de guardar
                        MessageBoxAutomatico _toPantalla = !this._MessageBoxAutomatic ? null : toPantalla;

                        loParam._DialogResult = frmMessage.Show(loParam._Mensaje, _toPantalla, loParam._Caption, loParam._Botones, loParam._Icono, loParam._BotonDefecto);

                        if (frmMessage._EwchkGuardar_Checked)
                        {
                           _GuardarRespuesta(toPantalla, frmMessage._DiccionarioBotonesRespuestas, loParam._Mensaje, loParam._DialogResult.ToString());
                        }
                    }
                }

                // Evento after    
                onMessageBoxAfter?.Invoke(ref loParam);
            }
            else
            {
                Exception ex = new Exception("Se ha lanzado este mensaje visual: " + text);
                throw ex;
            }

            return loParam._DialogResult;
        }

        public DialogResult _MessageBox(string text, string caption, MessageBoxButtons buttons, MessageBoxIcon icon,
                                        MessageBoxDefaultButton defaultButton, Link toLink)
        {
            MessageBoxParam loParam = new MessageBoxParam(text, caption, buttons, icon, defaultButton, new DialogResult(), toLink);
            MessageBoxAutomatico pantalla = new MessageBoxAutomatico();

            loParam._DialogResult = _MessageBox(text, caption, buttons, icon, defaultButton, toLink, pantalla);

            return loParam._DialogResult;
        }

        public DialogResult _MessageBox(string text, string caption, MessageBoxButtons buttons, MessageBoxIcon icon,
                                        MessageBoxDefaultButton defaultButton, Link toLink, MessageBoxAutomatico toPantalla)
        {
            // Evento before
            MessageBoxParam loParam = new MessageBoxParam(text, caption, buttons, icon, defaultButton, new DialogResult(), toLink);

            if (Application.OpenForms.Count > 0 || Debugger.IsAttached)
            {
                onMessageBoxBefore?.Invoke(ref loParam);

                // Si hay algún mensaje durante la carga de opciones de configuración, lo evitamos
                if (_ConfigUserOptionsLoading)
                    return loParam._DialogResultDefecto;

                // Si aún no hemos realizado el login de usuario, para evitar problemas de mensajes en blanco con windows 10,... utilizamos el messagebox nativo.
                if (!EW_GLOBAL._lLoginFinalizado)
                {
                    loParam._DialogResult = MessageBox.Show(loParam._Mensaje, loParam._Caption, loParam._Botones, loParam._Icono, loParam._BotonDefecto);
                    return loParam._DialogResult;
                }

                // Evento invalidate
                onMessageBoxInvalidate?.Invoke(ref loParam);
                if (loParam._Cancel)
                    return loParam._DialogResultDefecto;

                DialogResult dialogResult = new DialogResult();
                if (_RespuestaEncontrada(toPantalla, ref dialogResult))
                {
                    loParam._DialogResult = dialogResult;
                }
                else
                {
                    //PE-90150 : Todos los message box deben pasar por MessageBoxTactil
                    using (MessageBoxTactil frmMessage = new MessageBoxTactil())
                    {
                        // Bug 213372 Si la pantalla que lanza el mensaje no debe sacar mensajes automaticos ponemos a null el parametro _toPantalla para que no salga el check de guardar
                        MessageBoxAutomatico _toPantalla = !this._MessageBoxAutomatic ? null : toPantalla;

                        loParam._DialogResult = frmMessage.Show(loParam._Mensaje, _toPantalla, loParam._Link, loParam._Caption, loParam._Botones, loParam._Icono, loParam._BotonDefecto);
                        if (frmMessage._EwchkGuardar_Checked)
                        {
                            _GuardarRespuesta(toPantalla, frmMessage._DiccionarioBotonesRespuestas, loParam._Mensaje, loParam._DialogResult.ToString());
                        }
                    }
                }

                // Evento after    
                onMessageBoxAfter?.Invoke(ref loParam);
            }
            else
            {
                Exception ex = new Exception("Se ha lanzado este mensaje visual: " + text);
                throw ex;
            }

            return loParam._DialogResult;
        }

        public DialogResult _MessageBox(string text, string caption, MessageBoxButtons buttons, MessageBoxIcon icon,
                                        MessageBoxDefaultButton defaultButton,
                                        Dictionary<eBotonesMessagebox, string> tdicLiteralesBoton)
        {
            // Evento before
            MessageBoxParam loParam = new MessageBoxParam(text, caption, buttons, icon, defaultButton, new DialogResult(), tdicLiteralesBoton);
            MessageBoxAutomatico pantalla = new MessageBoxAutomatico();

            loParam._DialogResult = _MessageBox(text, caption, buttons, icon, defaultButton, tdicLiteralesBoton, pantalla);

            return loParam._DialogResult;
        }

        public DialogResult _MessageBox(string text, string caption, MessageBoxButtons buttons, MessageBoxIcon icon,
                                        MessageBoxDefaultButton defaultButton,
                                        Dictionary<eBotonesMessagebox, string> tdicLiteralesBoton, MessageBoxAutomatico toPantalla)
        {
            // Evento before
            MessageBoxParam loParam = new MessageBoxParam(text, caption, buttons, icon, defaultButton, new DialogResult(), tdicLiteralesBoton);

            if (Application.OpenForms.Count > 0 || Debugger.IsAttached)
            {
                onMessageBoxBefore?.Invoke(ref loParam);

                // Si hay algún mensaje durante la carga de opciones de configuración, lo evitamos
                if (_ConfigUserOptionsLoading)
                    return loParam._DialogResultDefecto;

                // Si aún no hemos realizado el login de usuario, para evitar problemas de mensajes en blanco con windows 10,... utilizamos el messagebox nativo.
                if (!EW_GLOBAL._lLoginFinalizado)
                {
                    loParam._DialogResult = MessageBox.Show(loParam._Mensaje, loParam._Caption, loParam._Botones, loParam._Icono, loParam._BotonDefecto);
                    return loParam._DialogResult;
                }

                // Evento invalidate
                onMessageBoxInvalidate?.Invoke(ref loParam);
                if (loParam._Cancel)
                    return loParam._DialogResultDefecto;

                DialogResult dialogResult = new DialogResult();
                if (_RespuestaEncontrada(toPantalla, ref dialogResult))
                {
                    loParam._DialogResult = dialogResult;
                }
                else
                {
                    //PE-90150 : Todos los message box deben pasar por MessageBoxTactil
                    using (MessageBoxTactil frmMessage = new MessageBoxTactil())
                    {
                        frmMessage._DiccionarioLiteralesBotones = loParam._DicLiteralesBotones;

                        // Bug 213372 Si la pantalla que lanza el mensaje no debe sacar mensajes automaticos ponemos a null el parametro _toPantalla para que no salga el check de guardar
                        MessageBoxAutomatico _toPantalla = !this._MessageBoxAutomatic ? null : toPantalla;

                        loParam._DialogResult = frmMessage.Show(loParam._Mensaje, _toPantalla, loParam._Caption, loParam._Botones, loParam._Icono, loParam._BotonDefecto);

                        if (frmMessage._EwchkGuardar_Checked)
                        {
                            _GuardarRespuesta(toPantalla, frmMessage._DiccionarioBotonesRespuestas, loParam._Mensaje, loParam._DialogResult.ToString());
                        }
                    }
                }

                // Evento after    
                onMessageBoxAfter?.Invoke(ref loParam);
            }
            else
            {
                Exception ex = new Exception("Se ha lanzado este mensaje visual: " + text);
                throw ex;
            }

            return loParam._DialogResult;
        }

        public DialogResult _MessageBox(string text, string caption, MessageBoxButtons buttons, MessageBoxIcon icon,
                                        MessageBoxDefaultButton defaultButton,
                                        Dictionary<eBotonesMessagebox, string> tdicLiteralesBoton,
                                        Link toLink)
        {
            // Evento before
            MessageBoxParam loParam = new MessageBoxParam(text, caption, buttons, icon, defaultButton, new DialogResult(), tdicLiteralesBoton, toLink);
            MessageBoxAutomatico pantalla = new MessageBoxAutomatico();

            loParam._DialogResult = _MessageBox(text, caption, buttons, icon, defaultButton, tdicLiteralesBoton, toLink, pantalla);

            return loParam._DialogResult;
        }

        public DialogResult _MessageBox(string text, string caption, MessageBoxButtons buttons, MessageBoxIcon icon,
                                        MessageBoxDefaultButton defaultButton,
                                        Dictionary<eBotonesMessagebox, string> tdicLiteralesBoton,
                                        Link toLink, MessageBoxAutomatico toPantalla)
        {
            // Evento before
            MessageBoxParam loParam = new MessageBoxParam(text, caption, buttons, icon, defaultButton, new DialogResult(), tdicLiteralesBoton, toLink);

            if (Application.OpenForms.Count > 0 || Debugger.IsAttached)
            {
                onMessageBoxBefore?.Invoke(ref loParam);

                // Si hay algún mensaje durante la carga de opciones de configuración, lo evitamos
                if (_ConfigUserOptionsLoading)
                    return loParam._DialogResultDefecto;

                // Si aún no hemos realizado el login de usuario, para evitar problemas de mensajes en blanco con windows 10,... utilizamos el messagebox nativo.
                if (!EW_GLOBAL._lLoginFinalizado)
                {
                    loParam._DialogResult = MessageBox.Show(loParam._Mensaje, loParam._Caption, loParam._Botones, loParam._Icono, loParam._BotonDefecto);
                    return loParam._DialogResult;
                }

                // Evento invalidate
                onMessageBoxInvalidate?.Invoke(ref loParam);
                if (loParam._Cancel)
                    return loParam._DialogResultDefecto;

                DialogResult dialogResult = new DialogResult();
                if (_RespuestaEncontrada(toPantalla, ref dialogResult))
                {
                    loParam._DialogResult = dialogResult;
                }
                else
                {
                    //PE-90150 : Todos los message box deben pasar por MessageBoxTactil
                    using (MessageBoxTactil frmMessage = new MessageBoxTactil())
                    {
                        frmMessage._DiccionarioLiteralesBotones = loParam._DicLiteralesBotones;

                        // Bug 213372 Si la pantalla que lanza el mensaje no debe sacar mensajes automaticos ponemos a null el parametro _toPantalla para que no salga el check de guardar
                        MessageBoxAutomatico _toPantalla = !this._MessageBoxAutomatic ? null : toPantalla;

                        loParam._DialogResult = frmMessage.Show(loParam._Mensaje, _toPantalla, loParam._Link, loParam._Caption, loParam._Botones, loParam._Icono, loParam._BotonDefecto);

                        if (frmMessage._EwchkGuardar_Checked)
                        {
                            _GuardarRespuesta(toPantalla, frmMessage._DiccionarioBotonesRespuestas, loParam._Mensaje, loParam._DialogResult.ToString());
                        }
                    }
                }

                // Evento after    
                onMessageBoxAfter?.Invoke(ref loParam);
            }
            else
            {
                Exception ex = new Exception("Se ha lanzado este mensaje visual: " + text);
                throw ex;
            }

            return loParam._DialogResult;
        }

        public DialogResult _MessageBox(string text, string caption, MessageBoxButtons buttons, MessageBoxIcon icon,
                                        MessageBoxDefaultButton defaultButton,
                                        Dictionary<eBotonesMessagebox, string> tdicLiteralesBoton,
                                        Dictionary<eBotonesMessagebox, Image> tdicImagenesBoton)
        {
            // Evento before
            MessageBoxParam loParam = new MessageBoxParam(text, caption, buttons, icon, defaultButton, new DialogResult(), tdicLiteralesBoton, tdicImagenesBoton);
            MessageBoxAutomatico pantalla = new MessageBoxAutomatico();

            loParam._DialogResult = _MessageBox(text, caption, buttons, icon, defaultButton, tdicLiteralesBoton, tdicImagenesBoton, pantalla);

            return loParam._DialogResult;
        }

        public DialogResult _MessageBox(string text, string caption, MessageBoxButtons buttons, MessageBoxIcon icon,
                                        MessageBoxDefaultButton defaultButton,
                                        Dictionary<eBotonesMessagebox, string> tdicLiteralesBoton,
                                        Dictionary<eBotonesMessagebox, Image> tdicImagenesBoton, MessageBoxAutomatico toPantalla)
        {
            // Evento before
            MessageBoxParam loParam = new MessageBoxParam(text, caption, buttons, icon, defaultButton, new DialogResult(), tdicLiteralesBoton, tdicImagenesBoton);

            if (Application.OpenForms.Count > 0 || Debugger.IsAttached)
            {
                onMessageBoxBefore?.Invoke(ref loParam);

                // Si hay algún mensaje durante la carga de opciones de configuración, lo evitamos
                if (_ConfigUserOptionsLoading)
                    return loParam._DialogResultDefecto;


                // Si aún no hemos realizado el login de usuario, para evitar problemas de mensajes en blanco con windows 10,... utilizamos el messagebox nativo.
                if (!EW_GLOBAL._lLoginFinalizado)
                {
                    loParam._DialogResult = MessageBox.Show(loParam._Mensaje, loParam._Caption, loParam._Botones, loParam._Icono, loParam._BotonDefecto);
                    return loParam._DialogResult;
                }

                // Evento invalidate
                onMessageBoxInvalidate?.Invoke(ref loParam);
                if (loParam._Cancel)
                    return loParam._DialogResultDefecto;

                DialogResult dialogResult = new DialogResult();
                if (_RespuestaEncontrada(toPantalla, ref dialogResult))
                {
                    loParam._DialogResult = dialogResult;
                }
                else
                {
                    //PE-90150 : Todos los message box deben pasar por MessageBoxTactil
                    using (MessageBoxTactil frmMessage = new MessageBoxTactil())
                    {
                        frmMessage._DiccionarioLiteralesBotones = loParam._DicLiteralesBotones;
                        frmMessage._DiccionarioImagenesBotones = loParam._DicImagenesBotones;

                        // Bug 213372 Si la pantalla que lanza el mensaje no debe sacar mensajes automaticos ponemos a null el parametro _toPantalla para que no salga el check de guardar
                        MessageBoxAutomatico _toPantalla = !this._MessageBoxAutomatic ? null : toPantalla;

                        loParam._DialogResult = frmMessage.Show(loParam._Mensaje, _toPantalla, loParam._Caption, loParam._Botones, loParam._Icono, loParam._BotonDefecto);

                        if (frmMessage._EwchkGuardar_Checked)
                        {
                            _GuardarRespuesta(toPantalla, frmMessage._DiccionarioBotonesRespuestas, loParam._Mensaje, loParam._DialogResult.ToString());
                        }
                    }
                }

                // Evento after    
                onMessageBoxAfter?.Invoke(ref loParam);
            }
            else
            {
                Exception ex = new Exception("Se ha lanzado este mensaje visual: " + text);
                throw ex;
            }

            return loParam._DialogResult;
        }

        public DialogResult _MessageBox(string text, string caption, MessageBoxButtons buttons, MessageBoxIcon icon,
                                        MessageBoxDefaultButton defaultButton,
                                        Dictionary<MessageBoxButtons, List<string>> tdicTextoBotones)
        {
            // Evento before
            MessageBoxParam loParam = new MessageBoxParam(text, caption, buttons, icon, defaultButton, new DialogResult(), tdicTextoBotones);
            MessageBoxAutomatico pantalla = new MessageBoxAutomatico();

            loParam._DialogResult = _MessageBox(text, caption, buttons, icon, defaultButton, tdicTextoBotones, pantalla);
            return loParam._DialogResult;
        }

        public DialogResult _MessageBox(string text, string caption, MessageBoxButtons buttons, MessageBoxIcon icon,
                                        MessageBoxDefaultButton defaultButton,
                                        Dictionary<MessageBoxButtons, List<string>> tdicTextoBotones, MessageBoxAutomatico toPantalla)
        {

            // Evento before
            MessageBoxParam loParam = new MessageBoxParam(text, caption, buttons, icon, defaultButton, new DialogResult(), tdicTextoBotones);

            if (Application.OpenForms.Count > 0 || Debugger.IsAttached)
            {
                onMessageBoxBefore?.Invoke(ref loParam);

                // Si hay algún mensaje durante la carga de opciones de configuración, lo evitamos
                if (_ConfigUserOptionsLoading)
                    return loParam._DialogResultDefecto;

                // Si aún no hemos realizado el login de usuario, para evitar problemas de mensajes en blanco con windows 10,... utilizamos el messagebox nativo.
                if (!EW_GLOBAL._lLoginFinalizado)
                {
                    loParam._DialogResult = MessageBox.Show(loParam._Mensaje, loParam._Caption, loParam._Botones, loParam._Icono, loParam._BotonDefecto);
                    return loParam._DialogResult;
                }

                // Evento invalidate
                onMessageBoxInvalidate?.Invoke(ref loParam);
                if (loParam._Cancel)
                    return loParam._DialogResultDefecto;

                DialogResult dialogResult = new DialogResult();
                if (_RespuestaEncontrada(toPantalla, ref dialogResult))
                {
                    loParam._DialogResult = dialogResult;
                }
                else
                {
                    //PE-90150 : Todos los message box deben pasar por MessageBoxTactil
                    using (MessageBoxTactil frmMessage = new MessageBoxTactil())
                    {
                        // Bug 213372 Si la pantalla que lanza el mensaje no debe sacar mensajes automaticos ponemos a null el parametro _toPantalla para que no salga el check de guardar
                        MessageBoxAutomatico _toPantalla = !this._MessageBoxAutomatic ? null : toPantalla;

                        loParam._DialogResult = frmMessage.Show(loParam._Mensaje, _toPantalla, loParam._Caption, loParam._Botones, loParam._Icono, loParam._BotonDefecto);

                        if (frmMessage._EwchkGuardar_Checked)
                        {
                            _GuardarRespuesta(toPantalla, frmMessage._DiccionarioBotonesRespuestas, loParam._Mensaje, loParam._DialogResult.ToString());
                        }
                    }
                }

                // Evento after    
                onMessageBoxAfter?.Invoke(ref loParam);
            }
            else
            {
                Exception ex = new Exception("Se ha lanzado este mensaje visual :" + text);
                loParam._DialogResult = DialogResult.OK;
            }

            return loParam._DialogResult;
        }

        private void _GuardarRespuesta(MessageBoxAutomatico toPantalla, Dictionary<string, string> toDiccionarioBotonesRespuestas, string toMensaje, string toDialogResult)
        {
            if( toPantalla != null && !string.IsNullOrWhiteSpace(toPantalla._Guid) && !string.IsNullOrWhiteSpace(toPantalla._Pantalla))
            {                
                string lcUsuario = Convert.ToString(EW_GLOBAL._GetVariable("wc_usuario"));
                UserMessageBox userMessageBox = new UserMessageBox();
                userMessageBox._MsgBox = toPantalla._Guid.ToUpper();
                userMessageBox._Pantalla = toPantalla._Pantalla.ToUpper();
                userMessageBox._Usuario = lcUsuario;
                userMessageBox._Pregunta = toMensaje;

                userMessageBox._CargarOpciones(toDiccionarioBotonesRespuestas, toDialogResult);

                userMessageBox._Save();
            }
        }

        private bool _RespuestaEncontrada(MessageBoxAutomatico toPantalla, ref DialogResult toDialogResult)
        {
            bool respuestaEncontrada = false;

            if (toPantalla != null && !string.IsNullOrWhiteSpace(toPantalla._Guid) && !string.IsNullOrWhiteSpace(toPantalla._Pantalla))
            {
                string lcUsuario = Convert.ToString(EW_GLOBAL._GetVariable("wc_usuario"));
                UserMessageBox userMessageBox = new UserMessageBox();
                userMessageBox._MsgBox = toPantalla._Guid.ToUpper();
                userMessageBox._Pantalla = toPantalla._Pantalla.ToUpper();
                userMessageBox._Usuario = lcUsuario;

               if( userMessageBox._Load())
                {
                    UserMessageBoxOpcion opcionSel = userMessageBox._DialogOpcionSel();
                    string resultDefault = opcionSel._DialogResult;
                    toDialogResult = (DialogResult)Enum.Parse(typeof(DialogResult), resultDefault);
                    respuestaEncontrada = true;
                    if (userMessageBox._AvisoActivo)
                    {
                        _ShowMessageBoxAutomatic(PanelAvisoRespAuto.TipoAviso.Info, "Respuesta automática activada", userMessageBox._Pregunta, opcionSel._Respuesta, userMessageBox._MsgBox);
                    }
                }                
            }
            return respuestaEncontrada;
        }

        public void _LockScreen(bool tlBloquear)
        {
            // Bug 162319. Si el formualrio no estaba visible se mostraba vacío. Si el formulario no está visible, no hace falta bloquear
            if (!Visible)
            {
                return;
            }

            SendMessage(Handle, WM_SETREDRAW, !tlBloquear, 0);

            if (!tlBloquear)
                Refresh();
        }

        protected virtual FormBase Clone()
        {
            return (FormBase)Activator.CreateInstance(this.GetType());
        }

        private void InitializeComponent()
        {
            this.components = new System.ComponentModel.Container();
            System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(FormBase));
            this._oErrorProvider = new sage.ew.objetos.ewErrorProvider();
            this.contextMenuStripPantalla = new System.Windows.Forms.ContextMenuStrip(this.components);
            this.configuracionesUsuarioItem = new System.Windows.Forms.ToolStripMenuItem();
            this.toolConfiguracionesToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
            this.configuracionesUsuarioItemSeparator = new System.Windows.Forms.ToolStripSeparator();
            this.nombreFormularioToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
            this.ShowPropertiesToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
            this.gestiónDeFavoritosToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
            this.gestiónDeAccesosToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
            this.crearAccesoDirectoToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
            this.crearTareaProgramadaItem = new System.Windows.Forms.ToolStripMenuItem();
            this.crearApunteCalendarioItem = new System.Windows.Forms.ToolStripMenuItem();
            this.listadosPersonalizablesEditarItem = new System.Windows.Forms.ToolStripMenuItem();
            this.listadosPersonalizablesDuplicarItem = new System.Windows.Forms.ToolStripMenuItem();
            this.ayudaPantallaToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
            this._MenuContext_Opciones = new sage.ew.objetos.ewcontextmenustrip(this.components);
            ((System.ComponentModel.ISupportInitialize)(this._oErrorProvider)).BeginInit();
            this.contextMenuStripPantalla.SuspendLayout();
            this.SuspendLayout();
            // 
            // _oErrorProvider
            // 
            this._oErrorProvider._ErrorToolTipActive = true;
            this._oErrorProvider.BlinkStyle = System.Windows.Forms.ErrorBlinkStyle.NeverBlink;
            this._oErrorProvider.ContainerControl = this;
            this._oErrorProvider.Icon = ((System.Drawing.Icon)(resources.GetObject("_oErrorProvider.Icon")));
            // 
            // contextMenuStripPantalla
            // 
            this.contextMenuStripPantalla.Items.AddRange(new System.Windows.Forms.ToolStripItem[] {
            this.configuracionesUsuarioItem,
            this.configuracionesUsuarioItemSeparator,
            this.nombreFormularioToolStripMenuItem,
            this.gestiÃnDeFavoritosToolStripMenuItem,
            this.gestiónDeAccesosToolStripMenuItem,
            this.crearAccesoDirectoToolStripMenuItem,
            this.crearTareaProgramadaItem,
            this.crearApunteCalendarioItem,
            this.listadosPersonalizablesEditarItem,
            this.listadosPersonalizablesDuplicarItem,
            this.ayudaPantallaToolStripMenuItem,
            this.ShowPropertiesToolStripMenuItem});
            this.contextMenuStripPantalla.Name = "contextMenuStripPantalla";
            this.contextMenuStripPantalla.Size = new System.Drawing.Size(289, 230);
            // 
            // configuracionesUsuarioItem
            // 
            this.configuracionesUsuarioItem.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] {
            this.toolConfiguracionesToolStripMenuItem});
            this.configuracionesUsuarioItem.Name = "configuracionesUsuarioItem";
            this.configuracionesUsuarioItem.Size = new System.Drawing.Size(288, 22);
            this.configuracionesUsuarioItem.Text = "Configuraciones de usuario";
            // 
            // toolConfiguracionesToolStripMenuItem
            // 
            this.toolConfiguracionesToolStripMenuItem.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.toolConfiguracionesToolStripMenuItem.Name = "toolConfiguracionesToolStripMenuItem";
            this.toolConfiguracionesToolStripMenuItem.Size = new System.Drawing.Size(221, 22);
            this.toolConfiguracionesToolStripMenuItem.Text = "Diseñador configuraciones";
            // 
            // configuracionesUsuarioItemSeparator
            // 
            this.configuracionesUsuarioItemSeparator.Name = "configuracionesUsuarioItemSeparator";
            this.configuracionesUsuarioItemSeparator.Size = new System.Drawing.Size(285, 6);
            // 
            // nombreFormularioToolStripMenuItem
            // 
            this.nombreFormularioToolStripMenuItem.Name = "nombreFormularioToolStripMenuItem";
            this.nombreFormularioToolStripMenuItem.Size = new System.Drawing.Size(288, 22);
            this.nombreFormularioToolStripMenuItem.Text = "Nombre del formulario";
            // 
            // ShowPropertiesToolStripMenuItem
            // 
            this.ShowPropertiesToolStripMenuItem.Name = "ShowPropertiesToolStripMenuItem";
            this.ShowPropertiesToolStripMenuItem.Size = new System.Drawing.Size(288, 22);
            this.ShowPropertiesToolStripMenuItem.Text = "Mostrar propiedades controles";
            // 
            // gestiónDeFavoritosToolStripMenuItem
            // 
            this.gestiónDeFavoritosToolStripMenuItem.Name = "gestiónDeFavoritosToolStripMenuItem";
            this.gestiónDeFavoritosToolStripMenuItem.Size = new System.Drawing.Size(288, 22);
            this.gestiónDeFavoritosToolStripMenuItem.Text = "Gestión de favoritos";
            // 
            // gestiónDeAccesosToolStripMenuItem
            // 
            this.gestiónDeAccesosToolStripMenuItem.Name = "gestiónDeAccesosToolStripMenuItem";
            this.gestiónDeAccesosToolStripMenuItem.Size = new System.Drawing.Size(288, 22);
            this.gestiónDeAccesosToolStripMenuItem.Text = "Gestión de accesos";
            // 
            // crearAccesoDirectoToolStripMenuItem
            // 
            this.crearAccesoDirectoToolStripMenuItem.Name = "crearAccesoDirectoToolStripMenuItem";
            this.crearAccesoDirectoToolStripMenuItem.Size = new System.Drawing.Size(288, 22);
            this.crearAccesoDirectoToolStripMenuItem.Text = "Crear acceso directo";
            // 
            // crearTareaProgramadaItem
            // 
            this.crearTareaProgramadaItem.Name = "crearTareaProgramadaItem";
            this.crearTareaProgramadaItem.Size = new System.Drawing.Size(288, 22);
            this.crearTareaProgramadaItem.Text = "Crear tarea programada";
            // 
            // crearApunteCalendarioItem
            // 
            this.crearApunteCalendarioItem.Name = "crearApunteCalendarioItem";
            this.crearApunteCalendarioItem.Size = new System.Drawing.Size(288, 22);
            this.crearApunteCalendarioItem.Text = "Nue&vo apunte calendario";
            // 
            // listadosPersonalizablesEditarItem
            // 
            this.listadosPersonalizablesEditarItem.Name = "listadosPersonalizablesEditarItem";
            this.listadosPersonalizablesEditarItem.Size = new System.Drawing.Size(288, 22);
            this.listadosPersonalizablesEditarItem.Text = "Editar el listado personalizable";
            // 
            // listadosPersonalizablesDuplicarItem
            // 
            this.listadosPersonalizablesDuplicarItem.Name = "listadosPersonalizablesDuplicarItem";
            this.listadosPersonalizablesDuplicarItem.Size = new System.Drawing.Size(288, 22);
            this.listadosPersonalizablesDuplicarItem.Text = "Duplicar y editar el listado personalizable";
            // 
            // ayudaPantallaToolStripMenuItem
            // 
            this.ayudaPantallaToolStripMenuItem.Name = "ayudaPantallaToolStripMenuItem";
            this.ayudaPantallaToolStripMenuItem.Size = new System.Drawing.Size(288, 22);
            this.ayudaPantallaToolStripMenuItem.Text = "Ayuda";
            // 
            // _MenuContext_Opciones
            // 
            this._MenuContext_Opciones.Font = new System.Drawing.Font("Segoe UI", 9.5F);
            this._MenuContext_Opciones.Name = "ewcontextmenustripOpcProc";
            this._MenuContext_Opciones.Size = new System.Drawing.Size(61, 4);
            // 
            // FormBase
            // 
            this.ClientSize = new System.Drawing.Size(284, 262);
            this.KeyPreview = true;
            this.Name = "FormBase";
            this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen;
            ((System.ComponentModel.ISupportInitialize)(this._oErrorProvider)).EndInit();
            this.contextMenuStripPantalla.ResumeLayout(false);
            this.ResumeLayout(false);

        }
        
        /// <summary>
        /// Devuelve una lista de los controles del tipo especificado
        /// Si no pasamos ningún control lo busca en todo el formulario
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="toControl"></param>       
        /// <returns></returns>
        public List<T> _FindControl<T>(Control toControl = null)
        {
            if (toControl == null)
                toControl = this;

            List<T> lstControls = new List<T>();

            lstControls = AllControls(toControl).OfType<T>().ToList();

            return lstControls;
        }

        /// <summary>
        /// Devuelve todos los controles
        /// </summary>
        /// <param name="container"></param>
        /// <returns></returns>
        private IEnumerable<Control> AllControls(Control container)
        {
            foreach (Control control in container.Controls)
            {
                yield return control;

                foreach (var innerControl in AllControls(control))
                    yield return innerControl;
            }
        }

        
        /// <summary>
        /// Capturamos el metodo para capturar los posibles mensajes enviados desde Eurowin (VFP)
        /// </summary>
        /// <param name="msgEW"></param>
        protected override void WndProc(ref Message msgEW)
        {
            if (msgEW.Msg != WM_SYSCOMMAND  || (msgEW.Msg == WM_SYSCOMMAND && ( _ExecuteCommandBefore == null || _ExecuteCommandBefore.Invoke(this, msgEW.WParam))))
            {
                base.WndProc(ref msgEW);

                if (EW_GLOBAL._EsEjecutable)
                {
                    //TODO: Temporal hasta que veamos que pasa realmente
                    if (!System.Diagnostics.Debugger.IsAttached && !NETVFP._ReceiveMessageFromVfp(ref msgEW))
                        return;
                }
            }
        }
        
        /// <summary>        
        /// PE-77741
        /// Evento para realizar las mismas comprobaciones que en el método análogo de la pantalla de fox 
        /// En los distintos formularios de .net donde se quiera realizar este control, habrá que sobreescribir este evento 
        /// teniendo en cuenta que el objeto "taParams" es un array de objetos con los mismos parámetros y valores que en el
        /// formulario equivalente de fox.
        /// </summary>
        /// <param name="taParams"></param>
        /// <returns></returns>
        public virtual bool _Init(object[] taParams)
        {
            if (taParams.Count() > 0)
            {
                _lAutomatico = true; //Bug 206971: Para poder saber en el formbase si estamos en una tarea programada
            }
            return true;
        }
        // FI PE-77741

        /// <summary>
        /// Método virtual que se invoca siempre que se muestra un formulario.
        /// Nos sirve para recuperar los parametros del acceso directo.
        /// </summary>
        /// <param name="taParams">Parametros de inicio</param>
        public virtual bool _InitAccesoDirecto(object[] taParams)
        {
            // Obtención de los parámetros según pantalla
            if (taParams != null && taParams.Length > 0)
            {
                foreach (object loItem in taParams)
                {
                    //Si trobem un parametre que començi per "idparam:" es que tenin propietats guardades a COMUNES!ACDIRPARAM
                    if (loItem.ToString().StartsWith(FUNCTIONS._AccesoDirectoParametro))
                    {
                        //Recuperem les propietats que mes tard asignarem al OnShown
                        return FUNCTIONS._RecuperarParametrosAccesoDirecto(loItem.ToString(), ref this._ValoresAccesoDirecto);
                    }
                }
            }
            return false;
        }

        /// <summary>
        /// Método virtual genérico para asignar los valores de los parametros de acceso directo en los controls del formulario a partir de la propiedad _ValoresAccesoDirecto.
        /// Se llama en el OnShown del formulario. Si se añade logica al OnShown del formulario hijo, recordar hacer la llamada al padre (base.OnShown())
        /// al finalizar la asignación de valores en los controles del propio formulario, así evitaremos que los parametros del A.D. se machaquen con los nuestros
        /// </summary>
        public virtual bool _EstablecerParametrosFormulario()
        {
            if (DesignMode)
                return true;

            bool llOk = false;
            if (this._ValoresAccesoDirecto.Count > 0)
            {
                string lcControl = "", lcPropiedad = "";
                object lcValor = "";
                foreach (KeyValuePair<string, object> loItem in this._ValoresAccesoDirecto)
                {
                    //La key estara composada del "nom_control:propietat_a_definir"
                    //El value contindra el valor de la propietat
                    if (loItem.Key.Contains(":"))
                    {
                        lcControl = loItem.Key.Substring(0, loItem.Key.IndexOf(":"));
                        lcPropiedad = loItem.Key.Substring(loItem.Key.IndexOf(":") + 1);
                        lcValor = loItem.Value;
                        //Recuperamos el control del formulario
                        Control loControl = this.__FindControlRecursive(lcControl);
                        if (loControl != null)
                        {
                            //Recuperamos la propiedad del Control
                            Type myType = loControl.GetType();
                            PropertyInfo myPropInfo = myType.GetProperty(lcPropiedad);
                            if (myPropInfo != null)
                            {
                                if (loControl is txtFiltroBase)
                                {
                                    llOk = true;
                                    if (lcPropiedad == "_Desde")
                                        (loControl as txtFiltroBase)._oFiltroDesde._Codigo = Convert.ToString(lcValor);
                                    else if (lcPropiedad == "_Hasta")
                                        (loControl as txtFiltroBase)._oFiltroHasta._Codigo = Convert.ToString(lcValor);
                                    else if (lcPropiedad == "_Todos")
                                        (loControl as txtFiltroBase)._Todos = Convert.ToBoolean(lcValor);
                                    else if (lcPropiedad == "_Lista")
                                        (loControl as txtFiltroBase)._Lista = new List<string>(lcValor.ToString().Split(','));
                                }
                                else
                                {
                                    //Tratamiento de valores
                                    object lcRealValue = lcValor;
                                    if (loControl is ewcombobox && lcPropiedad.ToLower() == "selectedindex")
                                        lcRealValue = Convert.ToInt32(lcRealValue);
                                    else if ((loControl is ewcheckbox || loControl is ewradiobutton) && lcPropiedad.ToLower() == "checked")
                                        lcRealValue = Convert.ToBoolean(lcRealValue);

                                    //Establecemos el valor a la propiedad
                                    try
                                    {
                                        myPropInfo.SetValue(loControl, lcRealValue, null);
                                        llOk = true;
                                    }
                                    catch (Exception)// loEx)
                                    {
                                        //TODO : Errores derivados de establecer propiedades con tipos que no corresponden?
                                        //loEx = loEx;
                                    }
                                }
                            }
                        }
                    }
                }
            }
            return llOk;
        }

        //PE-85758
        /// <summary>
        /// Método específico para disponer ShapeContainers
        /// </summary>
        /// <param name="toShapeContainer"></param>
        protected void _DisposeShapeContainer(Microsoft.VisualBasic.PowerPacks.ShapeContainer toShapeContainer)
        {
            if (toShapeContainer != null && !toShapeContainer.IsDisposed)
            {
                if (toShapeContainer.Shapes != null)
                {

                    List<Microsoft.VisualBasic.PowerPacks.Shape> llisShapes = new List<Microsoft.VisualBasic.PowerPacks.Shape>();
                    foreach (Microsoft.VisualBasic.PowerPacks.Shape tshape in toShapeContainer.Shapes)
                    {
                        llisShapes.Add(tshape);
                    }
                    toShapeContainer.Shapes.Clear();
                    toShapeContainer.Shapes.Dispose();

                    foreach (Microsoft.VisualBasic.PowerPacks.Shape loShape in llisShapes)
                    {
                        loShape.Dispose();
                    }
                }
                toShapeContainer.Dispose();
            }
        }

        [DllImport("user32")]
        private static extern IntPtr GetWindowDC(IntPtr hwnd);

        /// <summary>
        /// Método para el control de errores mediante objetos de tipo ErrorProvider.
        /// Se muestra un icono de error junto al control, sin efecto Blink y 
        /// con el icono alineado al centro de la parte izquierda del control.
        /// => Es equivalente a _oErrorProvider.SetError(NombreControl, TextoError) pero alineando al icono
        /// Para liberar al control del error basta con repetir la llamada al método pero con el texto de 
        /// error en blanco.
        /// </summary>
        /// <param name="toControl">Control sobre el que se va a establecer un icono de error.</param>
        /// <param name="tcMensaje">Mensaje de error. Si esta en blanco libera el control de la notificación de error</param>
        /// <param name="toAlineamiento">Alineamiento de la imagen</param>
        public virtual void _ControlError(Control toControl, string tcMensaje, ErrorIconAlignment toAlineamiento = ErrorIconAlignment.MiddleLeft)
        {
            _oErrorProvider.BlinkStyle = ErrorBlinkStyle.NeverBlink;
            _oErrorProvider.SetIconAlignment(toControl, toAlineamiento); // PARTE 93189. Se ha añadido el parámetro para poder pasarle la alineación
            _oErrorProvider.SetError(toControl, tcMensaje);

            // PE-92786. Obtener si ya hay algun error y concatenarlo
            string lcError = "";
            if (!string.IsNullOrWhiteSpace(tcMensaje))
            {
                lcError = this._oErrorProvider.GetError(this);
                lcError += (!string.IsNullOrWhiteSpace(lcError) ? Environment.NewLine : string.Empty) + tcMensaje;
                //if (toControl is IValidationControl)
                //{
                //    ((IValidationControl)toControl)._ErrorValidation = true;
                //}
            }
            //else
            //{
            //    if (toControl is IValidationControl)
            //    {
            //        ((IValidationControl)toControl)._ErrorValidation = false;
            //    }
            //}
        }


        /// <summary>
        /// PE92638
        /// Fa el ShowDialog però abans comprova l'accès al formulari
        /// </summary>
        public virtual void _ShowDialog()
        {
            if(CanShow()) ShowDialog();
        }

        /// <summary>
        /// PE92638
        /// Fa el Show però abans comprova l'accès al formulari
        /// </summary>
        public virtual void _Show()
        {
            if (CanShow()) Show();
        }

        private bool CanShow()
        {
            if (this._NivelAcceso != _TiposAccesosPantalla.Denegado && !this.IsDisposed) //T114218
            {
                if (_SaveReuseFormSettings && Usuario._This._PosicionFormulario)
                {
                    using (FormManagerProperties loFormManagerProperties = new FormManagerProperties(this))
                    {
                        _ReusingFormSettings = loFormManagerProperties._SetProperties();
                    }
                }

                return true;
            }

            return false;
        }

       

        private List<IButtonBarraHerram> _oListButtonsSagePanel = null;
        
        /// <summary>
        /// Lista de botones para el panel Sage50
        /// </summary>
        internal List<IButtonBarraHerram> _ButtonsSagePanel
        {
            get 
            {
                List<IButtonBarraHerram> loListButtonsAddons;

                if ( _oListButtonsSagePanel == null )
                {
                    _oListButtonsSagePanel = new List<IButtonBarraHerram>();

                    //Si la ayuda esta activa y hay ayuda o noticias
                    if(AyudaActiva() && _oResultadoAyuda._Ayuda) _oListButtonsSagePanel.Add(new AyudaNoticiasPantalla(this, _oResultadoAyuda));
                    
                    _oListButtonsSagePanel.Add(new AyudaPantalla(this));
                    _oListButtonsSagePanel.Add(new OpcionesPantalla(this));

                    // Comprobar si hay que mostrar la opción de configuración de mensajes por usuario/pantalla
                    if (_messageBoxAutomatic)
                        _oListButtonsSagePanel.Add(new CfgUsabilidad(this));

                    loListButtonsAddons = AddonsController.Instance.Methods.BindFormBarraHerram(_Pantalla);
                    if (loListButtonsAddons is List<IButtonBarraHerram> && loListButtonsAddons.Count > 0) _oListButtonsSagePanel.AddRange(loListButtonsAddons);
                }

                return _oListButtonsSagePanel;
            }
        }
        
        /// <summary>
        /// PE-87849: Mostrar formulario de accesos mediante el usuario actual        
        /// </summary>
        protected virtual void _Show_Accesos()
        {
            _Show_Accesos(_Pantalla);
        }

        /// <summary>
        /// Mostrar formulario de accesos mediante el usuario actual, para un formulario específico
        /// </summary>
        /// <param name="lcPantalla"></param>
        protected void _Show_Accesos(String lcPantalla)
        {
            // PE-92757. Usamos usuario estático
            if (!Usuario._This._Show_Gestion_Accesos(lcPantalla, _EliminarAcronimo(this.Text)))   //PE-90297: pasamos el título de la pantalla también por si no existe en los accesos añadirlo
            {
                _MessageBox("El usuario activo no tiene permisos para gestionar accesos a pantallas.", MessageBoxButtons.OK, MessageBoxIcon.Stop, MessageBoxDefaultButton.Button1, DialogResult.OK);
            }
        }

        /// <summary>
        /// PE-87840: Mostrar formulario de favoritos mediante el usuario actual        
        /// </summary>
        protected void _Show_Favoritos()
        {
            // PE-92757. Usamos usuario estático
            Usuario._This._Show_Favoritos(this._Pantalla, _EliminarAcronimo(this.Text));   //PE-92094: pasamos el título de la pantalla también, igual que en los accesos
        }

        /// <summary>
        /// PE-86720: mostrar la gestión de favoritos
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void gestiónDeFavoritosToolStripMenuItem_Click(object sender, EventArgs e)
        {
            this._Show_Favoritos();
        }

        /// <summary>
        /// PE-86720: mostrar la gestión de accesos
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void gestiónDeAccesosToolStripMenuItem_Click(object sender, EventArgs e)
        {
            this._Show_Accesos();
        }

        /// <summary>
        /// Crear acceso directo al formulario
        /// PE-95995
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void crearAccesoDirectoToolStripMenuItem_Click(object sender, EventArgs e)
        {
            this._AsignarValoresAccesoDirecto();
            //Creem el acces directe
            sage.ew.functions.FUNCTIONS._CrearAccesoDirecto(_EliminarAcronimo(this.Text), this._Pantalla.Trim(), this._ValoresAccesoDirecto);
        }

        /// <summary>
        /// Método virtual que se invoca antes de crear el acceso directo y que nos servirá para definir 
        /// los parámetros que se guradaran para el acceso directo a esta pantalla.
        /// </summary>
        /// <returns></returns>
        public virtual bool _AsignarValoresAccesoDirecto()
        {
            return false;
        }

        //PE-96746
        /// <summary>
        /// Respuesta al click de crear apunte de calendario
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void crearApunteCalendarioItem_Click(object sender, EventArgs e)
        {
            functions.FUNCTIONS._CrearNuevoApunteCalendario(this, _Pantalla);
        }

        // PARTE 101745
        /// <summary>
        /// Respuesta al click de ayuda de la pantalla
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void ayudaPantallaToolStripMenuItem_Click(object sender, EventArgs e)
        {
            _MostrarAyudaPantalla();
        }

        /// <summary>
        /// Mostrar la ayuda de la pantalla
        /// </summary>
        public void _MostrarAyudaPantalla()
        {
            // Bug 154751. Mostrar o no la ayuda
            // _PantallaAyuda tiene el valor de _Pantalla inicialmente
            // De este modo podemos tener una pantalla sin gestión de accesos con la ayuda correspondiente
            if (_MostrarAyudaF1) FUNCTIONS._MostrarAyudaPantalla(this._PantallaAyuda);
        }
        // FPARTE 101745

        /// <summary>
        /// Task 104592: Evento para ejecutar la creación de tarea programada
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void crearTareaProgramadaItem_Click(object sender, EventArgs e)
        {
            _CrearTareaProgramada(this._Pantalla);
        }

        /// <summary>
        /// Evento para cargar una configuración de usuario/pantalla
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void ConfiguracionesUsuarioItem_Click(object sender, EventArgs e)
        {
            ConfigUserForm loConfig;

            // Guardar "Última configuración" antes de abrir el editor de configuraciones            
            //ConfigUserOptionsUpdateLastValues();

            FormBase loFormClon = this.Clone();
            loFormClon._ConfigUserForm = this._ConfigUserForm;
            loFormClon._ConfigUserOptionsEditing = true;

            loConfig = ConfigurationDesignManager.ShowInDesign(loFormClon, this._ConfigUserForm);

            if (loConfig is ConfigUserForm)
            {
                _ConfigUserForm = loConfig;
                _ConfigUserOptionsLoad(_ConfigUserForm._dicOpciones);
            }

            loFormClon.Close();
            loFormClon.Dispose();
            loFormClon = null;
        }

        #region Opciones de menu para listados personalizables

        /// <summary>
        /// Task 104592: Método virtual para crear una tarea programada (principalmente para el FormListado)
        /// </summary>
        /// <param name="tcPantalla"></param>
        protected virtual void _CrearTareaProgramada(string tcPantalla)
        {
        }


        /// <summary>
        /// Generar un nuevo listado personalizable a partir de un listado existente previamente
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void listadosPersonalizablesDuplicarItem_Click(object sender, EventArgs e)
        {
            this.Close();

            ListadosPersonalizables loList = new ListadosPersonalizables();
            if (!loList._DuplicarListado(this._Pantalla))
            {
                sage.ew.functions.FUNCTIONS._MessageBox(loList._Error_Message, this.Text, //"Informes personalizables"
                    MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1);
            }
        }

        /// <summary>
        /// Editar un listado personalizable previamente creado
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void listadosPersonalizablesEditarItem_Click(object sender, EventArgs e)
        {
            this.Close();

            ListadosPersonalizables loList = new ListadosPersonalizables();
            if (!loList._CargarListado(this._Pantalla))
            {
                sage.ew.functions.FUNCTIONS._MessageBox(loList._Error_Message, this.Text, //"Informes personalizables"
                    MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1);
            }
        }

        #endregion Opciones de menu para listados personalizables

        private void ShowPropertiesToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (Debugger.IsAttached)
            {
                if (_oTimerProperties is Timer)
                {
                    ShowPropertiesToolStripMenuItem.Text = "Mostrar propiedades controles";

                    _InfoToolTip.Active = false;

                    _oTimerProperties.Stop();
                    _oTimerProperties.Tick -= _oTimerProperties_Tick;
                    _oTimerProperties.Dispose();
                    _oTimerProperties = null;
                }
                else
                {
                    ShowPropertiesToolStripMenuItem.Text = "Ocultar propiedades controles";

                    _InfoToolTip.Active = true;

                    _oTimerProperties = new Timer();
                    _oTimerProperties.Tick += _oTimerProperties_Tick;
                    _oTimerProperties.Interval = 500;
                    _oTimerProperties.Start();
                }
            }
        }

        private void _oTimerProperties_Tick(object sender, EventArgs e)
        {
            Control loControl;
            Point loPos = Cursor.Position;

            if (Bounds.Contains(loPos))
            {
                loControl = _GetChild(loPos, this);

                if ((loControl is Control && string.IsNullOrEmpty(_ControlNameShowing)) || (loControl is Control && loControl.Name != _ControlNameShowing))
                {
                    _ControlNameShowing = _InfoToolTip._GetControl(loControl).Name;
                    _CreateTooltipInfo(loControl, loControl.DataBindings.Count > 0 ? loControl.Name : "");
                    if(!loControl.Enabled) _InfoToolTip.Show(loControl.Name, this, PointToClient(loPos));
                }
                else if(loControl == null && !string.IsNullOrEmpty(_ControlNameShowing))
                {
                    _InfoToolTip.Hide(this);
                    _ControlNameShowing = string.Empty;
                }
            }
            else
            {
                _ControlNameShowing = string.Empty;
            }
        }

        private void _CreateTooltipInfo(Control toControl, string tcText = "")
        {
            string lcText;

            lcText = string.IsNullOrEmpty(tcText) ? toControl.DataBindings.Count > 0 ? toControl.Name : "" : tcText;

            if (!string.IsNullOrEmpty(lcText)) _InfoToolTip._ControlToolTip(toControl, lcText);

            if (toControl.Controls.Count > 0)
            {
                foreach (Control loControl in toControl.Controls)
                {
                    lcText = string.IsNullOrEmpty(tcText) ? loControl.DataBindings.Count > 0 ? loControl.Name : "" : tcText;

                    if (!string.IsNullOrEmpty(lcText))
                    {
                        _InfoToolTip._ControlToolTip(loControl, lcText);
                    }

                    if (loControl.Controls.Count > 0)
                    {
                        _CreateTooltipInfo(loControl, lcText);
                    }
                }
            } 
        }

        private string _ControlNameShowing;

        /// <summary>
        /// Obtener un Control situado en un point
        /// </summary>
        /// <param name="toPoint"></param>
        /// <param name="toBase"></param>
        /// <returns></returns>
        public Control _GetChild(Point toPoint, Control toBase)
        {
            Control loControl = null;

            if(toBase is Control) loControl = toBase.GetChildAtPoint(toBase.PointToClient(toPoint), GetChildAtPointSkip.Invisible | GetChildAtPointSkip.Transparent);

           return loControl?.Controls.Count > 0 && loControl?.DataBindings.Count == 0? _GetChild(toPoint, loControl) : loControl;
        }
        
        /// <summary>
        /// Mostrar la información relevante de la pantalla que llama este método.
        /// Se presentara la siguiente información:
        /// - Titulo del formulario
        /// - Librearia en la que esta contenido
        /// - Nombre de la clase del formulario
        /// - Pantalla (en caso de que esta definida)
        /// En mantenimientos y documentos se presentara también la información de los addons que modifiquen el formulario:
        /// - Nombre del addon / Libreria que carga (Si esta o no firmada y por quien)
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void nombreFormularioToolStripMenuItem_Click(object sender, EventArgs e)
        {
            frmInfoFormul loFormul = new frmInfoFormul();

            //Cabecera Información
            loFormul.AddHeader("Información");

            //Titulo del formulario
            loFormul.AddLine("Título", _EliminarAcronimo(this.Text));

            //Libreria
            loFormul.AddLine("Librería", System.Reflection.Assembly.GetAssembly(this.GetType()).Location);

            //Clase
            loFormul.AddLine("Clase", this.GetType().Name);

            //Pantalla. Presentamos el valo de _PantallaAyuda
            if (!string.IsNullOrWhiteSpace(_PantallaAyuda))
                loFormul.AddLine("Pantalla", _PantallaAyuda.Trim().ToUpper());

            //S50MIG-3188 Añadir namespace
            loFormul.AddLine("Namespace", GetType().Namespace);

            //Addons
            Dictionary<string, object> loAddons = null;
            if (this is FormMante && (this as FormMante)._ewMante != null && (this as FormMante)._ewMante._Addons != null)
            {
                loAddons = (this as FormMante)._ewMante._Addons;
            }
            else if (this is frmGestionPerfil && (this as frmGestionPerfil)._Documento != null && (this as frmGestionPerfil)._Documento._Addons != null)
            {
                loAddons = (this as frmGestionPerfil)._Documento._Addons;
            }
            else if (this is FormListado && (this as FormListado)._Addons != null)
            {
                loAddons = (this as FormListado)._Addons;
            }

            if (loAddons != null && loAddons.Count > 0)
            {
                //Cabecera addons
                loFormul.AddHeader("Add-ons");
                //Info de addons
                string lcDllAddon = "", lcSubjectName = "";
                foreach (KeyValuePair<string, object> loItem in loAddons)
                {
                    try
                    {
                        // Obtenemos el objeto de extensiones y lo configuramos
                        //loExtension = (_ExtensionMante)loItem.Value;
                        string lcName = "", lcTmp = "";
                        if (AddonsController.Instance.AddonsManager.IsLoaded(loItem.Key))
                        {
                            //Ruta a la dll
                            lcDllAddon = (AddonsController.Instance.AddonsManager.GetAddon(loItem.Key) as IModulo)._Libreria + ".dll";
                            lcTmp = lcDllAddon;
                            //Qui la firma
                            lcSubjectName = FUNCTIONS.GetDllNameInfo(lcDllAddon);
                            if (!string.IsNullOrWhiteSpace(lcSubjectName))
                                lcTmp += " (" + lcSubjectName + ")";
                            else
                                lcTmp += " (Sin firmar)";
                            //Quin tipus es
                            int lnTipo = (AddonsController.Instance.AddonsManager.GetAddon(loItem.Key) as IModulo)._Tipo;
                            switch (lnTipo)
                            {
                                case 2:
                                    lcTmp += " - Extensión contratable";
                                    break;
                                case 3:
                                    lcTmp += " - Extensión personalizada";
                                    break;
                                case 1:
                                case 0:
                                default:
                                    lcTmp += " - Extensión incluida";
                                    break;
                            }
                            //Nom del addon a mostrar
                            lcName = (AddonsController.Instance.AddonsManager.GetAddon(loItem.Key) as IModulo)._Nombre2;
                            if (string.IsNullOrWhiteSpace(lcName))
                                lcName = loItem.Key;

                            //Afegim una linia per cada addon
                            loFormul.AddLine(lcName, lcTmp);
                        }
                    }
                    catch (Exception loError)
                    {
                        DB.Registrar_Error(loError);
                    }
                }
            }

            //Mostramos el formulario
            loFormul._ShowDialog();
        }

        /// <summary>
        /// Elimina el acronimo del texto
        /// </summary>
        /// <param name="toText"></param>
        /// <returns></returns>
        protected string _EliminarAcronimo(String toText)
        {
            String lcText = toText;

            if (!String.IsNullOrEmpty(_Acronimo)) lcText = lcText.Replace(_Acronimo, "");
            lcText = lcText.TrimStart();

            return lcText;
        }


        /// <summary>
        /// Respuesta al click de "Reordenar pantallas" (PE-120903)
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void reordenarPantallasToolStripMenuItem_Click(object sender, EventArgs e)
        {
            // PE-103085 
            //NETVFP._Reordenar_Pantallas(); 
            //NETVFP._Ejecutar_Funcion_VFP("fPripals50.Reordenar_pantallas");
        }

        private void contextMenuStripPantalla_Opening(object sender, CancelEventArgs e)
        {
            contextMenuStripPantalla.Items["gestiónDeFavoritosToolStripMenuItem"].Image = sage.ew.images.Properties.Resources.favorite_16;
            contextMenuStripPantalla.Items["gestiónDeAccesosToolStripMenuItem"].Image = sage.ew.images.Properties.Resources.access_16;
            contextMenuStripPantalla.Items["crearAccesoDirectoToolStripMenuItem"].Image = sage.ew.images.Properties.Resources.link_16;
            contextMenuStripPantalla.Items["crearTareaProgramadaItem"].Image = sage.ew.images.Properties.Resources.TimeProgram; //TODO: utilizar otro icono
            contextMenuStripPantalla.Items["ShowPropertiesToolStripMenuItem"].Image = _oTimerProperties is null ? Resources.led_green_16 : Resources.led_red_16;

            bool lbSage50 = Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_sage50"));

            //Acces directe sols per a Sage50
            if (!lbSage50)
                contextMenuStripPantalla.Items["crearAccesoDirectoToolStripMenuItem"].Visible = false;
            else
                contextMenuStripPantalla.Items["crearAccesoDirectoToolStripMenuItem"].Visible = _MostrarCrearAccesoDirecto;  // PE-99866. Comprobar si mostar el ménu crear acceos directos            

            //Task 104592: Crear tarea programada
            if (!lbSage50)
                contextMenuStripPantalla.Items["crearTareaProgramadaItem"].Visible = false;
            else
                contextMenuStripPantalla.Items["crearTareaProgramadaItem"].Visible = _MostrarCrearTareaProgramada;

            //PE-96746
            contextMenuStripPantalla.Items["crearApunteCalendarioItem"].Image = sage.ew.images.Properties.Resources.calendar_16;

            //PE-103520 : listados personalizables
            contextMenuStripPantalla.Items["listadosPersonalizablesEditarItem"].Image = sage.ew.images.Properties.Resources.mant_edit_16;
            contextMenuStripPantalla.Items["listadosPersonalizablesDuplicarItem"].Image = sage.ew.images.Properties.Resources.duplicate_16;


            if (this is sage.ew.formul.Forms.FormListado)
            {
                if (!((sage.ew.formul.Forms.FormListado)this)._Personalizado)
                {
                    contextMenuStripPantalla.Items["listadosPersonalizablesEditarItem"].Visible = false;
                    if (!lbSage50)
                    {
                        contextMenuStripPantalla.Items["listadosPersonalizablesDuplicarItem"].Visible = false;
                    }
                    else
                    {
                        contextMenuStripPantalla.Items["listadosPersonalizablesDuplicarItem"].Visible = _MostrarDuplicarListado;
                    }
                }
            }
            else
            {
                contextMenuStripPantalla.Items["listadosPersonalizablesEditarItem"].Visible = false;
                contextMenuStripPantalla.Items["listadosPersonalizablesDuplicarItem"].Visible = false;
            }

            ConfigureConfigUserOptions();

            //PE-104540 - PE-104527 : Amagar l'opció de "Duplicar y editar el listado personalizable"
            //contextMenuStripPantalla.Items["listadosPersonalizablesDuplicarItem"].Visible = false;
        }

        /// <summary>
        /// Preparar menú de Configuraciones de usuario
        /// </summary>
        private void ConfigureConfigUserOptions()
        {
            configuracionesUsuarioItem.Image = sage.ew.images.Properties.Resources.icon_wrench;

            if (Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_sage50")) && _ConfigUserOptionsAllowed)
            {
                // Guardar "Última configuración"
                //ConfigUserOptionsUpdateLastValues();

                configuracionesUsuarioItem.Visible = true;
                configuracionesUsuarioItemSeparator.Visible = true;
                configuracionesUsuarioItem.DropDownItems.Clear();

                configuracionesUsuarioItem.DropDownItems.Add(toolConfiguracionesToolStripMenuItem);

                // Mostrar configuraciones de usuario                
                IEnumerable<ConfigUserForm> loList = _ConfigUserForm._ListaConfiguraciones().AsEnumerable();
                IEnumerable<ConfigUserForm> loListConfUsers = loList.Where(f => f._Tipo == ConfigUserForm.ConfigUserType.UserValuesConfig);
                IEnumerable<ConfigUserForm> loListDefaultConfUsers = loList.Where(f => f._Tipo != ConfigUserForm.ConfigUserType.UserValuesConfig);

                // Mostrar configuraciones del usuario
                _GenerateMenuItemsConfigUser(loListConfUsers.Where(f => !f._Publico));
                // Mostrar configuraciones públicas
                _GenerateMenuItemsConfigUser(loListConfUsers.Where(f => f._Publico));
                // Mostrar configuraciones base
                _GenerateMenuItemsConfigUser(loListDefaultConfUsers);
            }
            else
            {
                configuracionesUsuarioItem.Visible = false;
                configuracionesUsuarioItemSeparator.Visible = false;
            }
        }

        private void _GenerateMenuItemsConfigUser(IEnumerable<ConfigUserForm> toListConfigUsers)
        {
            if (toListConfigUsers != null && toListConfigUsers.Count() > 0)
            {
                configuracionesUsuarioItem.DropDownItems.Add(new ToolStripSeparator());

                foreach (ConfigUserForm loConfig in toListConfigUsers)
                {
                    ToolStripMenuItem loMenuItem = new ToolStripMenuItem();

                    loMenuItem.Text = loConfig._Config;
                    loMenuItem.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
                    loMenuItem.Click += LoadConfigUserMenuItem_Click;
                    loMenuItem.Tag = loConfig;

                    if (_ConfigUserForm._Config.Trim() == loConfig._Config.Trim()) loMenuItem.Image = sage.ew.images.Properties.Resources.icon_right;

                    configuracionesUsuarioItem.DropDownItems.Add(loMenuItem);
                }
            }
        }

        /// <summary>
        /// Evento para cargar configuración de usuario/pantalla des del menú de opciones
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void LoadConfigUserMenuItem_Click(object sender, EventArgs e)
        {
            if (sender is ToolStripMenuItem && ((ToolStripMenuItem)sender).Tag is ConfigUserForm)
            {
                ConfigUserForm loConfig = ((ToolStripMenuItem)sender).Tag as ConfigUserForm;

                // Antes de cargar la nueva configuración, guardamos "Última configuración"
                //ConfigUserOptionsUpdateLastValues();

                // Cargar nueva configuración
                _ConfigUserForm = loConfig;
                _ConfigUserOptionsLoad(_oConfigUserForm._dicOpciones);
            }
        }

        /// <summary>
        /// PE-96746: Comprobamos si hay que mostrar o no el la opció de apunte de calendario
        /// </summary>
        /// <returns>True si es visible</returns>
        protected bool _PresentarApunteCalendario()
        {
            return sage.ew.functions.FUNCTIONS._PermitirApunteCalendario(_Pantalla);
        }

        #region Forzar Fuente

        /// <summary>
        /// Override OnShown
        /// </summary>
        /// <param name="e"></param>
        protected override void OnShown(EventArgs e)
        {
            base.OnShown(e);

            if (EW_GLOBAL._EsEjecutable && _CambiarFuente)
            {
                if (Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_sage50")))
                {
                    if (estiloRevisado == false)
                    {
                        foreach (Control loControl in Controls)
                        {
                            FUNCTIONS._Cambiar_Font(loControl, "Segoe UI");
                        }
                    }
                }
                else
                {
                    foreach (Control loControl in Controls)
                    {
                        FUNCTIONS._Cambiar_Font(loControl, "Arial");
                    }
                }
            }

            // Bug 111565. En caso de abrir un formulario en modo MODAL, no dejamos minimizarlo
            if (this.Modal)
                this.MinimizeBox = false;

            //Asignem els parametres del formulari suposant que en tingui
            this._EstablecerParametrosFormulario();
        }

        #endregion Forzar Fuente

        /// <summary>
        /// Lista de toolStripMenuItems privada que se utiliza para poder gestionar las opciones del botón de opciones
        /// </summary>
        protected List<ToolStripMenuItemBase> _ToolStripMenuItemsBase = new List<ToolStripMenuItemBase>();

        /// <summary>
        /// Nuevo ítems del menú de opciones
        /// 
        /// Añade el ítem a la lista lstToolStripMenuItemBase para su posterior personalización
        /// </summary>
        /// <param name="tcNombre">Text del toolStripIEtem</param>
        /// <param name="tcNombre_Objeto">Nombre del objeto</param>
        /// <param name="tcTooltip">Tooltip del toolStripIEtem</param>
        /// <returns></returns>
        protected internal ToolStripMenuItemBase _AddToolStripMenuItemBase(string tcNombre, string tcNombre_Objeto, string tcTooltip)
        {
            ToolStripMenuItemBase loToolStripMenuItem = new ToolStripMenuItemBase(tcNombre, tcNombre_Objeto, tcTooltip);

            _ToolStripMenuItemsBase.Add(loToolStripMenuItem);

            return loToolStripMenuItem;
        }

        /// <summary>
        /// Notificamos a los subscriptores por si desean realizar una configuración de las opciones a presentar
        /// 
        /// NOTA: únicamente operativo en los documentos de perfiles y asientos
        /// </summary>
        /// <param name="sender">Referencia al objeto de opciones</param>
        protected internal void _GetOpcionesInvoke(object sender)
        {
            if (this is frmGestionPerfil || this is contabilidad.frmAsientos || this is frmListasPrevias || this.Name == "frmPrincipal") 
                _GetOpciones?.Invoke(new EventArgsOpciones(sender, _ToolStripMenuItemsBase));
            else
                throw new Exception("Este formulario no tiene ningún botón de Opciones o no está preparado para acceder a él");
        }

        /// <summary>
        /// Notificamos a los subscriptores por si desean añadir opciones en el botón de herramientas
        /// </summary>
        /// <param name="sender">Referencia al ContextMenu de opciones del botón de herramientas</param>
        /// <param name="tlstToolStripMenuItemsBase">Lista de ToolStripMenuItemBase</param>
        private void GetOpcionesHerramientasInvoke(object sender , List<ToolStripMenuItemBase> tlstToolStripMenuItemsBase)
        {
           _GetOpcionesHerramientas?.Invoke(new EventArgsOpciones(sender, tlstToolStripMenuItemsBase));
        }

        // Task 111119 - 115209 
        /// <summary>
        /// Inserta un control a los formularios, actualmente solo implementado en el formulario de perfiles
        /// </summary>
        /// <param name="toControl">Control a añadir al formulario, ha de cumplir la interfaz IAddonTabDoc, IAddonBotonMenuDoc, ...</param>
        /// <returns>Devuelve si ha agregado el control al formulario</returns>
        public virtual bool _InsertarObjetoAddon(Control toControl)
        {
            bool lITabDocAddon = false, llOk = true;
            Control loControlContenedor = this; // Asignamos donde vamos a agregar los controles
            string lcNombre_Objeto = toControl.Name;

            lITabDocAddon = toControl is IAddonTabDoc;

            if (lITabDocAddon)
                llOk = AddonInsertarTabDocAddon(toControl, ref loControlContenedor);
            else if ((toControl is IAddonBotonMenuDoc) && (toControl is Button)) // Task 123210: Creación de botones en la barra de herramientas de los Mantes
                llOk = AddonBotonMenuDoc(toControl);

            if (llOk)
                loControlContenedor.Controls.Add(toControl);

            return llOk;
        }

        /// <summary>
        /// Inserta un sage.ew.botones.ToolStripButtonAddonMante a la barra de botones en los FormMante
        /// </summary>
        /// <param name="toolStripButtonAddonMante"></param>
        /// <returns></returns>
        public virtual bool _InsertarObjetoAddon(ToolStripItem toolStripButtonAddonMante)
        {
            return true;
        }

        /// <summary>
        /// Para agregar opciones mediante los Addons en los mantenimientos y en el formulario de asientos
        /// </summary>
        /// <param name="toMenuStrip"></param>
        protected internal virtual void _AddonPrepararMenu(ewcontextmenustrip toMenuStrip)
        {
            if (this.lstOpcionesMenuAddon != null && this.lstOpcionesMenuAddon.Count > 0)
            {
                string lcTituloMenu, lcName;
                bool llSeparador = true;

                foreach (Control loControl in this.lstOpcionesMenuAddon)
                {
                    lcTituloMenu = ((IAddonBotonMenuDoc)loControl)._TituloMenu.Trim();

                    if (llSeparador && toMenuStrip.Items.Count > 0) // Añadimos un separador
                    {
                        toMenuStrip.Items.Add("-");
                        llSeparador = false;
                    }

                    toMenuStrip.Items.Add(lcTituloMenu);

                    lcName = loControl.Name;

                    if (string.IsNullOrWhiteSpace(lcName)) // Si el botón no tiene nombre le voy a asignar uno. Luego se realizará una búsqueda por el nombre del control
                    {
                        lcName = Convert.ToString(Guid.NewGuid()).ToUpper();
                        loControl.Name = lcName;
                    }

                    toMenuStrip.Items[toMenuStrip.Items.Count - 1].Name = lcName;
                    toMenuStrip.Items[toMenuStrip.Items.Count - 1].Click += new EventHandler(FormManteOpcionesAddon_Click);
                }
            }
        }
        // FTask 123210: Creación de botones en la barra de herramientas de los Mantes

        /// <summary>
        /// Ejecutamos la acción del botón correspondiente añadido mediante los Addons
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void FormManteOpcionesAddon_Click(object sender, EventArgs e)
        {
            string lcName = (sender as ToolStripMenuItem).Name;

            Control[] loControl = this.Controls.Find(lcName, true);

            if (loControl != null)
            {
                try
                {
                    ((ewbutton)loControl[0]).Enabled = true;
                    ((ewbutton)loControl[0]).PerformClick(); // No sabemos el código que se ha programado. Si da error ...
                }
                catch (Exception loEx)
                {
                    if (Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_prueva")) || System.Diagnostics.Debugger.IsAttached) // Gestión de error
                        this._MessageBox("Se ha producido la siguiente incidencia en la ejecución de la opción " + (sender as ToolStripMenuItem).Text.Trim() + ": " + Environment.NewLine + Environment.NewLine + loEx.Message, MessageBoxButtons.OK, MessageBoxIcon.Exclamation, MessageBoxDefaultButton.Button1, DialogResult.OK);
                }
            }
        }

        /// <summary>
        /// Configuramos la clase "clsElementos" para poder instanciar correctamente el control dque cumple la interfaz "IAddonBotonMenuDoc" que se añadirán en el botón de opciones correspondiente
        /// </summary>
        /// <param name="toControl"></param>
        private bool AddonBotonMenuDoc(Control toControl)
        {
            IAddonBotonMenuDoc loIAddonBotonMenuDoc = (IAddonBotonMenuDoc)toControl;

            this.lstOpcionesMenuAddon.Add(toControl); // Añadimos  la opción a la lista

            // La propiedad _Menu no la vamos a utilizar, únicamente es para los perfiles
            if (string.IsNullOrWhiteSpace(loIAddonBotonMenuDoc._TituloMenu) && toControl is ewbutton && !string.IsNullOrWhiteSpace(toControl.Text)) // Si no tiene título la opción, asignaremos el texto del botón
                loIAddonBotonMenuDoc._TituloMenu = toControl.Text;

            // Cambiamos la posición del control para que no se vea. No lo podemos hacer invisible o al hacer el PerformClick no se ejecutará
            toControl.Left = -10000;
            toControl.Top = -10000;
            toControl.Width = 1;
            toControl.Height = 1;

            AddonBotonMenuDocDocumento(toControl);

            return true;
        }

        /// <summary>
        /// Asignamos la referencia al documento al botón para realizar las acciones pertinentes
        /// </summary>
        /// <param name="toControl">Control de tipo IAddonBotonMenuDoc</param>
        private void AddonBotonMenuDocDocumento(Control toControl)
        {
            dynamic loDocumento = null;

            if (toControl is IAddonBotonMenuDoc)
            {
                if (this is FormMante)
                    loDocumento = ((FormMante)this)._ewMante;
                else if (this is FormBaseDocumento)
                    loDocumento = ((FormBaseDocumento)this)._Documento;

                if (loDocumento != null)
                {
                    IAddonBotonMenuDoc loIAddonBotonMenuDoc = ((IAddonBotonMenuDoc)toControl);
                    loIAddonBotonMenuDoc._Documento = loDocumento;
                }
            }
        }

        /// <summary>
        /// Realizamos el refresco recursivamente de los controles
        /// </summary>
        /// <param name="toContenedor">Objeto que puede ser contenedor de otros objetos</param>
        /// <param name="tlChild">Recorre si los diferentes controles del UserControl para ejecutar el _Refresh</param>
        private void ControlRefreshRecursive(Control toContenedor, bool tlChild = false)
        {
            if (!toContenedor.HasChildren)
                return;

            foreach (Control loControlChild in toContenedor.Controls)
                _ControlRefresh(loControlChild, tlChild);
        }

        /// <summary>
        /// Ejercución del método _Refresh del control
        /// </summary>
        /// <param name="toControl">Control al que se ejecutará el _Refresh</param>
        /// <param name="tlChild">Recorre si los diferentes controles del UserControl para ejecutar el _Refresh</param>
        public void _ControlRefresh(Control toControl, bool tlChild = false)
        {
            if (toControl == null)
                return;

            dynamic loControlDynamic = toControl;
            bool llRefresh = (toControl is IAddonTabDoc);

            if (llRefresh)
            {
                Type ltType = Type.GetType(loControlDynamic.GetType().AssemblyQualifiedName);

                MethodInfo objMethod = ltType.GetMethod("_Refresh"); // Busca la propiedad pública con el nombre especificado, si no la encuentra devuelve null
                llRefresh = (objMethod != null);
            }

            if (llRefresh)
            {
                try
                {
                    loControlDynamic._Refresh();
                }
                catch (Exception loEx)
                {
                    if (Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_prueva")) || System.Diagnostics.Debugger.IsAttached)
                        this._MessageBox("Se ha producido la siguiente incidencia en la ejecución del método Refresh del control " + toControl.Name + ": " + Environment.NewLine + Environment.NewLine + loEx.Message, MessageBoxButtons.OK, MessageBoxIcon.Exclamation, MessageBoxDefaultButton.Button1, DialogResult.OK);
                }
            }

            ControlRefreshRecursive(toControl);
        }

        /// <summary>
        /// Asociación de la propiedad _Documento al Addon recursivamente
        /// </summary>
        /// <param name="toContenedor">Objeto que puede ser contenedor de otros objetos</param>
        /// /// <param name="toDocumento"></param>
        /// <param name="tlChild">Recorre si los diferentes controles del UserControl para asociar el _Documento</param>
        private void ControlDocumentoRecursive(Control toContenedor, dynamic toDocumento, bool tlChild = false)
        {
            if (!toContenedor.HasChildren)
                return;

            foreach (Control loControlChild in toContenedor.Controls)
                _ControlDocumento(loControlChild, toDocumento, tlChild);
        }

        /// <summary>
        /// Asociación de la propiedad _Documento al Addon
        /// </summary>
        /// <param name="toControl">Control al que se asignará el _Documento</param>
        /// <param name="toDocumento">Referencia al documento</param>
        /// <param name="tlChild">Recorre si los diferentes controles del UserControl para asociar el _Documento</param>
        public void _ControlDocumento(Control toControl, dynamic toDocumento, bool tlChild = false)
        {
            if (toControl == null || toDocumento == null)
                return;

            dynamic loControlDynamic = toControl;
            bool llDocumento = (toControl is IAddonTabDoc);

            if (!llDocumento)
            {
                Type ltType = Type.GetType(loControlDynamic.GetType().AssemblyQualifiedName);

                MemberInfo[] objMember = ltType.GetMember("_Documento");
                llDocumento = (objMember.Length > 0);
            }

            if (llDocumento)
            {
                try
                {
                    loControlDynamic._Documento = toDocumento;
                }
                catch (Exception loEx)
                {
                    if (Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_prueva")) || System.Diagnostics.Debugger.IsAttached)
                        this._MessageBox("Se ha producido la siguiente incidencia en la asignación del documento al control " + toControl.Name + ": " + Environment.NewLine + Environment.NewLine + loEx.Message, MessageBoxButtons.OK, MessageBoxIcon.Exclamation, MessageBoxDefaultButton.Button1, DialogResult.OK);
                }
            }

            ControlDocumentoRecursive(toControl, toDocumento, tlChild);
        }

        /// <summary>
        /// Añadimos una addon en la página de en un ewtabcontrol
        /// </summary>
        /// <param name="toControl"></param>
        /// <param name="toControlContenedor"></param>
        /// <returns></returns>
        private bool AddonInsertarTabDocAddon(Control toControl, ref Control toControlContenedor)
        {
            bool llOk = false;
            ewtabcontrol loewtabcontrol = null;

            foreach (Control loControl in Controls) // De momento no es necesario realizarlo recursivamente
            {
                if (loControl is ewtabcontrol)
                {
                    loewtabcontrol = (ewtabcontrol)loControl;
                    break;
                }
            }

            if (loewtabcontrol != null)
            {
                Control loPagina = AddonNuevaPaginaTabDoc(toControl, loewtabcontrol);

                ewFlowLayoutPanel loewFlowLayoutPanel = this.AddonNuevoFlowLayoutPanel();
                loewFlowLayoutPanel.Size = loewtabcontrol.TabPages[0].Size; // Asignamos las dimensiones de la primera página
                loewFlowLayoutPanel.Dock = DockStyle.Fill;
                loPagina.Controls.Add(loewFlowLayoutPanel);  // Agregamos el flowlayout a la página para la gestión de las barras
                loPagina.Dock = DockStyle.Fill;

                toControlContenedor = loewFlowLayoutPanel; // Agregaremos el addon en el flowlayout de la página, por tanto actualizamos el controlContenedor

                llOk = true;
            }

            return llOk;
        }

        /// <summary>
        /// Instanciación de un "ewFlowLayoutPanel" que para que presenta las barras de desplazamiento si no cabe la totalidad del control que se pueda añadir
        /// </summary>
        /// <returns>Devuelve un "ewFlowLayoutPanel" para añadirlo en la página</returns>
        private ewFlowLayoutPanel AddonNuevoFlowLayoutPanel()
        {
            ewFlowLayoutPanel loewFlowLayoutPanel = new ewFlowLayoutPanel();

            loewFlowLayoutPanel.AutoScroll = true;
            loewFlowLayoutPanel.WrapContents = true;

            //if llResizeAddon
            // loewFlowLayoutPanel.Dock = System.Windows.Forms.DockStyle.Fill; // MEJORA: _Resize: Si nos interesa que el usuario gestiona el resize
            // loewFlowLayoutPanel.Size = toControl.Size; // Asignamos las dimensiones del control

            return loewFlowLayoutPanel;
        }

        /// <summary>
        /// Obtener el nombre de una página
        /// </summary>
        /// <param name="toewtabcontrol"></param>
        /// <returns></returns>
        private string AddonNombrePagina(ewtabcontrol toewtabcontrol)
        {
            string lcName = string.Empty;

            lcName = "AddonPagina" + Convert.ToString(toewtabcontrol.TabPages.Count);

            return lcName;
        }

        /// <summary>
        /// Añadimos una nueva página en un tabcontrol
        /// </summary>
        /// <param name="toControl"></param>
        /// <param name="toewtabcontrol"></param>
        /// <returns></returns>
        private Control AddonNuevaPaginaTabDoc(Control toControl, ewtabcontrol toewtabcontrol)
        {
            Control loControlewTabPage = null;
            string lcewtabcontrol = toewtabcontrol.Name, lcTitulo = string.Empty, lcName = string.Empty;
            IAddonTabDoc loIAddonTabDoc = (IAddonTabDoc)toControl;

            loControlewTabPage = new ewTabPage();

            lcName = toControl.Name;

            if (string.IsNullOrWhiteSpace(lcName))
                lcName = AddonNombrePagina(toewtabcontrol);

            loControlewTabPage.Name = lcName;
            loControlewTabPage.Text = loIAddonTabDoc._TituloPagina; // Indicamos el título de la página

            toewtabcontrol.Controls.Add(loControlewTabPage);

            if (loIAddonTabDoc._Principal) // Añadimos el tabpage como página principal
            {
                ewTabPage loewTabPage = (ewTabPage)loControlewTabPage;

                CambiarIndiceTabpage(toewtabcontrol, loewTabPage, 0);
            }

            return loControlewTabPage;
        }

        /// <summary>
        /// Reordenamos las páginas
        /// </summary>
        /// <param name="toewtabcontrol"></param>
        /// <param name="toewTabPage"></param>
        /// <param name="tnNuevoIndice"></param>
        private void CambiarIndiceTabpage(ewtabcontrol toewtabcontrol, ewTabPage toewTabPage, int tnNuevoIndice)
        {
            ewTabPage loewTabPage;

            int lnIndiceTabPage = toewtabcontrol.TabPages.IndexOf(toewTabPage); // Buscamos el índice de la página que hemos agregado

            for (int lnIndice = 0; lnIndice < lnIndiceTabPage; lnIndice++)
            {
                loewTabPage = (ewTabPage)toewtabcontrol.TabPages[0];

                toewtabcontrol.TabPages.Remove(loewTabPage);
                toewtabcontrol.TabPages.Add(loewTabPage);
            }

            // toewtabcontrol.TabPages.Insert(tnNuevoIndice, toewTabPage); // De momento como no funciona, hemos realizado el recorrido de las diferentes páginas
        }

        // FTask 111119 - 115209

        #region Ayuda contextual
        private bool _lFormActivated = true;
        private bool _lPresentandoAyuda = false;
        private BackgroundWorker _oBackgroundWorker;
        private FormPanelNotificaciones _oFormAyuda = null;

        /// <summary>
        /// Para guardar el título del formulario sin acrónimo ni sufijos
        /// </summary>
        private string _cTituloFormulario = "";

        /// <summary>
        /// Estructura para gestionar el resultado del BakcGroundWorker
        /// </summary>
        public struct oResultadoAyuda
        {
            /// <summary>
            /// Indica si ha de presentar la ayuda
            /// </summary>
            public bool _Ayuda
            {
                get { return _lAyuda; }
                set { _lAyuda = value; }
            }
            bool _lAyuda;

            /// <summary>
            /// Instancia de la ayuda contextual
            /// </summary>
            public IAyudaContextual _AyudaContextual
            {
                get { return _oAyudaContextual; }
                set { _oAyudaContextual = value; }
            }
            IAyudaContextual _oAyudaContextual;

            /// <summary>
            /// Instancia del OnBoardingController
            /// </summary>
            public IOnBoardingController _OnBoardingController
            {
                get { return _oOnBoardingController; }
                set { _oOnBoardingController = value; }
            }
            IOnBoardingController _oOnBoardingController;
        }

        /// <summary>
        /// Controlamos que tenemos la ayuda activa
        /// </summary>
        /// <returns></returns>
        private bool AyudaActiva()
        {

            if (Usuario._This._Opcesp("5004")) // No presentar ayuda en pantallas de Sage 50c
                return false;

            bool llActiva = true;

            object loObject = EW_GLOBAL._GetVariable("wl_DesactivarOnBoarding");

            if (loObject != null)
            {
                try
                {
                    llActiva = !Convert.ToBoolean(loObject); // Tendremos que "wl_DesactivarOnBoarding" es true por eso negamos
                }
                catch (Exception)
                {
                }
            }

            return llActiva;
        }

        /// <summary>
        /// Indica que la pantalla relacionada con la ayuda contextual / ayuda de Sage 50
        /// </summary>
        /// <returns></returns>
        protected virtual string _PantallaAyuda
        {
            get { return _Pantalla; }
        }

        /// <summary>
        /// Indica si ha de presentar el WalkTrought de la pantalla 0
        /// </summary>
        private bool _lPantalla0Showed = false;

        /// <summary>
        /// Marcamos que ya ha realizado el Login y no teniamos cargada aún la ayuda contextual al entrar la primera vez 
        /// </summary>
        private bool _lPantalla0ShowAfterLogin = false;

        /// <summary>
        /// Instanciación del BackgroundWorker de la ayuda contextual
        /// </summary>
        private void AyudaOnBoarding()
        {
            if (!IsDisposed && !Disposing )
            {
                if (BarrasAyudaActivas())
                {
                    if (string.IsNullOrWhiteSpace(_PantallaAyuda) || !AyudaActiva() || botonayuda == eAyudaContextual.Desactivada)
                    {
                        _FormSagePanel?._Show(_ButtonsSagePanel, this);
                    }
                    else
                    {
                        // Declaro un nuevo elemento
                        _oBackgroundWorker = new BackgroundWorker();
                        _oBackgroundWorker.WorkerSupportsCancellation = true;
                        _oBackgroundWorker.WorkerReportsProgress = false;

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

                        // Ejecución asíncrona
                        _oBackgroundWorker.RunWorkerAsync();
                    }
                }
            }
        }

        private bool BarrasAyudaActivas()
        {
            DataTable loDt = new DataTable();
            string lcDataBase, lcComunes, lcSql;

            if (!EW_GLOBAL._ContainsKey("wl_barras_ayuda_form"))
            {
                lcComunes = GrupoEmpresa._DbComunesRealGrupoPripal();
                lcDataBase = DB.SQLDatabaseReal(lcComunes, "VARIABLE");

                lcSql = $"SELECT VALOR FROM {lcDataBase} WHERE VARIABLE = 'NO_AYUDA' ";
                if(DB.SQLExec(lcSql, ref loDt)) EW_GLOBAL.ValorEnClave_VarGlob("wl_barras_ayuda_form", loDt.Rows.Count == 0);
            }

            return Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_barras_ayuda_form", true));
        }

        /// <summary>
        /// Método que define el proceso que se va a ejecutar en segundo plano de la ayuda contextual
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void _ExecuteRunWorkerAyuda(object sender, DoWorkEventArgs e)
        {
            oResultadoAyuda loResult = new oResultadoAyuda();
            loResult._Ayuda = false; // Asignamos el false por defecto

            try
            {
                IOnBoardingController loOnBoardingController = FUNCTIONS._OnBoardingController();

                if (loOnBoardingController != null && !loOnBoardingController._PlayingVideo)
                {
                    IAyudaContextual loAyudaContextual = new AyudaContextual(loOnBoardingController);
                    loAyudaContextual._Load(_PantallaAyuda.ToUpper());

                    if (loAyudaContextual != null && (loAyudaContextual._Categorias.Count > 0 || loAyudaContextual._NumeroTotalNoticias > 0))
                    {
                        loResult._OnBoardingController = loOnBoardingController;
                        loResult._AyudaContextual = loAyudaContextual;
                        loResult._Ayuda = true;
                    }
                }
            }
            catch (Exception loEx)
            {
                DB.Registrar_Error(loEx);
            }

            e.Result = loResult; // Asignamos el retorno
        }

        /// <summary>
        /// Método que se ejecutará al finalizar el proceso de consulta de la ayuda contextual
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void _RunWorkerCompletedAyuda(object sender, RunWorkerCompletedEventArgs e)
        {
            if (!e.Cancelled && e.Error == null &&!FormDisposed()) // Si no he sido cancelado ni he registrado excepción 
            {
                _oResultadoAyuda = ((oResultadoAyuda)e.Result);

                if (_oResultadoAyuda._Ayuda)
                    _BotonAyuda = eAyudaContextual.Si;

                //CambiarBotonAyudaMensaje();

                if (PresentarAyudaNuevasNoticias(_oResultadoAyuda))
                {
                    if (EsPantalla0)
                    {
                        _oResultadoAyuda._Ayuda = true;

                        if (_lPantalla0ShowAfterLogin && !_lPantalla0Showed && Ayuda_FormularioActivo()) // Si ha entrado el Usuario y no ha presentado aún el WalkTrought, ahora lo presentamos si no hay ninguna pantalla abierta
                            _WalkthroughsPantalla0();
                    }
                    //else
                    //    MostrarAyuda(_oResultadoAyuda._AyudaContextual);
                }

                _FormSagePanel?._Show(_ButtonsSagePanel, this);
            }
        }

        /// <summary>
        /// Controlamos si es necesario presentar las noticias relacionadas con la pantalla
        /// Tenemos dos casos:
        /// 
        /// 1. Si tenemos activada la ayuda y tenemos noticias
        /// 2. Existe alguna noticia nueva. La presentamos igualmente
        /// </summary>
        /// <param name="toResultadoAyuda"></param>
        /// <returns></returns>
        private bool PresentarAyudaNuevasNoticias(oResultadoAyuda toResultadoAyuda)
        {

            // Si la pantalla no tiene ayuda podemos salir
            if (!_oResultadoAyuda._Ayuda) 
                return false;

            // Tenemos activada la ayuda
            if ( _oResultadoAyuda._AyudaContextual._PresentacionAyuda != Presentacion.No)
                return true;

            // Existe alguna noticia nueva a partir de la fecha que el usuario marcó no volver a presentar la ayuda
            if (_oResultadoAyuda._AyudaContextual._NoticiasNuevasPendientesLeer > 0)
                return true;

            return false;
        }

        /// <summary>
        /// Devuelve si es la pantalla 0 donde presentaremos el formulario frmWalktrhoughs si es necesario
        /// </summary>
        private bool EsPantalla0
        {
            get { return _PantallaAyuda == "PANTALLA0"; }
        }

        /// <summary>
        /// Presentamos la pantalla de los Walktrhough si es necesario
        /// </summary>
        /// <returns></returns>
        protected bool _WalkthroughsPantalla0()
        {
            _lPantalla0ShowAfterLogin = true; // Marcamos que ya ha pasado por el AfterLogin que es el único lugar de donde se realiza la llamada

            if (EsPantalla0 && !FUNCTIONS._CanUseWebView()) // No presentamos mensaje, validamos si tenemos el RunTime del WebView2 independientemente de que tengamos o no información de la pantalla 0
                return false;

            if (_oResultadoAyuda._Ayuda == false || !EsPantalla0 || _lPantalla0Showed)
                return false;

            _lPantalla0Showed = true; // De momento marcamos que ya se ha visto o podrian salir dos instancias

            IOnBoardingController loOnBoardingController = FUNCTIONS._OnBoardingController();

            if (loOnBoardingController != null)
            {
                _lPantalla0Showed = ((OnBoardingControllerSage50)loOnBoardingController)._ShowWalkthroughs(_oResultadoAyuda._AyudaContextual);

                return _lPantalla0Showed;
            }
            else
                return false;
        }

        /// <summary>
        /// Calculamos la posición del formulario de ayuda del OnBoarding
        /// </summary>
        /// <param name="toRectangle">Rectangle del formualrio de ayuda</param>
        /// <returns></returns>
        private Point CalculateLocationAyuda(Rectangle toRectangle)
        {
            Rectangle loRectScreen = Screen.PrimaryScreen.WorkingArea;
            Point loPoint = toRectangle.Location;
            int lnOffsetX = 20, lnOffsetY = 50;

            if (Location.X < 0) // Tenemos pantallas como los mantenimientos o perfiles donde el formulario se presenta en una posición fuera de la area visible
            {
                loPoint.X = (loRectScreen.Width / 2) + (Size.Width / 2) - lnOffsetX;
                loPoint.Y = (loRectScreen.Height / 2) - (Size.Height / 2) + lnOffsetY;
            }
            else
            {
                loPoint.X = Location.X + Size.Width - lnOffsetX;
                loPoint.Y = Location.Y + lnOffsetY;
            }

            if (loPoint.X + toRectangle.Size.Width > loRectScreen.Width)
                loPoint.X = loRectScreen.Width - lnOffsetX - toRectangle.Width;

            if (loPoint.Y + toRectangle.Size.Height > loRectScreen.Height)
                loPoint.Y = (loRectScreen.Height / 2) - (toRectangle.Height / 2);

            return loPoint;
        }

        /// <summary>
        /// Posicionaremos la pantalla donde el usuario la dejó previamente
        /// Controlamos que sea en una area visible
        /// </summary>
        /// <param name="toAyudaContextual">Referencia a la ayuda contextual</param>
        private void LocationAyuda(IAyudaContextual toAyudaContextual)
        {
            Point loPoint = new Point(toAyudaContextual._Left, toAyudaContextual._Top);

            if (loPoint == new Point(0, 0) ||
                loPoint.X > Screen.PrimaryScreen.Bounds.Size.Width || loPoint.Y > Screen.PrimaryScreen.Bounds.Size.Height)
            {
                loPoint = CalculateLocationAyuda(_oFormAyuda.Bounds);
            }

            if (toAyudaContextual._Height > 0)
            {
                Size loSize = _oFormAyuda.Size;
                loSize.Height = toAyudaContextual._Height;

                if (_oFormAyuda.Size != loSize)
                    _oFormAyuda.Size = loSize;
            }

            _oFormAyuda.Location = loPoint;
        }

        /// <summary>
        /// Controlamos si el formulario se está destruyendo
        /// </summary>
        /// <returns></returns>
        protected virtual bool FormDisposed()
        {
            return (IsDisposed || Disposing);
        }

        private void CambiarBotonAyudaMensaje()
        {
            if (!EsPantalla0 && _oResultadoAyuda._AyudaContextual != null && !FormDisposed())
            {
                int numnoticias = _oResultadoAyuda._AyudaContextual._NoticiasPendientesLeer;

                if(menu is IActiveMenu)
                {
                    foreach (ActiveButton item in menu.Items)
                    {
                       
                        if (item.Name == "Ayuda")
                        {
                            // NOTICIAS ONBOARDING. Si tenemos noticias, sustituimos icono de Info por la Campana 
                            if (numnoticias > 0)
                            {
                                string lcTooltip = " Noticias";                                                                
                                item.ForeColor = Color.FromArgb(0, 129, 70);
                                item.Font = new Font("Segoe UI", 8.5F);                                
                                item._ModColors = false;

                                if (numnoticias == 1)
                                {
                                    item.Text = "1";
                                    lcTooltip = " Noticia";
                                }
                                else if (numnoticias < 100)
                                    item.Text = numnoticias.ToString().Trim();
                                else
                                    item.Text = "99+";

                                item.Image = sage.ew.images.Properties.Resources.bell_green_16;
                                menu.ToolTip.SetToolTip(item, item.Text+lcTooltip);
                                item.ChangeColors(); 
                            }

                            break;
                        }
                    }
                }
            }
        }

        /// <summary>
        /// Gestión de la presentación del formulario de configuración de usabilidad
        /// </summary>
        private void MostrarCfgUsabilidad()
        {
            // En el formulario de configuración se comprueba si hay mensajes configurados en el formulario/usuario actual
            // y se muestra mensaje sino hay y se cierra.
            frmUserFormConfig frmCfg = new frmUserFormConfig(Usuario._This._Codigo, this._Pantalla, this._ObtenerText(false));
            frmCfg._ShowDialog();
        }

        /// <summary>
        /// Gestión de la presentación de la ayuda contextual
        /// </summary>
        /// <param name="toAyudaContextual">Instancia de la ayuda contextual cuando venimos del BackGroundWordker</param>
        private void MostrarAyuda(IAyudaContextual toAyudaContextual = null)
        {
            if (_oFormAyuda != null && !_oFormAyuda.IsDisposed && !_oFormAyuda.Disposing)
            {
                ShowAyuda();
                return;
            }

            if (FormDisposed())
                return;

            IOnBoardingController loOnBoardingController = FUNCTIONS._OnBoardingController();

            if (toAyudaContextual == null) // Venimos del botón de opciones. Se ha de instanciar la ayuda contextual
            {
                toAyudaContextual = new AyudaContextual(loOnBoardingController);
                toAyudaContextual._Load(_Pantalla.ToUpper());

                ((OnBoardingControllerSage50)loOnBoardingController)._WebService("mostrar", tcPantalla: _Pantalla.ToUpper()); // Acción de mostrar ayuda
            }

            if (FormDisposed())
                return;

            _oFormAyuda = new FormPanelNotificaciones(_Pantalla.ToUpper(), Text, loOnBoardingCont³nDeFavoritosToolStripMenuItem,
            this.gestiÃnDeAccesosToolStripMenuItem,
            this.crearAccesoDirectoToolStripMenuItem,
            this.crearTareaProgramadaItem,
            this.crearApunteCalendarioItem,
            this.listadosPersonalizablesEditarItem,
            this.listadosPersonalizablesDuplicarItem,
            this.ayudaPantallaToolStripMenuItem,
            this.ShowPropertiesToolStripMenuItem});
            this.contextMenuStripPantalla.Name = "contextMenuStripPantalla";
            this.contextMenuStripPantalla.Size = new System.Drawing.Size(289, 230);
            // 
            // configuracionesUsuarioItem
            // 
            this.configuracionesUsuarioItem.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] {
            this.toolConfiguracionesToolStripMenuItem});
            this.configuracionesUsuarioItem.Name = "configuracionesUsuarioItem";
            this.configuracionesUsuarioItem.Size = new System.Drawing.Size(288, 22);
            this.configuracionesUsuarioItem.Text = "Configuraciones de usuario";
            // 
            // toolConfiguracionesToolStripMenuItem
            // 
            this.toolConfiguracionesToolStripMenuItem.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.toolConfiguracionesToolStripMenuItem.Name = "toolConfiguracionesToolStripMenuItem";
            this.toolConfiguracionesToolStripMenuItem.Size = new System.Drawing.Size(221, 22);
            this.toolConfiguracionesToolStripMenuItem.Text = "Diseñador configuraciones";
            // 
            // configuracionesUsuarioItemSeparator
            // 
            this.configuracionesUsuarioItemSeparator.Name = "configuracionesUsuarioItemSeparator";
            this.configuracionesUsuarioItemSeparator.Size = new System.Drawing.Size(285, 6);
            // 
            // nombreFormularioToolStripMenuItem
            // 
            this.nombreFormularioToolStripMenuItem.Name = "nombreFormularioToolStripMenuItem";
            this.nombreFormularioToolStripMenuItem.Size = new System.Drawing.Size(288, 22);
            this.nombreFormularioToolStripMenuItem.Text = "Nombre del formulario";
            // 
            // ShowPropertiesToolStripMenuItem
            // 
            this.ShowPropertiesToolStripMenuItem.Name = "ShowPropertiesToolStripMenuItem";
            this.ShowPropertiesToolStripMenuItem.Size = new System.Drawing.Size(288, 22);
            this.ShowPropertiesToolStripMenuItem.Text = "Mostrar propiedades controles";
            // 
            // gestiónDeFavoritosToolStripMenuItem
            // 
            this.gestiónDeFavoritosToolStripMenuItem.Name = "gestiónDeFavoritosToolStripMenuItem";
            this.gestiónDeFavoritosToolStripMenuItem.Size = new System.Drawing.Size(288, 22);
            this.gestiónDeFavoritosToolStripMenuItem.Text = "Gestión de favoritos";
            // 
            // gestiónDeAccesosToolStripMenuItem
            // 
            this.gestiónDeAccesosToolStripMenuItem.Name = "gestiónDeAccesosToolStripMenuItem";
            this.gestiónDeAccesosToolStripMenuItem.Size = new System.Drawing.Size(288, 22);
            this.gestiónDeAccesosToolStripMenuItem.Text = "Gestión de accesos";
            // 
            // crearAccesoDirectoToolStripMenuItem
            // 
            this.crearAccesoDirectoToolStripMenuItem.Name = "crearAccesoDirectoToolStripMenuItem";
            this.crearAccesoDirectoToolStripMenuItem.Size = new System.Drawing.Size(288, 22);
            this.crearAccesoDirectoToolStripMenuItem.Text = "Crear acceso directo";
            // 
            // crearTareaProgramadaItem
            // 
            this.crearTareaProgramadaItem.Name = "crearTareaProgramadaItem";
            this.crearTareaProgramadaItem.Size = new System.Drawing.Size(288, 22);
            this.crearTareaProgramadaItem.Text = "Crear tarea programada";
            // 
            // crearApunteCalendarioItem
            // 
            this.crearApunteCalendarioItem.Name = "crearApunteCalendarioItem";
            this.crearApunteCalendarioItem.Size = new System.Drawing.Size(288, 22);
            this.crearApunteCalendarioItem.Text = "Nue&vo apunte calendario";
            // 
            // listadosPersonalizablesEditarItem
            // 
            this.listadosPersonalizablesEditarItem.Name = "listadosPersonalizablesEditarItem";
            this.listadosPersonalizablesEditarItem.Size = new System.Drawing.Size(288, 22);
            this.listadosPersonalizablesEditarItem.Text = "Editar el listado personalizable";
            // 
            // listadosPersonalizablesDuplicarItem
            // 
            this.listadosPersonalizablesDuplicarItem.Name = "listadosPersonalizablesDuplicarItem";
            this.listadosPersonalizablesDuplicarItem.Size = new System.Drawing.Size(288, 22);
            this.listadosPersonalizablesDuplicarItem.Text = "Duplicar y editar el listado personalizable";
            // 
            // ayudaPantallaToolStripMenuItem
            // 
            this.ayudaPantallaToolStripMenuItem.Name = "ayudaPantallaToolStripMenuItem";
            this.ayudaPantallaToolStripMenuItem.Size = new System.Drawing.Size(288, 22);
            this.ayudaPantallaToolStripMenuItem.Text = "Ayuda";
            // 
            // _MenuContext_Opciones
            // 
            this._MenuContext_Opciones.Font = new System.Drawing.Font("Segoe UI", 9.5F);
            this._MenuContext_Opciones.Name = "ewcontextmenustripOpcProc";
            this._MenuContext_Opciones.Size = new System.Drawing.Size(61, 4);
            // 
            // FormBase
            // 
            this.ClientSize = new System.Drawing.Size(284, 262);
            this.KeyPreview = true;
            this.Name = "FormBase";
            this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen;
            ((System.ComponentModel.ISupportInitialize)(this._oErrorProvider)).EndInit();
            this.contextMenuStripPantalla.ResumeLayout(false);
            this.ResumeLayout(false);

        }
        
        /// <summary>
        /// Devuelve una lista de los controles del tipo especificado
        /// Si no pasamos ningún control lo busca en todo el formulario
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="toControl"></param>       
        /// <returns></returns>
        public List<T> _FindControl<T>(Control toControl = null)
        {
            if (toControl == null)
                toControl = this;

            List<T> lstControls = new List<T>();

            lstControls = AllControls(toControl).OfType<T>().ToList();

            return lstControls;
        }

        /// <summary>
        /// Devuelve todos los controles
        /// </summary>
        /// <param name="container"></param>
        /// <returns></returns>
        private IEnumerable<Control> AllControls(Control container)
        {
            foreach (Control control in container.Controls)
            {
                yield return control;

                foreach (var innerControl in AllControls(control))
                    yield return innerControl;
            }
        }

        
        /// <summary>
        /// Capturamos el metodo para capturar los posibles mensajes enviados desde Eurowin (VFP)
        /// </summary>
        /// <param name="msgEW"></param>
        protected override void WndProc(ref Message msgEW)
        {
            if (msgEW.Msg != WM_SYSCOMMAND  || (msgEW.Msg == WM_SYSCOMMAND && ( _ExecuteCommandBefore == null || _ExecuteCommandBefore.Invoke(this, msgEW.WParam))))
            {
                base.WndProc(ref msgEW);

                if (EW_GLOBAL._EsEjecutable)
                {
                    //TODO: Temporal hasta que veamos que pasa realmente
                    if (!System.Diagnostics.Debugger.IsAttached && !NETVFP._ReceiveMessageFromVfp(ref msgEW))
                        return;
                }
            }
        }
        
        /// <summary>        
        /// PE-77741
        /// Evento para realizar las mismas comprobaciones que en el método análogo de la pantalla de fox 
        /// En los distintos formularios de .net donde se quiera realizar este control, habrá que sobreescribir este evento 
        /// teniendo en cuenta que el objeto "taParams" es un array de objetos con los mismos parámetros y valores que en el
        /// formulario equivalente de fox.
        /// </summary>
        /// <param name="taParams"></param>
        /// <returns></returns>
        public virtual bool _Init(object[] taParams)
        {
            if (taParams.Count() > 0)
            {
                _lAutomatico = true; //Bug 206971: Para poder saber en el formbase si estamos en una tarea programada
            }
            return true;
        }
        // FI PE-77741

        /// <summary>
        /// Método virtual que se invoca siempre que se muestra un formulario.
        /// Nos sirve para recuperar los parametros del acceso directo.
        /// </summary>
        /// <param name="taParams">Parametros de inicio</param>
        public virtual bool _InitAccesoDirecto(object[] taParams)
        {
            // Obtención de los parámetros según pantalla
            if (taParams != null && taParams.Length > 0)
            {
                foreach (object loItem in taParams)
                {
                    //Si trobem un parametre que començi per "idparam:" es que tenin propietats guardades a COMUNES!ACDIRPARAM
                    if (loItem.ToString().StartsWith(FUNCTIONS._AccesoDirectoParametro))
                    {
                        //Recuperem les propietats que mes tard asignarem al OnShown
                        return FUNCTIONS._RecuperarParametrosAccesoDirecto(loItem.ToString(), ref this._ValoresAccesoDirecto);
                    }
                }
            }
            return false;
        }

        /// <summary>
        /// Método virtual genérico para asignar los valores de los parametros de acceso directo en los controls del formulario a partir de la propiedad _ValoresAccesoDirecto.
        /// Se llama en el OnShown del formulario. Si se añade logica al OnShown del formulario hijo, recordar hacer la llamada al padre (base.OnShown())
        /// al finalizar la asignación de valores en los controles del propio formulario, así evitaremos que los parametros del A.D. se machaquen con los nuestros
        /// </summary>
        public virtual bool _EstablecerParametrosFormulario()
        {
            if (DesignMode)
                return true;

            bool llOk = false;
            if (this._ValoresAccesoDirecto.Count > 0)
            {
                string lcControl = "", lcPropiedad = "";
                object lcValor = "";
                foreach (KeyValuePair<string, object> loItem in this._ValoresAccesoDirecto)
                {
                    //La key estara composada del "nom_control:propietat_a_definir"
                    //El value contindra el valor de la propietat
                    if (loItem.Key.Contains(":"))
                    {
                        lcControl = loItem.Key.Substring(0, loItem.Key.IndexOf(":"));
                        lcPropiedad = loItem.Key.Substring(loItem.Key.IndexOf(":") + 1);
                        lcValor = loItem.Value;
                        //Recuperamos el control del formulario
                        Control loControl = this.__FindControlRecursive(lcControl);
                        if (loControl != null)
                        {
                            //Recuperamos la propiedad del Control
                            Type myType = loControl.GetType();
                            PropertyInfo myPropInfo = myType.GetProperty(lcPropiedad);
                            if (myPropInfo != null)
                            {
                                if (loControl is txtFiltroBase)
                                {
                                    llOk = true;
                                    if (lcPropiedad == "_Desde")
                                        (loControl as txtFiltroBase)._oFiltroDesde._Codigo = Convert.ToString(lcValor);
                                    else if (lcPropiedad == "_Hasta")
                                        (loControl as txtFiltroBase)._oFiltroHasta._Codigo = Convert.ToString(lcValor);
                                    else if (lcPropiedad == "_Todos")
                                        (loControl as txtFiltroBase)._Todos = Convert.ToBoolean(lcValor);
                                    else if (lcPropiedad == "_Lista")
                                        (loControl as txtFiltroBase)._Lista = new List<string>(lcValor.ToString().Split(','));
                                }
                                else
                                {
                                    //Tratamiento de valores
                                    object lcRealValue = lcValor;
                                    if (loControl is ewcombobox && lcPropiedad.ToLower() == "selectedindex")
                                        lcRealValue = Convert.ToInt32(lcRealValue);
                                    else if ((loControl is ewcheckbox || loControl is ewradiobutton) && lcPropiedad.ToLower() == "checked")
                                        lcRealValue = Convert.ToBoolean(lcRealValue);

                                    //Establecemos el valor a la propiedad
                                    try
                                    {
                                        myPropInfo.SetValue(loControl, lcRealValue, null);
                                        llOk = true;
                                    }
                                    catch (Exception)// loEx)
                                    {
                                        //TODO : Errores derivados de establecer propiedades con tipos que no corresponden?
                                        //loEx = loEx;
                                    }
                                }
                            }
                        }
                    }
                }
            }
            return llOk;
        }

        //PE-85758
        /// <summary>
        /// Método específico para disponer ShapeContainers
        /// </summary>
        /// <param name="toShapeContainer"></param>
        protected void _DisposeShapeContainer(Microsoft.VisualBasic.PowerPacks.ShapeContainer toShapeContainer)
        {
            if (toShapeContainer != null && !toShapeContainer.IsDisposed)
            {
                if (toShapeContainer.Shapes != null)
                {

                    List<Microsoft.VisualBasic.PowerPacks.Shape> llisShapes = new List<Microsoft.VisualBasic.PowerPacks.Shape>();
                    foreach (Microsoft.VisualBasic.PowerPacks.Shape tshape in toShapeContainer.Shapes)
                    {
                        llisShapes.Add(tshape);
                    }
                    toShapeContainer.Shapes.Clear();
                    toShapeContainer.Shapes.Dispose();

                    foreach (Microsoft.VisualBasic.PowerPacks.Shape loShape in llisShapes)
                    {
                        loShape.Dispose();
                    }
                }
                toShapeContainer.Dispose();
            }
        }

        [DllImport("user32")]
        private static extern IntPtr GetWindowDC(IntPtr hwnd);

        /// <summary>
        /// Método para el control de errores mediante objetos de tipo ErrorProvider.
        /// Se muestra un icono de error junto al control, sin efecto Blink y 
        /// con el icono alineado al centro de la parte izquierda del control.
        /// => Es equivalente a _oErrorProvider.SetError(NombreControl, TextoError) pero alineando al icono
        /// Para liberar al control del error basta con repetir la llamada al método pero con el texto de 
        /// error en blanco.
        /// </summary>
        /// <param name="toControl">Control sobre el que se va a establecer un icono de error.</param>
        /// <param name="tcMensaje">Mensaje de error. Si esta en blanco libera el control de la notificación de error</param>
        /// <param name="toAlineamiento">Alineamiento de la imagen</param>
        public virtual void _ControlError(Control toControl, string tcMensaje, ErrorIconAlignment toAlineamiento = ErrorIconAlignment.MiddleLeft)
        {
            _oErrorProvider.BlinkStyle = ErrorBlinkStyle.NeverBlink;
            _oErrorProvider.SetIconAlignment(toControl, toAlineamiento); // PARTE 93189. Se ha añadido el parámetro para poder pasarle la alineación
            _oErrorProvider.SetError(toControl, tcMensaje);

            // PE-92786. Obtener si ya hay algun error y concatenarlo
            string lcError = "";
            if (!string.IsNullOrWhiteSpace(tcMensaje))
            {
                lcError = this._oErrorProvider.GetError(this);
                lcError += (!string.IsNullOrWhiteSpace(lcError) ? Environment.NewLine : string.Empty) + tcMensaje;
                //if (toControl is IValidationControl)
                //{
                //    ((IValidationControl)toControl)._ErrorValidation = true;
                //}
            }
            //else
            //{
            //    if (toControl is IValidationControl)
            //    {
            //        ((IValidationControl)toControl)._ErrorValidation = false;
            //    }
            //}
        }


        /// <summary>
        /// PE92638
        /// Fa el ShowDialog però abans comprova l'accès al formulari
        /// </summary>
        public virtual void _ShowDialog()
        {
            if(CanShow()) ShowDialog();
        }

        /// <summary>
        /// PE92638
        /// Fa el Show però abans comprova l'accès al formulari
        /// </summary>
        public virtual void _Show()
        {
            if (CanShow()) Show();
        }

        private bool CanShow()
        {
            if (this._NivelAcceso != _TiposAccesosPantalla.Denegado && !this.IsDisposed) //T114218
            {
                if (_SaveReuseFormSettings && Usuario._This._PosicionFormulario)
                {
                    using (FormManagerProperties loFormManagerProperties = new FormManagerProperties(this))
                    {
                        _ReusingFormSettings = loFormManagerProperties._SetProperties();
                    }
                }

                return true;
            }

            return false;
        }

       

        private List<IButtonBarraHerram> _oListButtonsSagePanel = null;
        
        /// <summary>
        /// Lista de botones para el panel Sage50
        /// </summary>
        internal List<IButtonBarraHerram> _ButtonsSagePanel
        {
            get 
            {
                List<IButtonBarraHerram> loListButtonsAddons;

                if ( _oListButtonsSagePanel == null )
                {
                    _oListButtonsSagePanel = new List<IButtonBarraHerram>();

                    //Si la ayuda esta activa y hay ayuda o noticias
                    if(AyudaActiva() && _oResultadoAyuda._Ayuda) _oListButtonsSagePanel.Add(new AyudaNoticiasPantalla(this, _oResultadoAyuda));
                    
                    _oListButtonsSagePanel.Add(new AyudaPantalla(this));
                    _oListButtonsSagePanel.Add(new OpcionesPantalla(this));

                    // Comprobar si hay que mostrar la opción de configuración de mensajes por usuario/pantalla
                    if (_messageBoxAutomatic)
                        _oListButtonsSagePanel.Add(new CfgUsabilidad(this));

                    loListButtonsAddons = AddonsController.Instance.Methods.BindFormBarraHerram(_Pantalla);
                    if (loListButtonsAddons is List<IButtonBarraHerram> && loListButtonsAddons.Count > 0) _oListButtonsSagePanel.AddRange(loListButtonsAddons);
                }

                return _oListButtonsSagePanel;
            }
        }
        
        /// <summary>
        /// PE-87849: Mostrar formulario de accesos mediante el usuario actual        
        /// </summary>
        protected virtual void _Show_Accesos()
        {
            _Show_Accesos(_Pantalla);
        }

        /// <summary>
        /// Mostrar formulario de accesos mediante el usuario actual, para un formulario específico
        /// </summary>
        /// <param name="lcPantalla"></param>
        protected void _Show_Accesos(String lcPantalla)
        {
            // PE-92757. Usamos usuario estático
            if (!Usuario._This._Show_Gestion_Accesos(lcPantalla, _EliminarAcronimo(this.Text)))   //PE-90297: pasamos el título de la pantalla también por si no existe en los accesos añadirlo
            {
                _MessageBox("El usuario activo no tiene permisos para gestionar accesos a pantallas.", MessageBoxButtons.OK, MessageBoxIcon.Stop, MessageBoxDefaultButton.Button1, DialogResult.OK);
            }
        }

        /// <summary>
        /// PE-87840: Mostrar formulario de favoritos mediante el usuario actual        
        /// </summary>
        protected void _Show_Favoritos()
        {
            // PE-92757. Usamos usuario estático
            Usuario._This._Show_Favoritos(this._Pantalla, _EliminarAcronimo(this.Text));   //PE-92094: pasamos el título de la pantalla también, igual que en los accesos
        }

        /// <summary>
        /// PE-86720: mostrar la gestión de favoritos
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void gestiónDeFavoritosToolStripMenuItem_Click(object sender, EventArgs e)
        {
            this._Show_Favoritos();
        }

        /// <summary>
        /// PE-86720: mostrar la gestión de accesos
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void gestiónDeAccesosToolStripMenuItem_Click(object sender, EventArgs e)
        {
            this._Show_Accesos();
        }

        /// <summary>
        /// Crear acceso directo al formulario
        /// PE-95995
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void crearAccesoDirectoToolStripMenuItem_Click(object sender, EventArgs e)
        {
            this._AsignarValoresAccesoDirecto();
            //Creem el acces directe
            sage.ew.functions.FUNCTIONS._CrearAccesoDirecto(_EliminarAcronimo(this.Text), this._Pantalla.Trim(), this._ValoresAccesoDirecto);
        }

        /// <summary>
        /// Método virtual que se invoca antes de crear el acceso directo y que nos servirá para definir 
        /// los parámetros que se guradaran para el acceso directo a esta pantalla.
        /// </summary>
        /// <returns></returns>
        public virtual bool _AsignarValoresAccesoDirecto()
        {
            return false;
        }

        //PE-96746
        /// <summary>
        /// Respuesta al click de crear apunte de calendario
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void crearApunteCalendarioItem_Click(object sender, EventArgs e)
        {
            functions.FUNCTIONS._CrearNuevoApunteCalendario(this, _Pantalla);
        }

        // PARTE 101745
        /// <summary>
        /// Respuesta al click de ayuda de la pantalla
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void ayudaPantallaToolStripMenuItem_Click(object sender, EventArgs e)
        {
            _MostrarAyudaPantalla();
        }

        /// <summary>
        /// Mostrar la ayuda de la pantalla
        /// </summary>
        public void _MostrarAyudaPantalla()
        {
            // Bug 154751. Mostrar o no la ayuda
            // _PantallaAyuda tiene el valor de _Pantalla inicialmente
            // De este modo podemos tener una pantalla sin gestión de accesos con la ayuda correspondiente
            if (_MostrarAyudaF1) FUNCTIONS._MostrarAyudaPantalla(this._PantallaAyuda);
        }
        // FPARTE 101745

        /// <summary>
        /// Task 104592: Evento para ejecutar la creación de tarea programada
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void crearTareaProgramadaItem_Click(object sender, EventArgs e)
        {
            _CrearTareaProgramada(this._Pantalla);
        }

        /// <summary>
        /// Evento para cargar una configuración de usuario/pantalla
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void ConfiguracionesUsuarioItem_Click(object sender, EventArgs e)
        {
            ConfigUserForm loConfig;

            // Guardar "Última configuración" antes de abrir el editor de configuraciones            
            //ConfigUserOptionsUpdateLastValues();

            FormBase loFormClon = this.Clone();
            loFormClon._ConfigUserForm = this._ConfigUserForm;
            loFormClon._ConfigUserOptionsEditing = true;

            loConfig = ConfigurationDesignManager.ShowInDesign(loFormClon, this._ConfigUserForm);

            if (loConfig is ConfigUserForm)
            {
                _ConfigUserForm = loConfig;
                _ConfigUserOptionsLoad(_ConfigUserForm._dicOpciones);
            }

            loFormClon.Close();
            loFormClon.Dispose();
            loFormClon = null;
        }

        #region Opciones de menu para listados personalizables

        /// <summary>
        /// Task 104592: Método virtual para crear una tarea programada (principalmente para el FormListado)
        /// </summary>
        /// <param name="tcPantalla"></param>
        protected virtual void _CrearTareaProgramada(string tcPantalla)
        {
        }


        /// <summary>
        /// Generar un nuevo listado personalizable a partir de un listado existente previamente
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void listadosPersonalizablesDuplicarItem_Click(object sender, EventArgs e)
        {
            this.Close();

            ListadosPersonalizables loList = new ListadosPersonalizables();
            if (!loList._DuplicarListado(this._Pantalla))
            {
                sage.ew.functions.FUNCTIONS._MessageBox(loList._Error_Message, this.Text, //"Informes personalizables"
                    MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1);
            }
        }

        /// <summary>
        /// Editar un listado personalizable previamente creado
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void listadosPersonalizablesEditarItem_Click(object sender, EventArgs e)
        {
            this.Close();

            ListadosPersonalizables loList = new ListadosPersonalizables();
            if (!loList._CargarListado(this._Pantalla))
            {
                sage.ew.functions.FUNCTIONS._MessageBox(loList._Error_Message, this.Text, //"Informes personalizables"
                    MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1);
            }
        }

        #endregion Opciones de menu para listados personalizables

        private void ShowPropertiesToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (Debugger.IsAttached)
            {
                if (_oTimerProperties is Timer)
                {
                    ShowPropertiesToolStripMenuItem.Text = "Mostrar propiedades controles";

                    _InfoToolTip.Active = false;

                    _oTimerProperties.Stop();
                    _oTimerProperties.Tick -= _oTimerProperties_Tick;
                    _oTimerProperties.Dispose();
                    _oTimerProperties = null;
                }
                else
                {
                    ShowPropertiesToolStripMenuItem.Text = "Ocultar propiedades controles";

                    _InfoToolTip.Active = true;

                    _oTimerProperties = new Timer();
                    _oTimerProperties.Tick += _oTimerProperties_Tick;
                    _oTimerProperties.Interval = 500;
                    _oTimerProperties.Start();
                }
            }
        }

        private void _oTimerProperties_Tick(object sender, EventArgs e)
        {
            Control loControl;
            Point loPos = Cursor.Position;

            if (Bounds.Contains(loPos))
            {
                loControl = _GetChild(loPos, this);

                if ((loControl is Control && string.IsNullOrEmpty(_ControlNameShowing)) || (loControl is Control && loControl.Name != _ControlNameShowing))
                {
                    _ControlNameShowing = _InfoToolTip._GetControl(loControl).Name;
                    _CreateTooltipInfo(loControl, loControl.DataBindings.Count > 0 ? loControl.Name : "");
                    if(!loControl.Enabled) _InfoToolTip.Show(loControl.Name, this, PointToClient(loPos));
                }
                else if(loControl == null && !string.IsNullOrEmpty(_ControlNameShowing))
                {
                    _InfoToolTip.Hide(this);
                    _ControlNameShowing = string.Empty;
                }
            }
            else
            {
                _ControlNameShowing = string.Empty;
            }
        }

        private void _CreateTooltipInfo(Control toControl, string tcText = "")
        {
            string lcText;

            lcText = string.IsNullOrEmpty(tcText) ? toControl.DataBindings.Count > 0 ? toControl.Name : "" : tcText;

            if (!string.IsNullOrEmpty(lcText)) _InfoToolTip._ControlToolTip(toControl, lcText);

            if (toControl.Controls.Count > 0)
            {
                foreach (Control loControl in toControl.Controls)
                {
                    lcText = string.IsNullOrEmpty(tcText) ? loControl.DataBindings.Count > 0 ? loControl.Name : "" : tcText;

                    if (!string.IsNullOrEmpty(lcText))
                    {
                        _InfoToolTip._ControlToolTip(loControl, lcText);
                    }

                    if (loControl.Controls.Count > 0)
                    {
                        _CreateTooltipInfo(loControl, lcText);
                    }
                }
            } 
        }

        private string _ControlNameShowing;

        /// <summary>
        /// Obtener un Control situado en un point
        /// </summary>
        /// <param name="toPoint"></param>
        /// <param name="toBase"></param>
        /// <returns></returns>
        public Control _GetChild(Point toPoint, Control toBase)
        {
            Control loControl = null;

            if(toBase is Control) loControl = toBase.GetChildAtPoint(toBase.PointToClient(toPoint), GetChildAtPointSkip.Invisible | GetChildAtPointSkip.Transparent);

           return loControl?.Controls.Count > 0 && loControl?.DataBindings.Count == 0? _GetChild(toPoint, loControl) : loControl;
        }
        
        /// <summary>
        /// Mostrar la información relevante de la pantalla que llama este método.
        /// Se presentara la siguiente información:
        /// - Titulo del formulario
        /// - Librearia en la que esta contenido
        /// - Nombre de la clase del formulario
        /// - Pantalla (en caso de que esta definida)
        /// En mantenimientos y documentos se presentara también la información de los addons que modifiquen el formulario:
        /// - Nombre del addon / Libreria que carga (Si esta o no firmada y por quien)
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void nombreFormularioToolStripMenuItem_Click(object sender, EventArgs e)
        {
            frmInfoFormul loFormul = new frmInfoFormul();

            //Cabecera Información
            loFormul.AddHeader("Información");

            //Titulo del formulario
            loFormul.AddLine("Título", _EliminarAcronimo(this.Text));

            //Libreria
            loFormul.AddLine("Librería", System.Reflection.Assembly.GetAssembly(this.GetType()).Location);

            //Clase
            loFormul.AddLine("Clase", this.GetType().Name);

            //Pantalla. Presentamos el valo de _PantallaAyuda
            if (!string.IsNullOrWhiteSpace(_PantallaAyuda))
                loFormul.AddLine("Pantalla", _PantallaAyuda.Trim().ToUpper());

            //S50MIG-3188 Añadir namespace
            loFormul.AddLine("Namespace", GetType().Namespace);

            //Addons
            Dictionary<string, object> loAddons = null;
            if (this is FormMante && (this as FormMante)._ewMante != null && (this as FormMante)._ewMante._Addons != null)
            {
                loAddons = (this as FormMante)._ewMante._Addons;
            }
            else if (this is frmGestionPerfil && (this as frmGestionPerfil)._Documento != null && (this as frmGestionPerfil)._Documento._Addons != null)
            {
                loAddons = (this as frmGestionPerfil)._Documento._Addons;
            }
            else if (this is FormListado && (this as FormListado)._Addons != null)
            {
                loAddons = (this as FormListado)._Addons;
            }

            if (loAddons != null && loAddons.Count > 0)
            {
                //Cabecera addons
                loFormul.AddHeader("Add-ons");
                //Info de addons
                string lcDllAddon = "", lcSubjectName = "";
                foreach (KeyValuePair<string, object> loItem in loAddons)
                {
                    try
                    {
                        // Obtenemos el objeto de extensiones y lo configuramos
                        //loExtension = (_ExtensionMante)loItem.Value;
                        string lcName = "", lcTmp = "";
                        if (AddonsController.Instance.AddonsManager.IsLoaded(loItem.Key))
                        {
                            //Ruta a la dll
                            lcDllAddon = (AddonsController.Instance.AddonsManager.GetAddon(loItem.Key) as IModulo)._Libreria + ".dll";
                            lcTmp = lcDllAddon;
                            //Qui la firma
                            lcSubjectName = FUNCTIONS.GetDllNameInfo(lcDllAddon);
                            if (!string.IsNullOrWhiteSpace(lcSubjectName))
                                lcTmp += " (" + lcSubjectName + ")";
                            else
                                lcTmp += " (Sin firmar)";
                            //Quin tipus es
                            int lnTipo = (AddonsController.Instance.AddonsManager.GetAddon(loItem.Key) as IModulo)._Tipo;
                            switch (lnTipo)
                            {
                                case 2:
                                    lcTmp += " - Extensión contratable";
                                    break;
                                case 3:
                                    lcTmp += " - Extensión personalizada";
                                    break;
                                case 1:
                                case 0:
                                default:
                                    lcTmp += " - Extensión incluida";
                                    break;
                            }
                            //Nom del addon a mostrar
                            lcName = (AddonsController.Instance.AddonsManager.GetAddon(loItem.Key) as IModulo)._Nombre2;
                            if (string.IsNullOrWhiteSpace(lcName))
                                lcName = loItem.Key;

                            //Afegim una linia per cada addon
                            loFormul.AddLine(lcName, lcTmp);
                        }
                    }
                    catch (Exception loError)
                    {
                        DB.Registrar_Error(loError);
                    }
                }
            }

            //Mostramos el formulario
            loFormul._ShowDialog();
        }

        /// <summary>
        /// Elimina el acronimo del texto
        /// </summary>
        /// <param name="toText"></param>
        /// <returns></returns>
        protected string _EliminarAcronimo(String toText)
        {
            String lcText = toText;

            if (!String.IsNullOrEmpty(_Acronimo)) lcText = lcText.Replace(_Acronimo, "");
            lcText = lcText.TrimStart();

            return lcText;
        }


        /// <summary>
        /// Respuesta al click de "Reordenar pantallas" (PE-120903)
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void reordenarPantallasToolStripMenuItem_Click(object sender, EventArgs e)
        {
            // PE-103085 
            //NETVFP._Reordenar_Pantallas(); 
            //NETVFP._Ejecutar_Funcion_VFP("fPripals50.Reordenar_pantallas");
        }

        private void contextMenuStripPantalla_Opening(object sender, CancelEventArgs e)
        {
            contextMenuStripPantalla.Items["gestiónDeFavoritosToolStripMenuItem"].Image = sage.ew.images.Properties.Resources.favorite_16;
            contextMenuStripPantalla.Items["gestiónDeAccesosToolStripMenuItem"].Image = sage.ew.images.Properties.Resources.access_16;
            contextMenuStripPantalla.Items["crearAccesoDirectoToolStripMenuItem"].Image = sage.ew.images.Properties.Resources.link_16;
            contextMenuStripPantalla.Items["crearTareaProgramadaItem"].Image = sage.ew.images.Properties.Resources.TimeProgram; //TODO: utilizar otro icono
            contextMenuStripPantalla.Items["ShowPropertiesToolStripMenuItem"].Image = _oTimerProperties is null ? Resources.led_green_16 : Resources.led_red_16;

            bool lbSage50 = Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_sage50"));

            //Acces directe sols per a Sage50
            if (!lbSage50)
                contextMenuStripPantalla.Items["crearAccesoDirectoToolStripMenuItem"].Visible = false;
            else
                contextMenuStripPantalla.Items["crearAccesoDirectoToolStripMenuItem"].Visible = _MostrarCrearAccesoDirecto;  // PE-99866. Comprobar si mostar el ménu crear acceos directos            

            //Task 104592: Crear tarea programada
            if (!lbSage50)
                contextMenuStripPantalla.Items["crearTareaProgramadaItem"].Visible = false;
            else
                contextMenuStripPantalla.Items["crearTareaProgramadaItem"].Visible = _MostrarCrearTareaProgramada;

            //PE-96746
            contextMenuStripPantalla.Items["crearApunteCalendarioItem"].Image = sage.ew.images.Properties.Resources.calendar_16;

            //PE-103520 : listados personalizables
            contextMenuStripPantalla.Items["listadosPersonalizablesEditarItem"].Image = sage.ew.images.Properties.Resources.mant_edit_16;
            contextMenuStripPantalla.Items["listadosPersonalizablesDuplicarItem"].Image = sage.ew.images.Properties.Resources.duplicate_16;


            if (this is sage.ew.formul.Forms.FormListado)
            {
                if (!((sage.ew.formul.Forms.FormListado)this)._Personalizado)
                {
                    contextMenuStripPantalla.Items["listadosPersonalizablesEditarItem"].Visible = false;
                    if (!lbSage50)
                    {
                        contextMenuStripPantalla.Items["listadosPersonalizablesDuplicarItem"].Visible = false;
                    }
                    else
                    {
                        contextMenuStripPantalla.Items["listadosPersonalizablesDuplicarItem"].Visible = _MostrarDuplicarListado;
                    }
                }
            }
            else
            {
                contextMenuStripPantalla.Items["listadosPersonalizablesEditarItem"].Visible = false;
                contextMenuStripPantalla.Items["listadosPersonalizablesDuplicarItem"].Visible = false;
            }

            ConfigureConfigUserOptions();

            //PE-104540 - PE-104527 : Amagar l'opció de "Duplicar y editar el listado personalizable"
            //contextMenuStripPantalla.Items["listadosPersonalizablesDuplicarItem"].Visible = false;
        }

        /// <summary>
        /// Preparar menú de Configuraciones de usuario
        /// </summary>
        private void ConfigureConfigUserOptions()
        {
            configuracionesUsuarioItem.Image = sage.ew.images.Properties.Resources.icon_wrench;

            if (Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_sage50")) && _ConfigUserOptionsAllowed)
            {
                // Guardar "Última configuración"
                //ConfigUserOptionsUpdateLastValues();

                configuracionesUsuarioItem.Visible = true;
                configuracionesUsuarioItemSeparator.Visible = true;
                configuracionesUsuarioItem.DropDownItems.Clear();

                configuracionesUsuarioItem.DropDownItems.Add(toolConfiguracionesToolStripMenuItem);

                // Mostrar configuraciones de usuario                
                IEnumerable<ConfigUserForm> loList = _ConfigUserForm._ListaConfiguraciones().AsEnumerable();
                IEnumerable<ConfigUserForm> loListConfUsers = loList.Where(f => f._Tipo == ConfigUserForm.ConfigUserType.UserValuesConfig);
                IEnumerable<ConfigUserForm> loListDefaultConfUsers = loList.Where(f => f._Tipo != ConfigUserForm.ConfigUserType.UserValuesConfig);

                // Mostrar configuraciones del usuario
                _GenerateMenuItemsConfigUser(loListConfUsers.Where(f => !f._Publico));
                // Mostrar configuraciones públicas
                _GenerateMenuItemsConfigUser(loListConfUsers.Where(f => f._Publico));
                // Mostrar configuraciones base
                _GenerateMenuItemsConfigUser(loListDefaultConfUsers);
            }
            else
            {
                configuracionesUsuarioItem.Visible = false;
                configuracionesUsuarioItemSeparator.Visible = false;
            }
        }

        private void _GenerateMenuItemsConfigUser(IEnumerable<ConfigUserForm> toListConfigUsers)
        {
            if (toListConfigUsers != null && toListConfigUsers.Count() > 0)
            {
                configuracionesUsuarioItem.DropDownItems.Add(new ToolStripSeparator());

                foreach (ConfigUserForm loConfig in toListConfigUsers)
                {
                    ToolStripMenuItem loMenuItem = new ToolStripMenuItem();

                    loMenuItem.Text = loConfig._Config;
                    loMenuItem.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
                    loMenuItem.Click += LoadConfigUserMenuItem_Click;
                    loMenuItem.Tag = loConfig;

                    if (_ConfigUserForm._Config.Trim() == loConfig._Config.Trim()) loMenuItem.Image = sage.ew.images.Properties.Resources.icon_right;

                    configuracionesUsuarioItem.DropDownItems.Add(loMenuItem);
                }
            }
        }

        /// <summary>
        /// Evento para cargar configuración de usuario/pantalla des del menú de opciones
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void LoadConfigUserMenuItem_Click(object sender, EventArgs e)
        {
            if (sender is ToolStripMenuItem && ((ToolStripMenuItem)sender).Tag is ConfigUserForm)
            {
                ConfigUserForm loConfig = ((ToolStripMenuItem)sender).Tag as ConfigUserForm;

                // Antes de cargar la nueva configuración, guardamos "Última configuración"
                //ConfigUserOptionsUpdateLastValues();

                // Cargar nueva configuración
                _ConfigUserForm = loConfig;
                _ConfigUserOptionsLoad(_oConfigUserForm._dicOpciones);
            }
        }

        /// <summary>
        /// PE-96746: Comprobamos si hay que mostrar o no el la opció de apunte de calendario
        /// </summary>
        /// <returns>True si es visible</returns>
        protected bool _PresentarApunteCalendario()
        {
            return sage.ew.functions.FUNCTIONS._PermitirApunteCalendario(_Pantalla);
        }

        #region Forzar Fuente

        /// <summary>
        /// Override OnShown
        /// </summary>
        /// <param name="e"></param>
        protected override void OnShown(EventArgs e)
        {
            base.OnShown(e);

            if (EW_GLOBAL._EsEjecutable && _CambiarFuente)
            {
                if (Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_sage50")))
                {
                    if (estiloRevisado == false)
                    {
                        foreach (Control loControl in Controls)
                        {
                            FUNCTIONS._Cambiar_Font(loControl, "Segoe UI");
                        }
                    }
                }
                else
                {
                    foreach (Control loControl in Controls)
                    {
                        FUNCTIONS._Cambiar_Font(loControl, "Arial");
                    }
                }
            }

            // Bug 111565. En caso de abrir un formulario en modo MODAL, no dejamos minimizarlo
            if (this.Modal)
                this.MinimizeBox = false;

            //Asignem els parametres del formulari suposant que en tingui
            this._EstablecerParametrosFormulario();
        }

        #endregion Forzar Fuente

        /// <summary>
        /// Lista de toolStripMenuItems privada que se utiliza para poder gestionar las opciones del botón de opciones
        /// </summary>
        protected List<ToolStripMenuItemBase> _ToolStripMenuItemsBase = new List<ToolStripMenuItemBase>();

        /// <summary>
        /// Nuevo ítems del menú de opciones
        /// 
        /// Añade el ítem a la lista lstToolStripMenuItemBase para su posterior personalización
        /// </summary>
        /// <param name="tcNombre">Text del toolStripIEtem</param>
        /// <param name="tcNombre_Objeto">Nombre del objeto</param>
        /// <param name="tcTooltip">Tooltip del toolStripIEtem</param>
        /// <returns></returns>
        protected internal ToolStripMenuItemBase _AddToolStripMenuItemBase(string tcNombre, string tcNombre_Objeto, string tcTooltip)
        {
            ToolStripMenuItemBase loToolStripMenuItem = new ToolStripMenuItemBase(tcNombre, tcNombre_Objeto, tcTooltip);

            _ToolStripMenuItemsBase.Add(loToolStripMenuItem);

            return loToolStripMenuItem;
        }

        /// <summary>
        /// Notificamos a los subscriptores por si desean realizar una configuración de las opciones a presentar
        /// 
        /// NOTA: únicamente operativo en los documentos de perfiles y asientos
        /// </summary>
        /// <param name="sender">Referencia al objeto de opciones</param>
        protected internal void _GetOpcionesInvoke(object sender)
        {
            if (this is frmGestionPerfil || this is contabilidad.frmAsientos || this is frmListasPrevias || this.Name == "frmPrincipal") 
                _GetOpciones?.Invoke(new EventArgsOpciones(sender, _ToolStripMenuItemsBase));
            else
                throw new Exception("Este formulario no tiene ningún botón de Opciones o no está preparado para acceder a él");
        }

        /// <summary>
        /// Notificamos a los subscriptores por si desean añadir opciones en el botón de herramientas
        /// </summary>
        /// <param name="sender">Referencia al ContextMenu de opciones del botón de herramientas</param>
        /// <param name="tlstToolStripMenuItemsBase">Lista de ToolStripMenuItemBase</param>
        private void GetOpcionesHerramientasInvoke(object sender , List<ToolStripMenuItemBase> tlstToolStripMenuItemsBase)
        {
           _GetOpcionesHerramientas?.Invoke(new EventArgsOpciones(sender, tlstToolStripMenuItemsBase));
        }

        // Task 111119 - 115209 
        /// <summary>
        /// Inserta un control a los formularios, actualmente solo implementado en el formulario de perfiles
        /// </summary>
        /// <param name="toControl">Control a añadir al formulario, ha de cumplir la interfaz IAddonTabDoc, IAddonBotonMenuDoc, ...</param>
        /// <returns>Devuelve si ha agregado el control al formulario</returns>
        public virtual bool _InsertarObjetoAddon(Control toControl)
        {
            bool lITabDocAddon = false, llOk = true;
            Control loControlContenedor = this; // Asignamos donde vamos a agregar los controles
            string lcNombre_Objeto = toControl.Name;

            lITabDocAddon = toControl is IAddonTabDoc;

            if (lITabDocAddon)
                llOk = AddonInsertarTabDocAddon(toControl, ref loControlContenedor);
            else if ((toControl is IAddonBotonMenuDoc) && (toControl is Button)) // Task 123210: Creación de botones en la barra de herramientas de los Mantes
                llOk = AddonBotonMenuDoc(toControl);

            if (llOk)
                loControlContenedor.Controls.Add(toControl);

            return llOk;
        }

        /// <summary>
        /// Inserta un sage.ew.botones.ToolStripButtonAddonMante a la barra de botones en los FormMante
        /// </summary>
        /// <param name="toolStripButtonAddonMante"></param>
        /// <returns></returns>
        public virtual bool _InsertarObjetoAddon(ToolStripItem toolStripButtonAddonMante)
        {
            return true;
        }

        /// <summary>
        /// Para agregar opciones mediante los Addons en los mantenimientos y en el formulario de asientos
        /// </summary>
        /// <param name="toMenuStrip"></param>
        protected internal virtual void _AddonPrepararMenu(ewcontextmenustrip toMenuStrip)
        {
            if (this.lstOpcionesMenuAddon != null && this.lstOpcionesMenuAddon.Count > 0)
            {
                string lcTituloMenu, lcName;
                bool llSeparador = true;

                foreach (Control loControl in this.lstOpcionesMenuAddon)
                {
                    lcTituloMenu = ((IAddonBotonMenuDoc)loControl)._TituloMenu.Trim();

                    if (llSeparador && toMenuStrip.Items.Count > 0) // Añadimos un separador
                    {
                        toMenuStrip.Items.Add("-");
                        llSeparador = false;
                    }

                    toMenuStrip.Items.Add(lcTituloMenu);

                    lcName = loControl.Name;

                    if (string.IsNullOrWhiteSpace(lcName)) // Si el botón no tiene nombre le voy a asignar uno. Luego se realizará una búsqueda por el nombre del control
                    {
                        lcName = Convert.ToString(Guid.NewGuid()).ToUpper();
                        loControl.Name = lcName;
                    }

                    toMenuStrip.Items[toMenuStrip.Items.Count - 1].Name = lcName;
                    toMenuStrip.Items[toMenuStrip.Items.Count - 1].Click += new EventHandler(FormManteOpcionesAddon_Click);
                }
            }
        }
        // FTask 123210: Creación de botones en la barra de herramientas de los Mantes

        /// <summary>
        /// Ejecutamos la acción del botón correspondiente añadido mediante los Addons
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void FormManteOpcionesAddon_Click(object sender, EventArgs e)
        {
            string lcName = (sender as ToolStripMenuItem).Name;

            Control[] loControl = this.Controls.Find(lcName, true);

            if (loControl != null)
            {
                try
                {
                    ((ewbutton)loControl[0]).Enabled = true;
                    ((ewbutton)loControl[0]).PerformClick(); // No sabemos el código que se ha programado. Si da error ...
                }
                catch (Exception loEx)
                {
                    if (Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_prueva")) || System.Diagnostics.Debugger.IsAttached) // Gestión de error
                        this._MessageBox("Se ha producido la siguiente incidencia en la ejecución de la opción " + (sender as ToolStripMenuItem).Text.Trim() + ": " + Environment.NewLine + Environment.NewLine + loEx.Message, MessageBoxButtons.OK, MessageBoxIcon.Exclamation, MessageBoxDefaultButton.Button1, DialogResult.OK);
                }
            }
        }

        /// <summary>
        /// Configuramos la clase "clsElementos" para poder instanciar correctamente el control dque cumple la interfaz "IAddonBotonMenuDoc" que se añadirán en el botón de opciones correspondiente
        /// </summary>
        /// <param name="toControl"></param>
        private bool AddonBotonMenuDoc(Control toControl)
        {
            IAddonBotonMenuDoc loIAddonBotonMenuDoc = (IAddonBotonMenuDoc)toControl;

            this.lstOpcionesMenuAddon.Add(toControl); // Añadimos  la opción a la lista

            // La propiedad _Menu no la vamos a utilizar, únicamente es para los perfiles
            if (string.IsNullOrWhiteSpace(loIAddonBotonMenuDoc._TituloMenu) && toControl is ewbutton && !string.IsNullOrWhiteSpace(toControl.Text)) // Si no tiene título la opción, asignaremos el texto del botón
                loIAddonBotonMenuDoc._TituloMenu = toControl.Text;

            // Cambiamos la posición del control para que no se vea. No lo podemos hacer invisible o al hacer el PerformClick no se ejecutará
            toControl.Left = -10000;
            toControl.Top = -10000;
            toControl.Width = 1;
            toControl.Height = 1;

            AddonBotonMenuDocDocumento(toControl);

            return true;
        }

        /// <summary>
        /// Asignamos la referencia al documento al botón para realizar las acciones pertinentes
        /// </summary>
        /// <param name="toControl">Control de tipo IAddonBotonMenuDoc</param>
        private void AddonBotonMenuDocDocumento(Control toControl)
        {
            dynamic loDocumento = null;

            if (toControl is IAddonBotonMenuDoc)
            {
                if (this is FormMante)
                    loDocumento = ((FormMante)this)._ewMante;
                else if (this is FormBaseDocumento)
                    loDocumento = ((FormBaseDocumento)this)._Documento;

                if (loDocumento != null)
                {
                    IAddonBotonMenuDoc loIAddonBotonMenuDoc = ((IAddonBotonMenuDoc)toControl);
                    loIAddonBotonMenuDoc._Documento = loDocumento;
                }
            }
        }

        /// <summary>
        /// Realizamos el refresco recursivamente de los controles
        /// </summary>
        /// <param name="toContenedor">Objeto que puede ser contenedor de otros objetos</param>
        /// <param name="tlChild">Recorre si los diferentes controles del UserControl para ejecutar el _Refresh</param>
        private void ControlRefreshRecursive(Control toContenedor, bool tlChild = false)
        {
            if (!toContenedor.HasChildren)
                return;

            foreach (Control loControlChild in toContenedor.Controls)
                _ControlRefresh(loControlChild, tlChild);
        }

        /// <summary>
        /// Ejercución del método _Refresh del control
        /// </summary>
        /// <param name="toControl">Control al que se ejecutará el _Refresh</param>
        /// <param name="tlChild">Recorre si los diferentes controles del UserControl para ejecutar el _Refresh</param>
        public void _ControlRefresh(Control toControl, bool tlChild = false)
        {
            if (toControl == null)
                return;

            dynamic loControlDynamic = toControl;
            bool llRefresh = (toControl is IAddonTabDoc);

            if (llRefresh)
            {
                Type ltType = Type.GetType(loControlDynamic.GetType().AssemblyQualifiedName);

                MethodInfo objMethod = ltType.GetMethod("_Refresh"); // Busca la propiedad pública con el nombre especificado, si no la encuentra devuelve null
                llRefresh = (objMethod != null);
            }

            if (llRefresh)
            {
                try
                {
                    loControlDynamic._Refresh();
                }
                catch (Exception loEx)
                {
                    if (Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_prueva")) || System.Diagnostics.Debugger.IsAttached)
                        this._MessageBox("Se ha producido la siguiente incidencia en la ejecución del método Refresh del control " + toControl.Name + ": " + Environment.NewLine + Environment.NewLine + loEx.Message, MessageBoxButtons.OK, MessageBoxIcon.Exclamation, MessageBoxDefaultButton.Button1, DialogResult.OK);
                }
            }

            ControlRefreshRecursive(toControl);
        }

        /// <summary>
        /// Asociación de la propiedad _Documento al Addon recursivamente
        /// </summary>
        /// <param name="toContenedor">Objeto que puede ser contenedor de otros objetos</param>
        /// /// <param name="toDocumento"></param>
        /// <param name="tlChild">Recorre si los diferentes controles del UserControl para asociar el _Documento</param>
        private void ControlDocumentoRecursive(Control toContenedor, dynamic toDocumento, bool tlChild = false)
        {
            if (!toContenedor.HasChildren)
                return;

            foreach (Control loControlChild in toContenedor.Controls)
                _ControlDocumento(loControlChild, toDocumento, tlChild);
        }

        /// <summary>
        /// Asociación de la propiedad _Documento al Addon
        /// </summary>
        /// <param name="toControl">Control al que se asignará el _Documento</param>
        /// <param name="toDocumento">Referencia al documento</param>
        /// <param name="tlChild">Recorre si los diferentes controles del UserControl para asociar el _Documento</param>
        public void _ControlDocumento(Control toControl, dynamic toDocumento, bool tlChild = false)
        {
            if (toControl == null || toDocumento == null)
                return;

            dynamic loControlDynamic = toControl;
            bool llDocumento = (toControl is IAddonTabDoc);

            if (!llDocumento)
            {
                Type ltType = Type.GetType(loControlDynamic.GetType().AssemblyQualifiedName);

                MemberInfo[] objMember = ltType.GetMember("_Documento");
                llDocumento = (objMember.Length > 0);
            }

            if (llDocumento)
            {
                try
                {
                    loControlDynamic._Documento = toDocumento;
                }
                catch (Exception loEx)
                {
                    if (Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_prueva")) || System.Diagnostics.Debugger.IsAttached)
                        this._MessageBox("Se ha producido la siguiente incidencia en la asignación del documento al control " + toControl.Name + ": " + Environment.NewLine + Environment.NewLine + loEx.Message, MessageBoxButtons.OK, MessageBoxIcon.Exclamation, MessageBoxDefaultButton.Button1, DialogResult.OK);
                }
            }

            ControlDocumentoRecursive(toControl, toDocumento, tlChild);
        }

        /// <summary>
        /// Añadimos una addon en la página de en un ewtabcontrol
        /// </summary>
        /// <param name="toControl"></param>
        /// <param name="toControlContenedor"></param>
        /// <returns></returns>
        private bool AddonInsertarTabDocAddon(Control toControl, ref Control toControlContenedor)
        {
            bool llOk = false;
            ewtabcontrol loewtabcontrol = null;

            foreach (Control loControl in Controls) // De momento no es necesario realizarlo recursivamente
            {
                if (loControl is ewtabcontrol)
                {
                    loewtabcontrol = (ewtabcontrol)loControl;
                    break;
                }
            }

            if (loewtabcontrol != null)
            {
                Control loPagina = AddonNuevaPaginaTabDoc(toControl, loewtabcontrol);

                ewFlowLayoutPanel loewFlowLayoutPanel = this.AddonNuevoFlowLayoutPanel();
                loewFlowLayoutPanel.Size = loewtabcontrol.TabPages[0].Size; // Asignamos las dimensiones de la primera página
                loewFlowLayoutPanel.Dock = DockStyle.Fill;
                loPagina.Controls.Add(loewFlowLayoutPanel);  // Agregamos el flowlayout a la página para la gestión de las barras
                loPagina.Dock = DockStyle.Fill;

                toControlContenedor = loewFlowLayoutPanel; // Agregaremos el addon en el flowlayout de la página, por tanto actualizamos el controlContenedor

                llOk = true;
            }

            return llOk;
        }

        /// <summary>
        /// Instanciación de un "ewFlowLayoutPanel" que para que presenta las barras de desplazamiento si no cabe la totalidad del control que se pueda añadir
        /// </summary>
        /// <returns>Devuelve un "ewFlowLayoutPanel" para añadirlo en la página</returns>
        private ewFlowLayoutPanel AddonNuevoFlowLayoutPanel()
        {
            ewFlowLayoutPanel loewFlowLayoutPanel = new ewFlowLayoutPanel();

            loewFlowLayoutPanel.AutoScroll = true;
            loewFlowLayoutPanel.WrapContents = true;

            //if llResizeAddon
            // loewFlowLayoutPanel.Dock = System.Windows.Forms.DockStyle.Fill; // MEJORA: _Resize: Si nos interesa que el usuario gestiona el resize
            // loewFlowLayoutPanel.Size = toControl.Size; // Asignamos las dimensiones del control

            return loewFlowLayoutPanel;
        }

        /// <summary>
        /// Obtener el nombre de una página
        /// </summary>
        /// <param name="toewtabcontrol"></param>
        /// <returns></returns>
        private string AddonNombrePagina(ewtabcontrol toewtabcontrol)
        {
            string lcName = string.Empty;

            lcName = "AddonPagina" + Convert.ToString(toewtabcontrol.TabPages.Count);

            return lcName;
        }

        /// <summary>
        /// Añadimos una nueva página en un tabcontrol
        /// </summary>
        /// <param name="toControl"></param>
        /// <param name="toewtabcontrol"></param>
        /// <returns></returns>
        private Control AddonNuevaPaginaTabDoc(Control toControl, ewtabcontrol toewtabcontrol)
        {
            Control loControlewTabPage = null;
            string lcewtabcontrol = toewtabcontrol.Name, lcTitulo = string.Empty, lcName = string.Empty;
            IAddonTabDoc loIAddonTabDoc = (IAddonTabDoc)toControl;

            loControlewTabPage = new ewTabPage();

            lcName = toControl.Name;

            if (string.IsNullOrWhiteSpace(lcName))
                lcName = AddonNombrePagina(toewtabcontrol);

            loControlewTabPage.Name = lcName;
            loControlewTabPage.Text = loIAddonTabDoc._TituloPagina; // Indicamos el título de la página

            toewtabcontrol.Controls.Add(loControlewTabPage);

            if (loIAddonTabDoc._Principal) // Añadimos el tabpage como página principal
            {
                ewTabPage loewTabPage = (ewTabPage)loControlewTabPage;

                CambiarIndiceTabpage(toewtabcontrol, loewTabPage, 0);
            }

            return loControlewTabPage;
        }

        /// <summary>
        /// Reordenamos las páginas
        /// </summary>
        /// <param name="toewtabcontrol"></param>
        /// <param name="toewTabPage"></param>
        /// <param name="tnNuevoIndice"></param>
        private void CambiarIndiceTabpage(ewtabcontrol toewtabcontrol, ewTabPage toewTabPage, int tnNuevoIndice)
        {
            ewTabPage loewTabPage;

            int lnIndiceTabPage = toewtabcontrol.TabPages.IndexOf(toewTabPage); // Buscamos el índice de la página que hemos agregado

            for (int lnIndice = 0; lnIndice < lnIndiceTabPage; lnIndice++)
            {
                loewTabPage = (ewTabPage)toewtabcontrol.TabPages[0];

                toewtabcontrol.TabPages.Remove(loewTabPage);
                toewtabcontrol.TabPages.Add(loewTabPage);
            }

            // toewtabcontrol.TabPages.Insert(tnNuevoIndice, toewTabPage); // De momento como no funciona, hemos realizado el recorrido de las diferentes páginas
        }

        // FTask 111119 - 115209

        #region Ayuda contextual
        private bool _lFormActivated = true;
        private bool _lPresentandoAyuda = false;
        private BackgroundWorker _oBackgroundWorker;
        private FormPanelNotificaciones _oFormAyuda = null;

        /// <summary>
        /// Para guardar el título del formulario sin acrónimo ni sufijos
        /// </summary>
        private string _cTituloFormulario = "";

        /// <summary>
        /// Estructura para gestionar el resultado del BakcGroundWorker
        /// </summary>
        public struct oResultadoAyuda
        {
            /// <summary>
            /// Indica si ha de presentar la ayuda
            /// </summary>
            public bool _Ayuda
            {
                get { return _lAyuda; }
                set { _lAyuda = value; }
            }
            bool _lAyuda;

            /// <summary>
            /// Instancia de la ayuda contextual
            /// </summary>
            public IAyudaContextual _AyudaContextual
            {
                get { return _oAyudaContextual; }
                set { _oAyudaContextual = value; }
            }
            IAyudaContextual _oAyudaContextual;

            /// <summary>
            /// Instancia del OnBoardingController
            /// </summary>
            public IOnBoardingController _OnBoardingController
            {
                get { return _oOnBoardingController; }
                set { _oOnBoardingController = value; }
            }
            IOnBoardingController _oOnBoardingController;
        }

        /// <summary>
        /// Controlamos que tenemos la ayuda activa
        /// </summary>
        /// <returns></returns>
        private bool AyudaActiva()
        {

            if (Usuario._This._Opcesp("5004")) // No presentar ayuda en pantallas de Sage 50c
                return false;

            bool llActiva = true;

            object loObject = EW_GLOBAL._GetVariable("wl_DesactivarOnBoarding");

            if (loObject != null)
            {
                try
                {
                    llActiva = !Convert.ToBoolean(loObject); // Tendremos que "wl_DesactivarOnBoarding" es true por eso negamos
                }
                catch (Exception)
                {
                }
            }

            return llActiva;
        }

        /// <summary>
        /// Indica que la pantalla relacionada con la ayuda contextual / ayuda de Sage 50
        /// </summary>
        /// <returns></returns>
        protected virtual string _PantallaAyuda
        {
            get { return _Pantalla; }
        }

        /// <summary>
        /// Indica si ha de presentar el WalkTrought de la pantalla 0
        /// </summary>
        private bool _lPantalla0Showed = false;

        /// <summary>
        /// Marcamos que ya ha realizado el Login y no teniamos cargada aún la ayuda contextual al entrar la primera vez 
        /// </summary>
        private bool _lPantalla0ShowAfterLogin = false;

        /// <summary>
        /// Instanciación del BackgroundWorker de la ayuda contextual
        /// </summary>
        private void AyudaOnBoarding()
        {
            if (!IsDisposed && !Disposing )
            {
                if (BarrasAyudaActivas())
                {
                    if (string.IsNullOrWhiteSpace(_PantallaAyuda) || !AyudaActiva() || botonayuda == eAyudaContextual.Desactivada)
                    {
                        _FormSagePanel?._Show(_ButtonsSagePanel, this);
                    }
                    else
                    {
                        // Declaro un nuevo elemento
                        _oBackgroundWorker = new BackgroundWorker();
                        _oBackgroundWorker.WorkerSupportsCancellation = true;
                        _oBackgroundWorker.WorkerReportsProgress = false;

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

                        // Ejecución asíncrona
                        _oBackgroundWorker.RunWorkerAsync();
                    }
                }
            }
        }

        private bool BarrasAyudaActivas()
        {
            DataTable loDt = new DataTable();
            string lcDataBase, lcComunes, lcSql;

            if (!EW_GLOBAL._ContainsKey("wl_barras_ayuda_form"))
            {
                lcComunes = GrupoEmpresa._DbComunesRealGrupoPripal();
                lcDataBase = DB.SQLDatabaseReal(lcComunes, "VARIABLE");

                lcSql = $"SELECT VALOR FROM {lcDataBase} WHERE VARIABLE = 'NO_AYUDA' ";
                if(DB.SQLExec(lcSql, ref loDt)) EW_GLOBAL.ValorEnClave_VarGlob("wl_barras_ayuda_form", loDt.Rows.Count == 0);
            }

            return Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_barras_ayuda_form", true));
        }

        /// <summary>
        /// Método que define el proceso que se va a ejecutar en segundo plano de la ayuda contextual
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void _ExecuteRunWorkerAyuda(object sender, DoWorkEventArgs e)
        {
            oResultadoAyuda loResult = new oResultadoAyuda();
            loResult._Ayuda = false; // Asignamos el false por defecto

            try
            {
                IOnBoardingController loOnBoardingController = FUNCTIONS._OnBoardingController();

                if (loOnBoardingController != null && !loOnBoardingController._PlayingVideo)
                {
                    IAyudaContextual loAyudaContextual = new AyudaContextual(loOnBoardingController);
                    loAyudaContextual._Load(_PantallaAyuda.ToUpper());

                    if (loAyudaContextual != null && (loAyudaContextual._Categorias.Count > 0 || loAyudaContextual._NumeroTotalNoticias > 0))
                    {
                        loResult._OnBoardingController = loOnBoardingController;
                        loResult._AyudaContextual = loAyudaContextual;
                        loResult._Ayuda = true;
                    }
                }
            }
            catch (Exception loEx)
            {
                DB.Registrar_Error(loEx);
            }

            e.Result = loResult; // Asignamos el retorno
        }

        /// <summary>
        /// Método que se ejecutará al finalizar el proceso de consulta de la ayuda contextual
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void _RunWorkerCompletedAyuda(object sender, RunWorkerCompletedEventArgs e)
        {
            if (!e.Cancelled && e.Error == null &&!FormDisposed()) // Si no he sido cancelado ni he registrado excepción 
            {
                _oResultadoAyuda = ((oResultadoAyuda)e.Result);

                if (_oResultadoAyuda._Ayuda)
                    _BotonAyuda = eAyudaContextual.Si;

                //CambiarBotonAyudaMensaje();

                if (PresentarAyudaNuevasNoticias(_oResultadoAyuda))
                {
                    if (EsPantalla0)
                    {
                        _oResultadoAyuda._Ayuda = true;

                        if (_lPantalla0ShowAfterLogin && !_lPantalla0Showed && Ayuda_FormularioActivo()) // Si ha entrado el Usuario y no ha presentado aún el WalkTrought, ahora lo presentamos si no hay ninguna pantalla abierta
                            _WalkthroughsPantalla0();
                    }
                    //else
                    //    MostrarAyuda(_oResultadoAyuda._AyudaContextual);
                }

                _FormSagePanel?._Show(_ButtonsSagePanel, this);
            }
        }

        /// <summary>
        /// Controlamos si es necesario presentar las noticias relacionadas con la pantalla
        /// Tenemos dos casos:
        /// 
        /// 1. Si tenemos activada la ayuda y tenemos noticias
        /// 2. Existe alguna noticia nueva. La presentamos igualmente
        /// </summary>
        /// <param name="toResultadoAyuda"></param>
        /// <returns></returns>
        private bool PresentarAyudaNuevasNoticias(oResultadoAyuda toResultadoAyuda)
        {

            // Si la pantalla no tiene ayuda podemos salir
            if (!_oResultadoAyuda._Ayuda) 
                return false;

            // Tenemos activada la ayuda
            if ( _oResultadoAyuda._AyudaContextual._PresentacionAyuda != Presentacion.No)
                return true;

            // Existe alguna noticia nueva a partir de la fecha que el usuario marcó no volver a presentar la ayuda
            if (_oResultadoAyuda._AyudaContextual._NoticiasNuevasPendientesLeer > 0)
                return true;

            return false;
        }

        /// <summary>
        /// Devuelve si es la pantalla 0 donde presentaremos el formulario frmWalktrhoughs si es necesario
        /// </summary>
        private bool EsPantalla0
        {
            get { return _PantallaAyuda == "PANTALLA0"; }
        }

        /// <summary>
        /// Presentamos la pantalla de los Walktrhough si es necesario
        /// </summary>
        /// <returns></returns>
        protected bool _WalkthroughsPantalla0()
        {
            _lPantalla0ShowAfterLogin = true; // Marcamos que ya ha pasado por el AfterLogin que es el único lugar de donde se realiza la llamada

            if (EsPantalla0 && !FUNCTIONS._CanUseWebView()) // No presentamos mensaje, validamos si tenemos el RunTime del WebView2 independientemente de que tengamos o no información de la pantalla 0
                return false;

            if (_oResultadoAyuda._Ayuda == false || !EsPantalla0 || _lPantalla0Showed)
                return false;

            _lPantalla0Showed = true; // De momento marcamos que ya se ha visto o podrian salir dos instancias

            IOnBoardingController loOnBoardingController = FUNCTIONS._OnBoardingController();

            if (loOnBoardingController != null)
            {
                _lPantalla0Showed = ((OnBoardingControllerSage50)loOnBoardingController)._ShowWalkthroughs(_oResultadoAyuda._AyudaContextual);

                return _lPantalla0Showed;
            }
            else
                return false;
        }

        /// <summary>
        /// Calculamos la posición del formulario de ayuda del OnBoarding
        /// </summary>
        /// <param name="toRectangle">Rectangle del formualrio de ayuda</param>
        /// <returns></returns>
        private Point CalculateLocationAyuda(Rectangle toRectangle)
        {
            Rectangle loRectScreen = Screen.PrimaryScreen.WorkingArea;
            Point loPoint = toRectangle.Location;
            int lnOffsetX = 20, lnOffsetY = 50;

            if (Location.X < 0) // Tenemos pantallas como los mantenimientos o perfiles donde el formulario se presenta en una posición fuera de la area visible
            {
                loPoint.X = (loRectScreen.Width / 2) + (Size.Width / 2) - lnOffsetX;
                loPoint.Y = (loRectScreen.Height / 2) - (Size.Height / 2) + lnOffsetY;
            }
            else
            {
                loPoint.X = Location.X + Size.Width - lnOffsetX;
                loPoint.Y = Location.Y + lnOffsetY;
            }

            if (loPoint.X + toRectangle.Size.Width > loRectScreen.Width)
                loPoint.X = loRectScreen.Width - lnOffsetX - toRectangle.Width;

            if (loPoint.Y + toRectangle.Size.Height > loRectScreen.Height)
                loPoint.Y = (loRectScreen.Height / 2) - (toRectangle.Height / 2);

            return loPoint;
        }

        /// <summary>
        /// Posicionaremos la pantalla donde el usuario la dejó previamente
        /// Controlamos que sea en una area visible
        /// </summary>
        /// <param name="toAyudaContextual">Referencia a la ayuda contextual</param>
        private void LocationAyuda(IAyudaContextual toAyudaContextual)
        {
            Point loPoint = new Point(toAyudaContextual._Left, toAyudaContextual._Top);

            if (loPoint == new Point(0, 0) ||
                loPoint.X > Screen.PrimaryScreen.Bounds.Size.Width || loPoint.Y > Screen.PrimaryScreen.Bounds.Size.Height)
            {
                loPoint = CalculateLocationAyuda(_oFormAyuda.Bounds);
            }

            if (toAyudaContextual._Height > 0)
            {
                Size loSize = _oFormAyuda.Size;
                loSize.Height = toAyudaContextual._Height;

                if (_oFormAyuda.Size != loSize)
                    _oFormAyuda.Size = loSize;
            }

            _oFormAyuda.Location = loPoint;
        }

        /// <summary>
        /// Controlamos si el formulario se está destruyendo
        /// </summary>
        /// <returns></returns>
        protected virtual bool FormDisposed()
        {
            return (IsDisposed || Disposing);
        }

        private void CambiarBotonAyudaMensaje()
        {
            if (!EsPantalla0 && _oResultadoAyuda._AyudaContextual != null && !FormDisposed())
            {
                int numnoticias = _oResultadoAyuda._AyudaContextual._NoticiasPendientesLeer;

                if(menu is IActiveMenu)
                {
                    foreach (ActiveButton item in menu.Items)
                    {
                       
                        if (item.Name == "Ayuda")
                        {
                            // NOTICIAS ONBOARDING. Si tenemos noticias, sustituimos icono de Info por la Campana 
                            if (numnoticias > 0)
                            {
                                string lcTooltip = " Noticias";                                                                
                                item.ForeColor = Color.FromArgb(0, 129, 70);
                                item.Font = new Font("Segoe UI", 8.5F);                                
                                item._ModColors = false;

                                if (numnoticias == 1)
                                {
                                    item.Text = "1";
                                    lcTooltip = " Noticia";
                                }
                                else if (numnoticias < 100)
                                    item.Text = numnoticias.ToString().Trim();
                                else
                                    item.Text = "99+";

                                item.Image = sage.ew.images.Properties.Resources.bell_green_16;
                                menu.ToolTip.SetToolTip(item, item.Text+lcTooltip);
                                item.ChangeColors(); 
                            }

                            break;
                        }
                    }
                }
            }
        }

        /// <summary>
        /// Gestión de la presentación del formulario de configuración de usabilidad
        /// </summary>
        private void MostrarCfgUsabilidad()
        {
            // En el formulario de configuración se comprueba si hay mensajes configurados en el formulario/usuario actual
            // y se muestra mensaje sino hay y se cierra.
            frmUserFormConfig frmCfg = new frmUserFormConfig(Usuario._This._Codigo, this._Pantalla, this._ObtenerText(false));
            frmCfg._ShowDialog();
        }

        /// <summary>
        /// Gestión de la presentación de la ayuda contextual
        /// </summary>
        /// <param name="toAyudaContextual">Instancia de la ayuda contextual cuando venimos del BackGroundWordker</param>
        private void MostrarAyuda(IAyudaContextual toAyudaContextual = null)
        {
            if (_oFormAyuda != null && !_oFormAyuda.IsDisposed && !_oFormAyuda.Disposing)
            {
                ShowAyuda();
                return;
            }

            if (FormDisposed())
                return;

            IOnBoardingController loOnBoardingController = FUNCTIONS._OnBoardingController();

            if (toAyudaContextual == null) // Venimos del botón de opciones. Se ha de instanciar la ayuda contextual
            {
                toAyudaContextual = new AyudaContextual(loOnBoardingController);
                toAyudaContextual._Load(_Pantalla.ToUpper());

                ((OnBoardingControllerSage50)loOnBoardingController)._WebService("mostrar", tcPantalla: _Pantalla.ToUpper()); // Acción de mostrar ayuda
            }

            if (FormDisposed())
                return;

            _oFormAyuda = new FormPanelNotificaciones(_Pantalla.ToUpper(), Text, loOnBoardingCont³nDeAccesosToolStripMenuItem,
            this.crearAccesoDirectoToolStripMenuItem,
            this.crearTareaProgramadaItem,
            this.crearApunteCalendarioItem,
            this.listadosPersonalizablesEditarItem,
            this.listadosPersonalizablesDuplicarItem,
            this.ayudaPantallaToolStripMenuItem,
            this.ShowPropertiesToolStripMenuItem});
            this.contextMenuStripPantalla.Name = "contextMenuStripPantalla";
            this.contextMenuStripPantalla.Size = new System.Drawing.Size(289, 230);
            // 
            // configuracionesUsuarioItem
            // 
            this.configuracionesUsuarioItem.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] {
            this.toolConfiguracionesToolStripMenuItem});
            this.configuracionesUsuarioItem.Name = "configuracionesUsuarioItem";
            this.configuracionesUsuarioItem.Size = new System.Drawing.Size(288, 22);
            this.configuracionesUsuarioItem.Text = "Configuraciones de usuario";
            // 
            // toolConfiguracionesToolStripMenuItem
            // 
            this.toolConfiguracionesToolStripMenuItem.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.toolConfiguracionesToolStripMenuItem.Name = "toolConfiguracionesToolStripMenuItem";
            this.toolConfiguracionesToolStripMenuItem.Size = new System.Drawing.Size(221, 22);
            this.toolConfiguracionesToolStripMenuItem.Text = "Diseñador configuraciones";
            // 
            // configuracionesUsuarioItemSeparator
            // 
            this.configuracionesUsuarioItemSeparator.Name = "configuracionesUsuarioItemSeparator";
            this.configuracionesUsuarioItemSeparator.Size = new System.Drawing.Size(285, 6);
            // 
            // nombreFormularioToolStripMenuItem
            // 
            this.nombreFormularioToolStripMenuItem.Name = "nombreFormularioToolStripMenuItem";
            this.nombreFormularioToolStripMenuItem.Size = new System.Drawing.Size(288, 22);
            this.nombreFormularioToolStripMenuItem.Text = "Nombre del formulario";
            // 
            // ShowPropertiesToolStripMenuItem
            // 
            this.ShowPropertiesToolStripMenuItem.Name = "ShowPropertiesToolStripMenuItem";
            this.ShowPropertiesToolStripMenuItem.Size = new System.Drawing.Size(288, 22);
            this.ShowPropertiesToolStripMenuItem.Text = "Mostrar propiedades controles";
            // 
            // gestiónDeFavoritosToolStripMenuItem
            // 
            this.gestiónDeFavoritosToolStripMenuItem.Name = "gestiónDeFavoritosToolStripMenuItem";
            this.gestiónDeFavoritosToolStripMenuItem.Size = new System.Drawing.Size(288, 22);
            this.gestiónDeFavoritosToolStripMenuItem.Text = "Gestión de favoritos";
            // 
            // gestiónDeAccesosToolStripMenuItem
            // 
            this.gestiónDeAccesosToolStripMenuItem.Name = "gestiónDeAccesosToolStripMenuItem";
            this.gestiónDeAccesosToolStripMenuItem.Size = new System.Drawing.Size(288, 22);
            this.gestiónDeAccesosToolStripMenuItem.Text = "Gestión de accesos";
            // 
            // crearAccesoDirectoToolStripMenuItem
            // 
            this.crearAccesoDirectoToolStripMenuItem.Name = "crearAccesoDirectoToolStripMenuItem";
            this.crearAccesoDirectoToolStripMenuItem.Size = new System.Drawing.Size(288, 22);
            this.crearAccesoDirectoToolStripMenuItem.Text = "Crear acceso directo";
            // 
            // crearTareaProgramadaItem
            // 
            this.crearTareaProgramadaItem.Name = "crearTareaProgramadaItem";
            this.crearTareaProgramadaItem.Size = new System.Drawing.Size(288, 22);
            this.crearTareaProgramadaItem.Text = "Crear tarea programada";
            // 
            // crearApunteCalendarioItem
            // 
            this.crearApunteCalendarioItem.Name = "crearApunteCalendarioItem";
            this.crearApunteCalendarioItem.Size = new System.Drawing.Size(288, 22);
            this.crearApunteCalendarioItem.Text = "Nue&vo apunte calendario";
            // 
            // listadosPersonalizablesEditarItem
            // 
            this.listadosPersonalizablesEditarItem.Name = "listadosPersonalizablesEditarItem";
            this.listadosPersonalizablesEditarItem.Size = new System.Drawing.Size(288, 22);
            this.listadosPersonalizablesEditarItem.Text = "Editar el listado personalizable";
            // 
            // listadosPersonalizablesDuplicarItem
            // 
            this.listadosPersonalizablesDuplicarItem.Name = "listadosPersonalizablesDuplicarItem";
            this.listadosPersonalizablesDuplicarItem.Size = new System.Drawing.Size(288, 22);
            this.listadosPersonalizablesDuplicarItem.Text = "Duplicar y editar el listado personalizable";
            // 
            // ayudaPantallaToolStripMenuItem
            // 
            this.ayudaPantallaToolStripMenuItem.Name = "ayudaPantallaToolStripMenuItem";
            this.ayudaPantallaToolStripMenuItem.Size = new System.Drawing.Size(288, 22);
            this.ayudaPantallaToolStripMenuItem.Text = "Ayuda";
            // 
            // _MenuContext_Opciones
            // 
            this._MenuContext_Opciones.Font = new System.Drawing.Font("Segoe UI", 9.5F);
            this._MenuContext_Opciones.Name = "ewcontextmenustripOpcProc";
            this._MenuContext_Opciones.Size = new System.Drawing.Size(61, 4);
            // 
            // FormBase
            // 
            this.ClientSize = new System.Drawing.Size(284, 262);
            this.KeyPreview = true;
            this.Name = "FormBase";
            this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen;
            ((System.ComponentModel.ISupportInitialize)(this._oErrorProvider)).EndInit();
            this.contextMenuStripPantalla.ResumeLayout(false);
            this.ResumeLayout(false);

        }
        
        public List<T> _FindControl<T>(Control toControl = null)
        {
            if (toControl == null)
                toControl = this;

            List<T> lstControls = new List<T>();

            lstControls = AllControls(toControl).OfType<T>().ToList();

            return lstControls;
        }

        private IEnumerable<Control> AllControls(Control container)
        {
            foreach (Control control in container.Controls)
            {
                yield return control;

                foreach (var innerControl in AllControls(control))
                    yield return innerControl;
            }
        }

        
        protected override void WndProc(ref Message msgEW)
        {
            if (msgEW.Msg != WM_SYSCOMMAND  || (msgEW.Msg == WM_SYSCOMMAND && ( _ExecuteCommandBefore == null || _ExecuteCommandBefore.Invoke(this, msgEW.WParam))))
            {
                base.WndProc(ref msgEW);

                if (EW_GLOBAL._EsEjecutable)
                {
                    //TODO: Temporal hasta que veamos que pasa realmente
                    if (!System.Diagnostics.Debugger.IsAttached && !NETVFP._ReceiveMessageFromVfp(ref msgEW))
                        return;
                }
            }
        }
        
        public virtual bool _Init(object[] taParams)
        {
            if (taParams.Count() > 0)
            {
                _lAutomatico = true; //Bug 206971: Para poder saber en el formbase si estamos en una tarea programada
            }
            return true;
        }
        // FI PE-77741

        public virtual bool _InitAccesoDirecto(object[] taParams)
        {
            // Obtención de los parámetros según pantalla
            if (taParams != null && taParams.Length > 0)
            {
                foreach (object loItem in taParams)
                {
                    //Si trobem un parametre que començi per "idparam:" es que tenin propietats guardades a COMUNES!ACDIRPARAM
                    if (loItem.ToString().StartsWith(FUNCTIONS._AccesoDirectoParametro))
                    {
                        //Recuperem les propietats que mes tard asignarem al OnShown
                        return FUNCTIONS._RecuperarParametrosAccesoDirecto(loItem.ToString(), ref this._ValoresAccesoDirecto);
                    }
                }
            }
            return false;
        }

        public virtual bool _EstablecerParametrosFormulario()
        {
            if (DesignMode)
                return true;

            bool llOk = false;
            if (this._ValoresAccesoDirecto.Count > 0)
            {
                string lcControl = "", lcPropiedad = "";
                object lcValor = "";
                foreach (KeyValuePair<string, object> loItem in this._ValoresAccesoDirecto)
                {
                    //La key estara composada del "nom_control:propietat_a_definir"
                    //El value contindra el valor de la propietat
                    if (loItem.Key.Contains(":"))
                    {
                        lcControl = loItem.Key.Substring(0, loItem.Key.IndexOf(":"));
                        lcPropiedad = loItem.Key.Substring(loItem.Key.IndexOf(":") + 1);
                        lcValor = loItem.Value;
                        //Recuperamos el control del formulario
                        Control loControl = this.__FindControlRecursive(lcControl);
                        if (loControl != null)
                        {
                            //Recuperamos la propiedad del Control
                            Type myType = loControl.GetType();
                            PropertyInfo myPropInfo = myType.GetProperty(lcPropiedad);
                            if (myPropInfo != null)
                            {
                                if (loControl is txtFiltroBase)
                                {
                                    llOk = true;
                                    if (lcPropiedad == "_Desde")
                                        (loControl as txtFiltroBase)._oFiltroDesde._Codigo = Convert.ToString(lcValor);
                                    else if (lcPropiedad == "_Hasta")
                                        (loControl as txtFiltroBase)._oFiltroHasta._Codigo = Convert.ToString(lcValor);
                                    else if (lcPropiedad == "_Todos")
                                        (loControl as txtFiltroBase)._Todos = Convert.ToBoolean(lcValor);
                                    else if (lcPropiedad == "_Lista")
                                        (loControl as txtFiltroBase)._Lista = new List<string>(lcValor.ToString().Split(','));
                                }
                                else
                                {
                                    //Tratamiento de valores
                                    object lcRealValue = lcValor;
                                    if (loControl is ewcombobox && lcPropiedad.ToLower() == "selectedindex")
                                        lcRealValue = Convert.ToInt32(lcRealValue);
                                    else if ((loControl is ewcheckbox || loControl is ewradiobutton) && lcPropiedad.ToLower() == "checked")
                                        lcRealValue = Convert.ToBoolean(lcRealValue);

                                    //Establecemos el valor a la propiedad
                                    try
                                    {
                                        myPropInfo.SetValue(loControl, lcRealValue, null);
                                        llOk = true;
                                    }
                                    catch (Exception)// loEx)
                                    {
                                        //TODO : Errores derivados de establecer propiedades con tipos que no corresponden?
                                        //loEx = loEx;
                                    }
                                }
                            }
                        }
                    }
                }
            }
            return llOk;
        }

        //PE-85758
        protected void _DisposeShapeContainer(Microsoft.VisualBasic.PowerPacks.ShapeContainer toShapeContainer)
        {
            if (toShapeContainer != null && !toShapeContainer.IsDisposed)
            {
                if (toShapeContainer.Shapes != null)
                {

                    List<Microsoft.VisualBasic.PowerPacks.Shape> llisShapes = new List<Microsoft.VisualBasic.PowerPacks.Shape>();
                    foreach (Microsoft.VisualBasic.PowerPacks.Shape tshape in toShapeContainer.Shapes)
                    {
                        llisShapes.Add(tshape);
                    }
                    toShapeContainer.Shapes.Clear();
                    toShapeContainer.Shapes.Dispose();

                    foreach (Microsoft.VisualBasic.PowerPacks.Shape loShape in llisShapes)
                    {
                        loShape.Dispose();
                    }
                }
                toShapeContainer.Dispose();
            }
        }

        [DllImport("user32")]
        private static extern IntPtr GetWindowDC(IntPtr hwnd);

        public virtual void _ControlError(Control toControl, string tcMensaje, ErrorIconAlignment toAlineamiento = ErrorIconAlignment.MiddleLeft)
        {
            _oErrorProvider.BlinkStyle = ErrorBlinkStyle.NeverBlink;
            _oErrorProvider.SetIconAlignment(toControl, toAlineamiento); // PARTE 93189. Se ha añadido el parámetro para poder pasarle la alineación
            _oErrorProvider.SetError(toControl, tcMensaje);

            // PE-92786. Obtener si ya hay algun error y concatenarlo
            string lcError = "";
            if (!string.IsNullOrWhiteSpace(tcMensaje))
            {
                lcError = this._oErrorProvider.GetError(this);
                lcError += (!string.IsNullOrWhiteSpace(lcError) ? Environment.NewLine : string.Empty) + tcMensaje;
                //if (toControl is IValidationControl)
                //{
                //    ((IValidationControl)toControl)._ErrorValidation = true;
                //}
            }
            //else
            //{
            //    if (toControl is IValidationControl)
            //    {
            //        ((IValidationControl)toControl)._ErrorValidation = false;
            //    }
            //}
        }


        public virtual void _ShowDialog()
        {
            if(CanShow()) ShowDialog();
        }

        public virtual void _Show()
        {
            if (CanShow()) Show();
        }

        private bool CanShow()
        {
            if (this._NivelAcceso != _TiposAccesosPantalla.Denegado && !this.IsDisposed) //T114218
            {
                if (_SaveReuseFormSettings && Usuario._This._PosicionFormulario)
                {
                    using (FormManagerProperties loFormManagerProperties = new FormManagerProperties(this))
                    {
                        _ReusingFormSettings = loFormManagerProperties._SetProperties();
                    }
                }

                return true;
            }

            return false;
        }

       

        private List<IButtonBarraHerram> _oListButtonsSagePanel = null;
        
        internal List<IButtonBarraHerram> _ButtonsSagePanel
        {
            get 
            {
                List<IButtonBarraHerram> loListButtonsAddons;

                if ( _oListButtonsSagePanel == null )
                {
                    _oListButtonsSagePanel = new List<IButtonBarraHerram>();

                    //Si la ayuda esta activa y hay ayuda o noticias
                    if(AyudaActiva() && _oResultadoAyuda._Ayuda) _oListButtonsSagePanel.Add(new AyudaNoticiasPantalla(this, _oResultadoAyuda));
                    
                    _oListButtonsSagePanel.Add(new AyudaPantalla(this));
                    _oListButtonsSagePanel.Add(new OpcionesPantalla(this));

                    // Comprobar si hay que mostrar la opción de configuración de mensajes por usuario/pantalla
                    if (_messageBoxAutomatic)
                        _oListButtonsSagePanel.Add(new CfgUsabilidad(this));

                    loListButtonsAddons = AddonsController.Instance.Methods.BindFormBarraHerram(_Pantalla);
                    if (loListButtonsAddons is List<IButtonBarraHerram> && loListButtonsAddons.Count > 0) _oListButtonsSagePanel.AddRange(loListButtonsAddons);
                }

                return _oListButtonsSagePanel;
            }
        }
        
        protected virtual void _Show_Accesos()
        {
            _Show_Accesos(_Pantalla);
        }

        protected void _Show_Accesos(String lcPantalla)
        {
            // PE-92757. Usamos usuario estático
            if (!Usuario._This._Show_Gestion_Accesos(lcPantalla, _EliminarAcronimo(this.Text)))   //PE-90297: pasamos el título de la pantalla también por si no existe en los accesos añadirlo
            {
                _MessageBox("El usuario activo no tiene permisos para gestionar accesos a pantallas.", MessageBoxButtons.OK, MessageBoxIcon.Stop, MessageBoxDefaultButton.Button1, DialogResult.OK);
            }
        }

        protected void _Show_Favoritos()
        {
            // PE-92757. Usamos usuario estático
            Usuario._This._Show_Favoritos(this._Pantalla, _EliminarAcronimo(this.Text));   //PE-92094: pasamos el título de la pantalla también, igual que en los accesos
        }

        private void gestiónDeFavoritosToolStripMenuItem_Click(object sender, EventArgs e)
        {
            this._Show_Favoritos();
        }

        private void gestiónDeAccesosToolStripMenuItem_Click(object sender, EventArgs e)
        {
            this._Show_Accesos();
        }

        private void crearAccesoDirectoToolStripMenuItem_Click(object sender, EventArgs e)
        {
            this._AsignarValoresAccesoDirecto();
            //Creem el acces directe
            sage.ew.functions.FUNCTIONS._CrearAccesoDirecto(_EliminarAcronimo(this.Text), this._Pantalla.Trim(), this._ValoresAccesoDirecto);
        }

        public virtual bool _AsignarValoresAccesoDirecto()
        {
            return false;
        }

        //PE-96746
        private void crearApunteCalendarioItem_Click(object sender, EventArgs e)
        {
            functions.FUNCTIONS._CrearNuevoApunteCalendario(this, _Pantalla);
        }

        // PARTE 101745
        private void ayudaPantallaToolStripMenuItem_Click(object sender, EventArgs e)
        {
            _MostrarAyudaPantalla();
        }

        public void _MostrarAyudaPantalla()
        {
            // Bug 154751. Mostrar o no la ayuda
            // _PantallaAyuda tiene el valor de _Pantalla inicialmente
            // De este modo podemos tener una pantalla sin gestión de accesos con la ayuda correspondiente
            if (_MostrarAyudaF1) FUNCTIONS._MostrarAyudaPantalla(this._PantallaAyuda);
        }
        // FPARTE 101745

        private void crearTareaProgramadaItem_Click(object sender, EventArgs e)
        {
            _CrearTareaProgramada(this._Pantalla);
        }

        private void ConfiguracionesUsuarioItem_Click(object sender, EventArgs e)
        {
            ConfigUserForm loConfig;

            // Guardar "Última configuración" antes de abrir el editor de configuraciones            
            //ConfigUserOptionsUpdateLastValues();

            FormBase loFormClon = this.Clone();
            loFormClon._ConfigUserForm = this._ConfigUserForm;
            loFormClon._ConfigUserOptionsEditing = true;

            loConfig = ConfigurationDesignManager.ShowInDesign(loFormClon, this._ConfigUserForm);

            if (loConfig is ConfigUserForm)
            {
                _ConfigUserForm = loConfig;
                _ConfigUserOptionsLoad(_ConfigUserForm._dicOpciones);
            }

            loFormClon.Close();
            loFormClon.Dispose();
            loFormClon = null;
        }

        #region Opciones de menu para listados personalizables

        protected virtual void _CrearTareaProgramada(string tcPantalla)
        {
        }


        private void listadosPersonalizablesDuplicarItem_Click(object sender, EventArgs e)
        {
            this.Close();

            ListadosPersonalizables loList = new ListadosPersonalizables();
            if (!loList._DuplicarListado(this._Pantalla))
            {
                sage.ew.functions.FUNCTIONS._MessageBox(loList._Error_Message, this.Text, //"Informes personalizables"
                    MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1);
            }
        }

        private void listadosPersonalizablesEditarItem_Click(object sender, EventArgs e)
        {
            this.Close();

            ListadosPersonalizables loList = new ListadosPersonalizables();
            if (!loList._CargarListado(this._Pantalla))
            {
                sage.ew.functions.FUNCTIONS._MessageBox(loList._Error_Message, this.Text, //"Informes personalizables"
                    MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1);
            }
        }

        #endregion Opciones de menu para listados personalizables

        private void ShowPropertiesToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (Debugger.IsAttached)
            {
                if (_oTimerProperties is Timer)
                {
                    ShowPropertiesToolStripMenuItem.Text = "Mostrar propiedades controles";

                    _InfoToolTip.Active = false;

                    _oTimerProperties.Stop();
                    _oTimerProperties.Tick -= _oTimerProperties_Tick;
                    _oTimerProperties.Dispose();
                    _oTimerProperties = null;
                }
                else
                {
                    ShowPropertiesToolStripMenuItem.Text = "Ocultar propiedades controles";

                    _InfoToolTip.Active = true;

                    _oTimerProperties = new Timer();
                    _oTimerProperties.Tick += _oTimerProperties_Tick;
                    _oTimerProperties.Interval = 500;
                    _oTimerProperties.Start();
                }
            }
        }

        private void _oTimerProperties_Tick(object sender, EventArgs e)
        {
            Control loControl;
            Point loPos = Cursor.Position;

            if (Bounds.Contains(loPos))
            {
                loControl = _GetChild(loPos, this);

                if ((loControl is Control && string.IsNullOrEmpty(_ControlNameShowing)) || (loControl is Control && loControl.Name != _ControlNameShowing))
                {
                    _ControlNameShowing = _InfoToolTip._GetControl(loControl).Name;
                    _CreateTooltipInfo(loControl, loControl.DataBindings.Count > 0 ? loControl.Name : "");
                    if(!loControl.Enabled) _InfoToolTip.Show(loControl.Name, this, PointToClient(loPos));
                }
                else if(loControl == null && !string.IsNullOrEmpty(_ControlNameShowing))
                {
                    _InfoToolTip.Hide(this);
                    _ControlNameShowing = string.Empty;
                }
            }
            else
            {
                _ControlNameShowing = string.Empty;
            }
        }

        private void _CreateTooltipInfo(Control toControl, string tcText = "")
        {
            string lcText;

            lcText = string.IsNullOrEmpty(tcText) ? toControl.DataBindings.Count > 0 ? toControl.Name : "" : tcText;

            if (!string.IsNullOrEmpty(lcText)) _InfoToolTip._ControlToolTip(toControl, lcText);

            if (toControl.Controls.Count > 0)
            {
                foreach (Control loControl in toControl.Controls)
                {
                    lcText = string.IsNullOrEmpty(tcText) ? loControl.DataBindings.Count > 0 ? loControl.Name : "" : tcText;

                    if (!string.IsNullOrEmpty(lcText))
                    {
                        _InfoToolTip._ControlToolTip(loControl, lcText);
                    }

                    if (loControl.Controls.Count > 0)
                    {
                        _CreateTooltipInfo(loControl, lcText);
                    }
                }
            } 
        }

        private string _ControlNameShowing;

        public Control _GetChild(Point toPoint, Control toBase)
        {
            Control loControl = null;

            if(toBase is Control) loControl = toBase.GetChildAtPoint(toBase.PointToClient(toPoint), GetChildAtPointSkip.Invisible | GetChildAtPointSkip.Transparent);

           return loControl?.Controls.Count > 0 && loControl?.DataBindings.Count == 0? _GetChild(toPoint, loControl) : loControl;
        }
        
        private void nombreFormularioToolStripMenuItem_Click(object sender, EventArgs e)
        {
            frmInfoFormul loFormul = new frmInfoFormul();

            //Cabecera Información
            loFormul.AddHeader("Información");

            //Titulo del formulario
            loFormul.AddLine("Título", _EliminarAcronimo(this.Text));

            //Libreria
            loFormul.AddLine("Librería", System.Reflection.Assembly.GetAssembly(this.GetType()).Location);

            //Clase
            loFormul.AddLine("Clase", this.GetType().Name);

            //Pantalla. Presentamos el valo de _PantallaAyuda
            if (!string.IsNullOrWhiteSpace(_PantallaAyuda))
                loFormul.AddLine("Pantalla", _PantallaAyuda.Trim().ToUpper());

            //S50MIG-3188 Añadir namespace
            loFormul.AddLine("Namespace", GetType().Namespace);

            //Addons
            Dictionary<string, object> loAddons = null;
            if (this is FormMante && (this as FormMante)._ewMante != null && (this as FormMante)._ewMante._Addons != null)
            {
                loAddons = (this as FormMante)._ewMante._Addons;
            }
            else if (this is frmGestionPerfil && (this as frmGestionPerfil)._Documento != null && (this as frmGestionPerfil)._Documento._Addons != null)
            {
                loAddons = (this as frmGestionPerfil)._Documento._Addons;
            }
            else if (this is FormListado && (this as FormListado)._Addons != null)
            {
                loAddons = (this as FormListado)._Addons;
            }

            if (loAddons != null && loAddons.Count > 0)
            {
                //Cabecera addons
                loFormul.AddHeader("Add-ons");
                //Info de addons
                string lcDllAddon = "", lcSubjectName = "";
                foreach (KeyValuePair<string, object> loItem in loAddons)
                {
                    try
                    {
                        // Obtenemos el objeto de extensiones y lo configuramos
                        //loExtension = (_ExtensionMante)loItem.Value;
                        string lcName = "", lcTmp = "";
                        if (AddonsController.Instance.AddonsManager.IsLoaded(loItem.Key))
                        {
                            //Ruta a la dll
                            lcDllAddon = (AddonsController.Instance.AddonsManager.GetAddon(loItem.Key) as IModulo)._Libreria + ".dll";
                            lcTmp = lcDllAddon;
                            //Qui la firma
                            lcSubjectName = FUNCTIONS.GetDllNameInfo(lcDllAddon);
                            if (!string.IsNullOrWhiteSpace(lcSubjectName))
                                lcTmp += " (" + lcSubjectName + ")";
                            else
                                lcTmp += " (Sin firmar)";
                            //Quin tipus es
                            int lnTipo = (AddonsController.Instance.AddonsManager.GetAddon(loItem.Key) as IModulo)._Tipo;
                            switch (lnTipo)
                            {
                                case 2:
                                    lcTmp += " - Extensión contratable";
                                    break;
                                case 3:
                                    lcTmp += " - Extensión personalizada";
                                    break;
                                case 1:
                                case 0:
                                default:
                                    lcTmp += " - Extensión incluida";
                                    break;
                            }
                            //Nom del addon a mostrar
                            lcName = (AddonsController.Instance.AddonsManager.GetAddon(loItem.Key) as IModulo)._Nombre2;
                            if (string.IsNullOrWhiteSpace(lcName))
                                lcName = loItem.Key;

                            //Afegim una linia per cada addon
                            loFormul.AddLine(lcName, lcTmp);
                        }
                    }
                    catch (Exception loError)
                    {
                        DB.Registrar_Error(loError);
                    }
                }
            }

            //Mostramos el formulario
            loFormul._ShowDialog();
        }

        protected string _EliminarAcronimo(String toText)
        {
            String lcText = toText;

            if (!String.IsNullOrEmpty(_Acronimo)) lcText = lcText.Replace(_Acronimo, "");
            lcText = lcText.TrimStart();

            return lcText;
        }


        private void reordenarPantallasToolStripMenuItem_Click(object sender, EventArgs e)
        {
            // PE-103085 
            //NETVFP._Reordenar_Pantallas(); 
            //NETVFP._Ejecutar_Funcion_VFP("fPripals50.Reordenar_pantallas");
        }

        private void contextMenuStripPantalla_Opening(object sender, CancelEventArgs e)
        {
            contextMenuStripPantalla.Items["gestiónDeFavoritosToolStripMenuItem"].Image = sage.ew.images.Properties.Resources.favorite_16;
            contextMenuStripPantalla.Items["gestiónDeAccesosToolStripMenuItem"].Image = sage.ew.images.Properties.Resources.access_16;
            contextMenuStripPantalla.Items["crearAccesoDirectoToolStripMenuItem"].Image = sage.ew.images.Properties.Resources.link_16;
            contextMenuStripPantalla.Items["crearTareaProgramadaItem"].Image = sage.ew.images.Properties.Resources.TimeProgram; //TODO: utilizar otro icono
            contextMenuStripPantalla.Items["ShowPropertiesToolStripMenuItem"].Image = _oTimerProperties is null ? Resources.led_green_16 : Resources.led_red_16;

            bool lbSage50 = Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_sage50"));

            //Acces directe sols per a Sage50
            if (!lbSage50)
                contextMenuStripPantalla.Items["crearAccesoDirectoToolStripMenuItem"].Visible = false;
            else
                contextMenuStripPantalla.Items["crearAccesoDirectoToolStripMenuItem"].Visible = _MostrarCrearAccesoDirecto;  // PE-99866. Comprobar si mostar el ménu crear acceos directos            

            //Task 104592: Crear tarea programada
            if (!lbSage50)
                contextMenuStripPantalla.Items["crearTareaProgramadaItem"].Visible = false;
            else
                contextMenuStripPantalla.Items["crearTareaProgramadaItem"].Visible = _MostrarCrearTareaProgramada;

            //PE-96746
            contextMenuStripPantalla.Items["crearApunteCalendarioItem"].Image = sage.ew.images.Properties.Resources.calendar_16;

            //PE-103520 : listados personalizables
            contextMenuStripPantalla.Items["listadosPersonalizablesEditarItem"].Image = sage.ew.images.Properties.Resources.mant_edit_16;
            contextMenuStripPantalla.Items["listadosPersonalizablesDuplicarItem"].Image = sage.ew.images.Properties.Resources.duplicate_16;


            if (this is sage.ew.formul.Forms.FormListado)
            {
                if (!((sage.ew.formul.Forms.FormListado)this)._Personalizado)
                {
                    contextMenuStripPantalla.Items["listadosPersonalizablesEditarItem"].Visible = false;
                    if (!lbSage50)
                    {
                        contextMenuStripPantalla.Items["listadosPersonalizablesDuplicarItem"].Visible = false;
                    }
                    else
                    {
                        contextMenuStripPantalla.Items["listadosPersonalizablesDuplicarItem"].Visible = _MostrarDuplicarListado;
                    }
                }
            }
            else
            {
                contextMenuStripPantalla.Items["listadosPersonalizablesEditarItem"].Visible = false;
                contextMenuStripPantalla.Items["listadosPersonalizablesDuplicarItem"].Visible = false;
            }

            ConfigureConfigUserOptions();

            //PE-104540 - PE-104527 : Amagar l'opció de "Duplicar y editar el listado personalizable"
            //contextMenuStripPantalla.Items["listadosPersonalizablesDuplicarItem"].Visible = false;
        }

        private void ConfigureConfigUserOptions()
        {
            configuracionesUsuarioItem.Image = sage.ew.images.Properties.Resources.icon_wrench;

            if (Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_sage50")) && _ConfigUserOptionsAllowed)
            {
                // Guardar "Última configuración"
                //ConfigUserOptionsUpdateLastValues();

                configuracionesUsuarioItem.Visible = true;
                configuracionesUsuarioItemSeparator.Visible = true;
                configuracionesUsuarioItem.DropDownItems.Clear();

                configuracionesUsuarioItem.DropDownItems.Add(toolConfiguracionesToolStripMenuItem);

                // Mostrar configuraciones de usuario                
                IEnumerable<ConfigUserForm> loList = _ConfigUserForm._ListaConfiguraciones().AsEnumerable();
                IEnumerable<ConfigUserForm> loListConfUsers = loList.Where(f => f._Tipo == ConfigUserForm.ConfigUserType.UserValuesConfig);
                IEnumerable<ConfigUserForm> loListDefaultConfUsers = loList.Where(f => f._Tipo != ConfigUserForm.ConfigUserType.UserValuesConfig);

                // Mostrar configuraciones del usuario
                _GenerateMenuItemsConfigUser(loListConfUsers.Where(f => !f._Publico));
                // Mostrar configuraciones públicas
                _GenerateMenuItemsConfigUser(loListConfUsers.Where(f => f._Publico));
                // Mostrar configuraciones base
                _GenerateMenuItemsConfigUser(loListDefaultConfUsers);
            }
            else
            {
                configuracionesUsuarioItem.Visible = false;
                configuracionesUsuarioItemSeparator.Visible = false;
            }
        }

        private void _GenerateMenuItemsConfigUser(IEnumerable<ConfigUserForm> toListConfigUsers)
        {
            if (toListConfigUsers != null && toListConfigUsers.Count() > 0)
            {
                configuracionesUsuarioItem.DropDownItems.Add(new ToolStripSeparator());

                foreach (ConfigUserForm loConfig in toListConfigUsers)
                {
                    ToolStripMenuItem loMenuItem = new ToolStripMenuItem();

                    loMenuItem.Text = loConfig._Config;
                    loMenuItem.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
                    loMenuItem.Click += LoadConfigUserMenuItem_Click;
                    loMenuItem.Tag = loConfig;

                    if (_ConfigUserForm._Config.Trim() == loConfig._Config.Trim()) loMenuItem.Image = sage.ew.images.Properties.Resources.icon_right;

                    configuracionesUsuarioItem.DropDownItems.Add(loMenuItem);
                }
            }
        }

        private void LoadConfigUserMenuItem_Click(object sender, EventArgs e)
        {
            if (sender is ToolStripMenuItem && ((ToolStripMenuItem)sender).Tag is ConfigUserForm)
            {
                ConfigUserForm loConfig = ((ToolStripMenuItem)sender).Tag as ConfigUserForm;

                // Antes de cargar la nueva configuración, guardamos "Última configuración"
                //ConfigUserOptionsUpdateLastValues();

                // Cargar nueva configuración
                _ConfigUserForm = loConfig;
                _ConfigUserOptionsLoad(_oConfigUserForm._dicOpciones);
            }
        }

        protected bool _PresentarApunteCalendario()
        {
            return sage.ew.functions.FUNCTIONS._PermitirApunteCalendario(_Pantalla);
        }

        #region Forzar Fuente

        protected override void OnShown(EventArgs e)
        {
            base.OnShown(e);

            if (EW_GLOBAL._EsEjecutable && _CambiarFuente)
            {
                if (Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_sage50")))
                {
                    if (estiloRevisado == false)
                    {
                        foreach (Control loControl in Controls)
                        {
                            FUNCTIONS._Cambiar_Font(loControl, "Segoe UI");
                        }
                    }
                }
                else
                {
                    foreach (Control loControl in Controls)
                    {
                        FUNCTIONS._Cambiar_Font(loControl, "Arial");
                    }
                }
            }

            // Bug 111565. En caso de abrir un formulario en modo MODAL, no dejamos minimizarlo
            if (this.Modal)
                this.MinimizeBox = false;

            //Asignem els parametres del formulari suposant que en tingui
            this._EstablecerParametrosFormulario();
        }

        #endregion Forzar Fuente

        protected List<ToolStripMenuItemBase> _ToolStripMenuItemsBase = new List<ToolStripMenuItemBase>();

        protected internal ToolStripMenuItemBase _AddToolStripMenuItemBase(string tcNombre, string tcNombre_Objeto, string tcTooltip)
        {
            ToolStripMenuItemBase loToolStripMenuItem = new ToolStripMenuItemBase(tcNombre, tcNombre_Objeto, tcTooltip);

            _ToolStripMenuItemsBase.Add(loToolStripMenuItem);

            return loToolStripMenuItem;
        }

        protected internal void _GetOpcionesInvoke(object sender)
        {
            if (this is frmGestionPerfil || this is contabilidad.frmAsientos || this is frmListasPrevias || this.Name == "frmPrincipal") 
                _GetOpciones?.Invoke(new EventArgsOpciones(sender, _ToolStripMenuItemsBase));
            else
                throw new Exception("Este formulario no tiene ningún botón de Opciones o no está preparado para acceder a él");
        }

        private void GetOpcionesHerramientasInvoke(object sender , List<ToolStripMenuItemBase> tlstToolStripMenuItemsBase)
        {
           _GetOpcionesHerramientas?.Invoke(new EventArgsOpciones(sender, tlstToolStripMenuItemsBase));
        }

        // Task 111119 - 115209 
        public virtual bool _InsertarObjetoAddon(Control toControl)
        {
            bool lITabDocAddon = false, llOk = true;
            Control loControlContenedor = this; // Asignamos donde vamos a agregar los controles
            string lcNombre_Objeto = toControl.Name;

            lITabDocAddon = toControl is IAddonTabDoc;

            if (lITabDocAddon)
                llOk = AddonInsertarTabDocAddon(toControl, ref loControlContenedor);
            else if ((toControl is IAddonBotonMenuDoc) && (toControl is Button)) // Task 123210: Creación de botones en la barra de herramientas de los Mantes
                llOk = AddonBotonMenuDoc(toControl);

            if (llOk)
                loControlContenedor.Controls.Add(toControl);

            return llOk;
        }

        public virtual bool _InsertarObjetoAddon(ToolStripItem toolStripButtonAddonMante)
        {
            return true;
        }

        protected internal virtual void _AddonPrepararMenu(ewcontextmenustrip toMenuStrip)
        {
            if (this.lstOpcionesMenuAddon != null && this.lstOpcionesMenuAddon.Count > 0)
            {
                string lcTituloMenu, lcName;
                bool llSeparador = true;

                foreach (Control loControl in this.lstOpcionesMenuAddon)
                {
                    lcTituloMenu = ((IAddonBotonMenuDoc)loControl)._TituloMenu.Trim();

                    if (llSeparador && toMenuStrip.Items.Count > 0) // Añadimos un separador
                    {
                        toMenuStrip.Items.Add("-");
                        llSeparador = false;
                    }

                    toMenuStrip.Items.Add(lcTituloMenu);

                    lcName = loControl.Name;

                    if (string.IsNullOrWhiteSpace(lcName)) // Si el botón no tiene nombre le voy a asignar uno. Luego se realizará una búsqueda por el nombre del control
                    {
                        lcName = Convert.ToString(Guid.NewGuid()).ToUpper();
                        loControl.Name = lcName;
                    }

                    toMenuStrip.Items[toMenuStrip.Items.Count - 1].Name = lcName;
                    toMenuStrip.Items[toMenuStrip.Items.Count - 1].Click += new EventHandler(FormManteOpcionesAddon_Click);
                }
            }
        }
        // FTask 123210: Creación de botones en la barra de herramientas de los Mantes

        private void FormManteOpcionesAddon_Click(object sender, EventArgs e)
        {
            string lcName = (sender as ToolStripMenuItem).Name;

            Control[] loControl = this.Controls.Find(lcName, true);

            if (loControl != null)
            {
                try
                {
                    ((ewbutton)loControl[0]).Enabled = true;
                    ((ewbutton)loControl[0]).PerformClick(); // No sabemos el código que se ha programado. Si da error ...
                }
                catch (Exception loEx)
                {
                    if (Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_prueva")) || System.Diagnostics.Debugger.IsAttached) // Gestión de error
                        this._MessageBox("Se ha producido la siguiente incidencia en la ejecución de la opción " + (sender as ToolStripMenuItem).Text.Trim() + ": " + Environment.NewLine + Environment.NewLine + loEx.Message, MessageBoxButtons.OK, MessageBoxIcon.Exclamation, MessageBoxDefaultButton.Button1, DialogResult.OK);
                }
            }
        }

        private bool AddonBotonMenuDoc(Control toControl)
        {
            IAddonBotonMenuDoc loIAddonBotonMenuDoc = (IAddonBotonMenuDoc)toControl;

            this.lstOpcionesMenuAddon.Add(toControl); // Añadimos  la opción a la lista

            // La propiedad _Menu no la vamos a utilizar, únicamente es para los perfiles
            if (string.IsNullOrWhiteSpace(loIAddonBotonMenuDoc._TituloMenu) && toControl is ewbutton && !string.IsNullOrWhiteSpace(toControl.Text)) // Si no tiene título la opción, asignaremos el texto del botón
                loIAddonBotonMenuDoc._TituloMenu = toControl.Text;

            // Cambiamos la posición del control para que no se vea. No lo podemos hacer invisible o al hacer el PerformClick no se ejecutará
            toControl.Left = -10000;
            toControl.Top = -10000;
            toControl.Width = 1;
            toControl.Height = 1;

            AddonBotonMenuDocDocumento(toControl);

            return true;
        }

        private void AddonBotonMenuDocDocumento(Control toControl)
        {
            dynamic loDocumento = null;

            if (toControl is IAddonBotonMenuDoc)
            {
                if (this is FormMante)
                    loDocumento = ((FormMante)this)._ewMante;
                else if (this is FormBaseDocumento)
                    loDocumento = ((FormBaseDocumento)this)._Documento;

                if (loDocumento != null)
                {
                    IAddonBotonMenuDoc loIAddonBotonMenuDoc = ((IAddonBotonMenuDoc)toControl);
                    loIAddonBotonMenuDoc._Documento = loDocumento;
                }
            }
        }

        private void ControlRefreshRecursive(Control toContenedor, bool tlChild = false)
        {
            if (!toContenedor.HasChildren)
                return;

            foreach (Control loControlChild in toContenedor.Controls)
                _ControlRefresh(loControlChild, tlChild);
        }

        public void _ControlRefresh(Control toControl, bool tlChild = false)
        {
            if (toControl == null)
                return;

            dynamic loControlDynamic = toControl;
            bool llRefresh = (toControl is IAddonTabDoc);

            if (llRefresh)
            {
                Type ltType = Type.GetType(loControlDynamic.GetType().AssemblyQualifiedName);

                MethodInfo objMethod = ltType.GetMethod("_Refresh"); // Busca la propiedad pública con el nombre especificado, si no la encuentra devuelve null
                llRefresh = (objMethod != null);
            }

            if (llRefresh)
            {
                try
                {
                    loControlDynamic._Refresh();
                }
                catch (Exception loEx)
                {
                    if (Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_prueva")) || System.Diagnostics.Debugger.IsAttached)
                        this._MessageBox("Se ha producido la siguiente incidencia en la ejecución del método Refresh del control " + toControl.Name + ": " + Environment.NewLine + Environment.NewLine + loEx.Message, MessageBoxButtons.OK, MessageBoxIcon.Exclamation, MessageBoxDefaultButton.Button1, DialogResult.OK);
                }
            }

            ControlRefreshRecursive(toControl);
        }

        private void ControlDocumentoRecursive(Control toContenedor, dynamic toDocumento, bool tlChild = false)
        {
            if (!toContenedor.HasChildren)
                return;

            foreach (Control loControlChild in toContenedor.Controls)
                _ControlDocumento(loControlChild, toDocumento, tlChild);
        }

        public void _ControlDocumento(Control toControl, dynamic toDocumento, bool tlChild = false)
        {
            if (toControl == null || toDocumento == null)
                return;

            dynamic loControlDynamic = toControl;
            bool llDocumento = (toControl is IAddonTabDoc);

            if (!llDocumento)
            {
                Type ltType = Type.GetType(loControlDynamic.GetType().AssemblyQualifiedName);

                MemberInfo[] objMember = ltType.GetMember("_Documento");
                llDocumento = (objMember.Length > 0);
            }

            if (llDocumento)
            {
                try
                {
                    loControlDynamic._Documento = toDocumento;
                }
                catch (Exception loEx)
                {
                    if (Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_prueva")) || System.Diagnostics.Debugger.IsAttached)
                        this._MessageBox("Se ha producido la siguiente incidencia en la asignación del documento al control " + toControl.Name + ": " + Environment.NewLine + Environment.NewLine + loEx.Message, MessageBoxButtons.OK, MessageBoxIcon.Exclamation, MessageBoxDefaultButton.Button1, DialogResult.OK);
                }
            }

            ControlDocumentoRecursive(toControl, toDocumento, tlChild);
        }

        private bool AddonInsertarTabDocAddon(Control toControl, ref Control toControlContenedor)
        {
            bool llOk = false;
            ewtabcontrol loewtabcontrol = null;

            foreach (Control loControl in Controls) // De momento no es necesario realizarlo recursivamente
            {
                if (loControl is ewtabcontrol)
                {
                    loewtabcontrol = (ewtabcontrol)loControl;
                    break;
                }
            }

            if (loewtabcontrol != null)
            {
                Control loPagina = AddonNuevaPaginaTabDoc(toControl, loewtabcontrol);

                ewFlowLayoutPanel loewFlowLayoutPanel = this.AddonNuevoFlowLayoutPanel();
                loewFlowLayoutPanel.Size = loewtabcontrol.TabPages[0].Size; // Asignamos las dimensiones de la primera página
                loewFlowLayoutPanel.Dock = DockStyle.Fill;
                loPagina.Controls.Add(loewFlowLayoutPanel);  // Agregamos el flowlayout a la página para la gestión de las barras
                loPagina.Dock = DockStyle.Fill;

                toControlContenedor = loewFlowLayoutPanel; // Agregaremos el addon en el flowlayout de la página, por tanto actualizamos el controlContenedor

                llOk = true;
            }

            return llOk;
        }

        private ewFlowLayoutPanel AddonNuevoFlowLayoutPanel()
        {
            ewFlowLayoutPanel loewFlowLayoutPanel = new ewFlowLayoutPanel();

            loewFlowLayoutPanel.AutoScroll = true;
            loewFlowLayoutPanel.WrapContents = true;

            //if llResizeAddon
            // loewFlowLayoutPanel.Dock = System.Windows.Forms.DockStyle.Fill; // MEJORA: _Resize: Si nos interesa que el usuario gestiona el resize
            // loewFlowLayoutPanel.Size = toControl.Size; // Asignamos las dimensiones del control

            return loewFlowLayoutPanel;
        }

        private string AddonNombrePagina(ewtabcontrol toewtabcontrol)
        {
            string lcName = string.Empty;

            lcName = "AddonPagina" + Convert.ToString(toewtabcontrol.TabPages.Count);

            return lcName;
        }

        private Control AddonNuevaPaginaTabDoc(Control toControl, ewtabcontrol toewtabcontrol)
        {
            Control loControlewTabPage = null;
            string lcewtabcontrol = toewtabcontrol.Name, lcTitulo = string.Empty, lcName = string.Empty;
            IAddonTabDoc loIAddonTabDoc = (IAddonTabDoc)toControl;

            loControlewTabPage = new ewTabPage();

            lcName = toControl.Name;

            if (string.IsNullOrWhiteSpace(lcName))
                lcName = AddonNombrePagina(toewtabcontrol);

            loControlewTabPage.Name = lcName;
            loControlewTabPage.Text = loIAddonTabDoc._TituloPagina; // Indicamos el título de la página

            toewtabcontrol.Controls.Add(loControlewTabPage);

            if (loIAddonTabDoc._Principal) // Añadimos el tabpage como página principal
            {
                ewTabPage loewTabPage = (ewTabPage)loControlewTabPage;

                CambiarIndiceTabpage(toewtabcontrol, loewTabPage, 0);
            }

            return loControlewTabPage;
        }

        private void CambiarIndiceTabpage(ewtabcontrol toewtabcontrol, ewTabPage toewTabPage, int tnNuevoIndice)
        {
            ewTabPage loewTabPage;

            int lnIndiceTabPage = toewtabcontrol.TabPages.IndexOf(toewTabPage); // Buscamos el índice de la página que hemos agregado

            for (int lnIndice = 0; lnIndice < lnIndiceTabPage; lnIndice++)
            {
                loewTabPage = (ewTabPage)toewtabcontrol.TabPages[0];

                toewtabcontrol.TabPages.Remove(loewTabPage);
                toewtabcontrol.TabPages.Add(loewTabPage);
            }

            // toewtabcontrol.TabPages.Insert(tnNuevoIndice, toewTabPage); // De momento como no funciona, hemos realizado el recorrido de las diferentes páginas
        }

        // FTask 111119 - 115209

        #region Ayuda contextual
        private bool _lFormActivated = true;
        private bool _lPresentandoAyuda = false;
        private BackgroundWorker _oBackgroundWorker;
        private FormPanelNotificaciones _oFormAyuda = null;

        private string _cTituloFormulario = "";

        public struct oResultadoAyuda
        {
            public bool _Ayuda
            {
                get { return _lAyuda; }
                set { _lAyuda = value; }
            }
            bool _lAyuda;

            public IAyudaContextual _AyudaContextual
            {
                get { return _oAyudaContextual; }
                set { _oAyudaContextual = value; }
            }
            IAyudaContextual _oAyudaContextual;

            public IOnBoardingController _OnBoardingController
            {
                get { return _oOnBoardingController; }
                set { _oOnBoardingController = value; }
            }
            IOnBoardingController _oOnBoardingController;
        }

        private bool AyudaActiva()
        {

            if (Usuario._This._Opcesp("5004")) // No presentar ayuda en pantallas de Sage 50c
                return false;

            bool llActiva = true;

            object loObject = EW_GLOBAL._GetVariable("wl_DesactivarOnBoarding");

            if (loObject != null)
            {
                try
                {
                    llActiva = !Convert.ToBoolean(loObject); // Tendremos que "wl_DesactivarOnBoarding" es true por eso negamos
                }
                catch (Exception)
                {
                }
            }

            return llActiva;
        }

        protected virtual string _PantallaAyuda
        {
            get { return _Pantalla; }
        }

        private bool _lPantalla0Showed = false;

        private bool _lPantalla0ShowAfterLogin = false;

        private void AyudaOnBoarding()
        {
            if (!IsDisposed && !Disposing )
            {
                if (BarrasAyudaActivas())
                {
                    if (string.IsNullOrWhiteSpace(_PantallaAyuda) || !AyudaActiva() || botonayuda == eAyudaContextual.Desactivada)
                    {
                        _FormSagePanel?._Show(_ButtonsSagePanel, this);
                    }
                    else
                    {
                        // Declaro un nuevo elemento
                        _oBackgroundWorker = new BackgroundWorker();
                        _oBackgroundWorker.WorkerSupportsCancellation = true;
                        _oBackgroundWorker.WorkerReportsProgress = false;

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

                        // Ejecución asíncrona
                        _oBackgroundWorker.RunWorkerAsync();
                    }
                }
            }
        }

        private bool BarrasAyudaActivas()
        {
            DataTable loDt = new DataTable();
            string lcDataBase, lcComunes, lcSql;

            if (!EW_GLOBAL._ContainsKey("wl_barras_ayuda_form"))
            {
                lcComunes = GrupoEmpresa._DbComunesRealGrupoPripal();
                lcDataBase = DB.SQLDatabaseReal(lcComunes, "VARIABLE");

                lcSql = $"SELECT VALOR FROM {lcDataBase} WHERE VARIABLE = 'NO_AYUDA' ";
                if(DB.SQLExec(lcSql, ref loDt)) EW_GLOBAL.ValorEnClave_VarGlob("wl_barras_ayuda_form", loDt.Rows.Count == 0);
            }

            return Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_barras_ayuda_form", true));
        }

        private void _ExecuteRunWorkerAyuda(object sender, DoWorkEventArgs e)
        {
            oResultadoAyuda loResult = new oResultadoAyuda();
            loResult._Ayuda = false; // Asignamos el false por defecto

            try
            {
                IOnBoardingController loOnBoardingController = FUNCTIONS._OnBoardingController();

                if (loOnBoardingController != null && !loOnBoardingController._PlayingVideo)
                {
                    IAyudaContextual loAyudaContextual = new AyudaContextual(loOnBoardingController);
                    loAyudaContextual._Load(_PantallaAyuda.ToUpper());

                    if (loAyudaContextual != null && (loAyudaContextual._Categorias.Count > 0 || loAyudaContextual._NumeroTotalNoticias > 0))
                    {
                        loResult._OnBoardingController = loOnBoardingController;
                        loResult._AyudaContextual = loAyudaContextual;
                        loResult._Ayuda = true;
                    }
                }
            }
            catch (Exception loEx)
            {
                DB.Registrar_Error(loEx);
            }

            e.Result = loResult; // Asignamos el retorno
        }

        private void _RunWorkerCompletedAyuda(object sender, RunWorkerCompletedEventArgs e)
        {
            if (!e.Cancelled && e.Error == null &&!FormDisposed()) // Si no he sido cancelado ni he registrado excepción 
            {
                _oResultadoAyuda = ((oResultadoAyuda)e.Result);

                if (_oResultadoAyuda._Ayuda)
                    _BotonAyuda = eAyudaContextual.Si;

                //CambiarBotonAyudaMensaje();

                if (PresentarAyudaNuevasNoticias(_oResultadoAyuda))
                {
                    if (EsPantalla0)
                    {
                        _oResultadoAyuda._Ayuda = true;

                        if (_lPantalla0ShowAfterLogin && !_lPantalla0Showed && Ayuda_FormularioActivo()) // Si ha entrado el Usuario y no ha presentado aún el WalkTrought, ahora lo presentamos si no hay ninguna pantalla abierta
                            _WalkthroughsPantalla0();
                    }
                    //else
                    //    MostrarAyuda(_oResultadoAyuda._AyudaContextual);
                }

                _FormSagePanel?._Show(_ButtonsSagePanel, this);
            }
        }

        private bool PresentarAyudaNuevasNoticias(oResultadoAyuda toResultadoAyuda)
        {

            // Si la pantalla no tiene ayuda podemos salir
            if (!_oResultadoAyuda._Ayuda) 
                return false;

            // Tenemos activada la ayuda
            if ( _oResultadoAyuda._AyudaContextual._PresentacionAyuda != Presentacion.No)
                return true;

            // Existe alguna noticia nueva a partir de la fecha que el usuario marcó no volver a presentar la ayuda
            if (_oResultadoAyuda._AyudaContextual._NoticiasNuevasPendientesLeer > 0)
                return true;

            return false;
        }

        private bool EsPantalla0
        {
            get { return _PantallaAyuda == "PANTALLA0"; }
        }

        protected bool _WalkthroughsPantalla0()
        {
            _lPantalla0ShowAfterLogin = true; // Marcamos que ya ha pasado por el AfterLogin que es el único lugar de donde se realiza la llamada

            if (EsPantalla0 && !FUNCTIONS._CanUseWebView()) // No presentamos mensaje, validamos si tenemos el RunTime del WebView2 independientemente de que tengamos o no información de la pantalla 0
                return false;

            if (_oResultadoAyuda._Ayuda == false || !EsPantalla0 || _lPantalla0Showed)
                return false;

            _lPantalla0Showed = true; // De momento marcamos que ya se ha visto o podrian salir dos instancias

            IOnBoardingController loOnBoardingController = FUNCTIONS._OnBoardingController();

            if (loOnBoardingController != null)
            {
                _lPantalla0Showed = ((OnBoardingControllerSage50)loOnBoardingController)._ShowWalkthroughs(_oResultadoAyuda._AyudaContextual);

                return _lPantalla0Showed;
            }
            else
                return false;
        }

        private Point CalculateLocationAyuda(Rectangle toRectangle)
        {
            Rectangle loRectScreen = Screen.PrimaryScreen.WorkingArea;
            Point loPoint = toRectangle.Location;
            int lnOffsetX = 20, lnOffsetY = 50;

            if (Location.X < 0) // Tenemos pantallas como los mantenimientos o perfiles donde el formulario se presenta en una posición fuera de la area visible
            {
                loPoint.X = (loRectScreen.Width / 2) + (Size.Width / 2) - lnOffsetX;
                loPoint.Y = (loRectScreen.Height / 2) - (Size.Height / 2) + lnOffsetY;
            }
            else
            {
                loPoint.X = Location.X + Size.Width - lnOffsetX;
                loPoint.Y = Location.Y + lnOffsetY;
            }

            if (loPoint.X + toRectangle.Size.Width > loRectScreen.Width)
                loPoint.X = loRectScreen.Width - lnOffsetX - toRectangle.Width;

            if (loPoint.Y + toRectangle.Size.Height > loRectScreen.Height)
                loPoint.Y = (loRectScreen.Height / 2) - (toRectangle.Height / 2);

            return loPoint;
        }

        private void LocationAyuda(IAyudaContextual toAyudaContextual)
        {
            Point loPoint = new Point(toAyudaContextual._Left, toAyudaContextual._Top);

            if (loPoint == new Point(0, 0) ||
                loPoint.X > Screen.PrimaryScreen.Bounds.Size.Width || loPoint.Y > Screen.PrimaryScreen.Bounds.Size.Height)
            {
                loPoint = CalculateLocationAyuda(_oFormAyuda.Bounds);
            }

            if (toAyudaContextual._Height > 0)
            {
                Size loSize = _oFormAyuda.Size;
                loSize.Height = toAyudaContextual._Height;

                if (_oFormAyuda.Size != loSize)
                    _oFormAyuda.Size = loSize;
            }

            _oFormAyuda.Location = loPoint;
        }

        protected virtual bool FormDisposed()
        {
            return (IsDisposed || Disposing);
        }

        private void CambiarBotonAyudaMensaje()
        {
            if (!EsPantalla0 && _oResultadoAyuda._AyudaContextual != null && !FormDisposed())
            {
                int numnoticias = _oResultadoAyuda._AyudaContextual._NoticiasPendientesLeer;

                if(menu is IActiveMenu)
                {
                    foreach (ActiveButton item in menu.Items)
                    {
                       
                        if (item.Name == "Ayuda")
                        {
                            // NOTICIAS ONBOARDING. Si tenemos noticias, sustituimos icono de Info por la Campana 
                            if (numnoticias > 0)
                            {
                                string lcTooltip = " Noticias";                                                                
                                item.ForeColor = Color.FromArgb(0, 129, 70);
                                item.Font = new Font("Segoe UI", 8.5F);                                
                                item._ModColors = false;

                                if (numnoticias == 1)
                                {
                                    item.Text = "1";
                                    lcTooltip = " Noticia";
                                }
                                else if (numnoticias < 100)
                                    item.Text = numnoticias.ToString().Trim();
                                else
                                    item.Text = "99+";

                                item.Image = sage.ew.images.Properties.Resources.bell_green_16;
                                menu.ToolTip.SetToolTip(item, item.Text+lcTooltip);
                                item.ChangeColors(); 
                            }

                            break;
                        }
                    }
                }
            }
        }

        private void MostrarCfgUsabilidad()
        {
            // En el formulario de configuración se comprueba si hay mensajes configurados en el formulario/usuario actual
            // y se muestra mensaje sino hay y se cierra.
            frmUserFormConfig frmCfg = new frmUserFormConfig(Usuario._This._Codigo, this._Pantalla, this._ObtenerText(false));
            frmCfg._ShowDialog();
        }

        private void MostrarAyuda(IAyudaContextual toAyudaContextual = null)
        {
            if (_oFormAyuda != null && !_oFormAyuda.IsDisposed && !_oFormAyuda.Disposing)
            {
                ShowAyuda();
                return;
            }

            if (FormDisposed())
                return;

            IOnBoardingController loOnBoardingController = FUNCTIONS._OnBoardingController();

            if (toAyudaContextual == null) // Venimos del botón de opciones. Se ha de instanciar la ayuda contextual
            {
                toAyudaContextual = new AyudaContextual(loOnBoardingController);
                toAyudaContextual._Load(_Pantalla.ToUpper());

                ((OnBoardingControllerSage50)loOnBoardingController)._WebService("mostrar", tcPantalla: _Pantalla.ToUpper()); // Acción de mostrar ayuda
            }

            if (FormDisposed())
                return;

            _oFormAyuda = new FormPanelNotificaciones(_Pantalla.ToUpper(), Text, loOnBoardingController, toAyudaContextual);
            _oFormAyuda.Owner = this;
            _oFormAyuda.Opacity = 0;
            _oFormAyuda._RefreshNoticiasPendientes += FormAyuda__RefreshNoticiasPendientes;

            _oFormAyuda.Show();

            LocationAyuda(toAyudaContextual);

            if (FormDisposed())
            {
                _oFormAyuda.Dispose();
                _oFormAyuda = null;
                return;
            }

            if (_lFormActivated)
                _oFormAyuda.Opacity = 1;
            else
                _oFormAyuda._Hide();

            AyudaSubscripcionEventos();
        }

        private void FormAyuda__RefreshNoticiasPendientes()
        {
            CambiarBotonAyudaMensaje();
        }

        private void DevolverFocusAyuda()
        {
            _oFormAyuda._FormParentStateActived = true;
            Focus(); // Pasamos el foco al formulario de origen

            RepaintActiveButton();
        }

        private void RepaintActiveButton()
        {
            foreach (Control loItem in menu.Items)
            {
                if (loItem is ActiveButton)
                    ((ActiveButton)loItem)._Refresh();
            }
        }

        private void AyudaSubscripcionEventos()
        {
            FormClosed += Ayuda_FormClosed;
            SizeChanged += Ayuda_SizeChanged;
        }

        private void Ayuda_SizeChanged(object sender, EventArgs e)
        {
            if (AyudaIsPlayingVideo())
                return;

            if (WindowState == FormWindowState.Minimized)
            {
                if (_oFormAyuda != null && !_oFormAyuda.IsDisposed && !_oFormAyuda.Disposing && _oFormAyuda.Visible && !_lPresentandoAyuda)
                    OcultarAyuda();
            }
            else
            {
                if (AyudaOcultada())
                    TimerAyuda();
            }
        }

        private void Ayuda_FormClosed(object sender, FormClosedEventArgs e)
        {
            if (_oFormAyuda != null && !_oFormAyuda.IsDisposed && !_oFormAyuda.Disposing)
                _oFormAyuda.Close();
        }

        private void OcultarAyuda()
        {
            _oFormAyuda._Hide();
        }

        private bool AyudaIsPlayingVideo()
        {
            return _oFormAyuda != null && _oFormAyuda._PlayingVideo;
        }

        private void TimerAyuda()
        {
            Timer loTimerAyuda = new Timer();
            loTimerAyuda.Interval = 100;
            loTimerAyuda.Tick += new EventHandler(TimerAyuda_Tick);
            loTimerAyuda.Start();
        }

        private void TimerAyuda_Tick(object sender, EventArgs e)
        {
            Timer loTimer = (Timer)sender;
            loTimer.Dispose();

            ShowAyuda();
        }

        private void ShowAyuda()
        {
            if (AyudaOcultada())
            {
                _lPresentandoAyuda = true;
                _oFormAyuda._RelocatePoint(); // Reposicionamos la pantalla 

                DevolverFocusAyuda();

                _lPresentandoAyuda = false;
            }
        }

        private bool AyudaOcultada()
        {
            return (!Disposing && !IsDisposed && _oFormAyuda != null && !_oFormAyuda.IsDisposed && !_oFormAyuda.Disposing && (!_oFormAyuda.Visible || _oFormAyuda.Opacity == 0) && !_oFormAyuda._OcultandoAyuda && (WindowState != FormWindowState.Minimized || Location.X > 0)); // Cuando está minimizada la posición es la -32000
        }

        private void Ayuda_Deactivate(object sender, EventArgs e)
        {
            if (_oFormAyuda == null || AyudaIsPlayingVideo() || Ayuda_FormularioActivo())
                return;

            _lFormActivated = false;

            _oFormAyuda._FormParentStateActived = false;

            if (_oFormAyuda != null && !_oFormAyuda.IsDisposed && !_oFormAyuda.Disposing && _oFormAyuda.Visible && !_oFormAyuda.Focused && !_lPresentandoAyuda)
            {
                Point loPoint = new Point(Cursor.Position.X, Cursor.Position.Y);
                Rectangle loRect = new Rectangle(loPoint, new Size(10, 10));

                if (!_oFormAyuda.Bounds.IntersectsWith(loRect)) // Si estamos pasando el foco a la pantalla de ayuda no la ocultamos
                    OcultarAyuda();
            }
        }

        private bool Ayuda_FormularioActivo()
        {
            return (EW_GLOBAL._OpenForms.Count > 0 && EW_GLOBAL._OpenForms.Peek() == this);
        }

        private void Ayuda_Activated(object sender, EventArgs e)
        {
            _lFormActivated = true;

            if (_oFormAyuda == null || _lPresentandoAyuda)
                return;

            _oFormAyuda._FormParentStateActived = true;

            if (AyudaOcultada())
                TimerAyuda();
        }
        #endregion Ayuda contextual
    }

    #region classe O365CalendarEntryPoint

    public class O365CalendarEntryPoint : ewbase.ewMante
    {
        public static bool _IsAllowed(string tcPantalla, out O365CalendarEntryPoint toClass)
        {
            //string lcSql = "";


            toClass = null;
            return false;
        }

        public override void _Show()
        {
            sage.ew.formul.Forms.frmNuevoEvento loForm = new sage.ew.formul.Forms.frmNuevoEvento();
            //loForm._Asunto = 

        }

        public int _Id { get; set; }
        public new string _Pantalla { get; set; }
        public new string _Nombre { get; set; }
        public string _Valor { get; set; }
        public string _Propiedad { get; set; }

        private bool _LoadCalendarEntryPoint()
        {
            // Declaración de variables
            DataTable ldtMante = new DataTable();
            string lcClase = string.Empty;
            string lcSql = string.Empty;

            // Certificamos que tenemos asignado el nombre del mantenimiento
            if (!string.IsNullOrWhiteSpace(_Pantalla))
            {
                // Consultamos el ID máximo por si tenemos modificaciones
                lcSql = "SELECT pantalla AS pantalla,MAX(id) AS id " +
                        "FROM " + DB.SQLDatabase("comunes", "calendar") + " " +
                        "WHERE pantalla = " + DB.SQLString(_Pantalla) + " " +
                        "GROUP BY pantalla ";

                DB.SQLExec(lcSql, ref ldtMante);

                // Certificamos que existe el mantenimiento
                if (ldtMante != null && ldtMante.Rows.Count > 0)
                {
                    int lnId = Convert.ToInt32(ldtMante.Rows[0]["Id"]);

                    // Preparamos la consulta
                    lcSql = "SELECT pantalla, clase, libreria, nombre, menu, lista " +
                            "FROM " + DB.SQLDatabase("comunes", "calendar") + " " +
                            "WHERE pantalla = " + DB.SQLString(this._Pantalla) + " AND id = " + DB.SQLString(lnId) + " ";

                    DB.SQLExec(lcSql, ref ldtMante);

                    // Certificamos que existe el mantenimiento
                    if (ldtMante != null && ldtMante.Rows.Count > 0)
                    {
                        lcClase = Convert.ToString(ldtMante.Rows[0]["Clase"]).Trim() + "," + Convert.ToString(ldtMante.Rows[0]["Libreria"]).Trim();

                        Type elementType = Type.GetType(lcClase);

                        if (elementType != null)
                        {

                            // Todo ha ido correcto
                            return true;
                        }
                    }
                }
            }

            return false;
        }
    }

    #endregion classe O365CalendarEntryPoint
}