AddonsPropertiesObjects.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using sage.ew.ewbase;
using System.ComponentModel;
using System.Windows.Forms;
using System.Collections;
using sage.ew.objetos.Widgets;
using System.Data;
using System.Reflection;
using sage.addons.components;
using System.Xml.Serialization;

namespace sage.addons.components
{
    public enum DataTypes
    {
        Carácter,
        Booleano,
        Memo,
        Entero,
        Fecha,
        Numérico
    }

    public enum PrimaryKeys
    {
        No,
        Ascendente,
        Descendente
    }

    public enum WidgetTypes
    {
        [Description("Círculo")]
        Círculo,
        [Description("Etiqueta")]
        Etiqueta,
        [Description("Botón")]
        Botón,
        [Description("Texto")]
        Texto,
        [Description("Etiqueta Ratio financiero")]
        EtiquetaRatio,
        [Description("Plataforma Web")]
        PlataformaWeb
    }


    public class WidgetTypesListConverter : TypeConverter
    {
        public override bool GetStandardValuesSupported(ITypeDescriptorContext context)
        {
            return true; // display drop
        }

        public override bool GetStandardValuesExclusive(ITypeDescriptorContext context)
        {
            return true; // drop-down vs combo
        }
        public override StandardValuesCollection GetStandardValues(ITypeDescriptorContext context)
        {
            DataWidgetProperties loData = new DataWidgetProperties();
            // note you can also look at context etc to build list
            return new StandardValuesCollection(loData.GetWidgetTypes());
        }
    }



    public class DataFieldProperties    
    {
        private string nombre = "";
        [
            Bindable(false),
            Category("Diseño"),
            DefaultValue(typeof(string), ""),
            Description("Nombre del campo."),
            Localizable(false),
            DisplayName("(nombre)")
        ]
        public string Nombre
        {
            get { return nombre; }
            set { nombre = value.ToUpper(); }
        }

        private DataTypes tipoDato = DataTypes.Carácter;
        [
            Bindable(false),
            Category("Diseño"),
            DefaultValue(typeof(DataTypes), "Carácter"),
            Description("Tipo de datos."),
            Localizable(false),
            DisplayName("Tipo")
        ]
        public DataTypes TipoDato
        {
            get { return tipoDato; }
            set
            {
                if (tipoDato != value)
                {
                    tipoDato = value;

                    switch (tipoDato)
                    {
                        case DataTypes.Carácter:
                            Longitud = 20;
                            precision = 0;
                            break;
                        case DataTypes.Booleano:
                            Longitud = 0;
                            precision = 0;
                            break;
                        case DataTypes.Memo:
                            Longitud = 0;
                            precision = 0;
                            break;
                        case DataTypes.Entero:
                            Longitud = 0;
                            precision = 0;
                            break;
                        case DataTypes.Fecha:
                            Longitud = 0;
                            precision = 0;
                            break;
                        case DataTypes.Numérico:
                            Longitud = 15;
                            precision = 6;
                            break;
                        default:
                            Longitud = 20;
                            precision = 0;
                            break;
                    }
                }
            }
        }

        private int longitud = 0;
        [
            Bindable(false),
            Category("Diseño"),
            DefaultValue(typeof(int), "0"),
            Description("Longitud del campo."),
            Localizable(false),
            DisplayName("Longitud")
        ]
        public int Longitud
        {
            get { return longitud; }
            set { longitud = value; }
        }

        private int precision = 0;
        [
            Bindable(false),
            Category("Diseño"),
            DefaultValue(typeof(int), "0"),
            Description("Número de decimales para los campos numéricos."),
            Localizable(false),
            DisplayName("Decimales")
        ]
        public int Precision
        {
            get { return precision; }
            set { precision = value; }
        }

        private bool acceptNulls = false;
        [
            Bindable(false),
            Category("Diseño"),
            DefaultValue(typeof(bool), "false"),
            Description("Permite nulos."),
            Localizable(false),
            DisplayName("Permite nulos")
        ]
        public bool AcceptNulls
        {
            get { return acceptNulls; }
            set { acceptNulls = value; }
        }

        private PrimaryKeys clavePrincipal = PrimaryKeys.No;
        [
            Bindable(false),
            Category("Diseño"),
            DefaultValue(typeof(PrimaryKeys), "No"),
            Description("Indica si formará parte de la clave principal."),
            Localizable(false),
            DisplayName("Clave principal")
        ]
        public PrimaryKeys ClavePrincipal
        {
            get { return clavePrincipal; }
            set { clavePrincipal = value; }
        }

        private string defaultValue = "";
        [
            Bindable(false),
            Category("Diseño"),
            DefaultValue(typeof(string), ""),
            Description("Valor por defecto del campo."),
            Localizable(false),
            DisplayName("Valor por defecto")
        ]
        public string DefaultValue
        {
            get { return defaultValue; }
            set { defaultValue = value; }
        }

        private bool debeExistir = false;
        [
            Bindable(false),
            Category("Diseño"),
            DefaultValue(typeof(bool), "false"),
            Description("Indica si el campo debe existir al crear nuevas tablas."),
            Localizable(false),
            DisplayName("Debe existir"),
            Browsable(false)
        ]
        public bool DebeExistir
        {
            get { return debeExistir; }
            set { debeExistir = value; }
        }

        private string campoConfig = "";
        [
            Bindable(false),
            Category("Configuración"),
            DefaultValue(typeof(string), ""),
            Description("Indicar el correspondiente campo ampliable de Sage50."),
            Localizable(false),
            DisplayName("Campo ampliable"),
            TypeConverter(typeof(CamposConfig))
        ]
        public string CampoConfig
        {
            get { return campoConfig; }
            set 
            {
                campoConfig = value; 
            
                // Buscar la longitud del campo ampliable
                Longitud = FuncsDataBase.GetLenCampoConfig(campoConfig);
            }
        }

        private string descripcion = "";
        [
            Bindable(false),
            Category("Diseño"),
            DefaultValue(typeof(string), ""),
            Description("Descripción del campo."),
            Localizable(false),
            DisplayName("Descripción")
        ]
        public string Descripcion
        {
            get { return descripcion; }
            set { descripcion = value; }
        }

        public class CamposConfig : sage.ew.objetos.Widgets.cmb_List
        {
            public override List<string> _CargarDatos(ITypeDescriptorContext context)
            {
                List<string> configList = new List<string>();
                if (context != null && context.Instance != null && context.PropertyDescriptor != null)
                {
                    try
                    {
                        if (FuncsDataBase.ConfigTable != null && FuncsDataBase.ConfigTable.Rows.Count > 0)
                        {
                            foreach (DataRow filtro in FuncsDataBase.ConfigTable.Rows)
                            {
                                configList.Add(filtro["clave"].ToString().Trim());
                            }
                        }
                        else
                        {
                            configList = new List<string>();
                        }
                    }
                    catch (Exception)
                    {
                        configList = new List<string>();
                    }
                }

                return configList;
            }
        }

    }


    public class DataWidgetProperties
    {
        private Dictionary<string, string> dicWidgetTypes = new Dictionary<string, string>();

        public DataWidgetProperties()
        {
            //dicWidgetTypes.Add("Círculo", "Círculo");
            //dicWidgetTypes.Add("Etiqueta", "Etiqueta");
            //dicWidgetTypes.Add("Botón", "Botón");
            //dicWidgetTypes.Add("Texto", "Texto");
            //dicWidgetTypes.Add("EtiquetaRatio", "Etiqueta Ratio financiero");
            LoadDictionaryTipoWidgets();
        }
        

        private string nombre = "";
        [
            Bindable(false),
            Category("Diseño"),
            DefaultValue(typeof(string), ""),
            Description("Nombre del widget."),
            Localizable(false),
            DisplayName("(nombre)"),
            ReadOnly(false)
        ]
        public string Nombre
        {
            get {
                ChangeReadOnlyProperty(this, "Nombre", this.existe);
                return nombre; 
                }
            set { nombre = value; }
        }

        private string titulo = "";
        [
            Bindable(false),
            Category("Apariencia"),
            DefaultValue(typeof(string), ""),
            Description("Título del widget."),
            Localizable(false),
            DisplayName("Título"),
            ReadOnly(false)
        ]
        public string Titulo
        {
            get { return titulo; }
            set { titulo = value; }
        }

        private string descripcion = "";
        [
            Bindable(false),
            Category("Apariencia"),
            DefaultValue(typeof(string), ""),
            Description("Descripción del widget."),
            Localizable(false),
            DisplayName("Descripción"),
            ReadOnly(false)

        ]
        public string Descripcion
        {
            get { return descripcion; }
            set { descripcion = value; }
        }

        private string tipoWidget = "Texto";
        [
            Bindable(false),
            Category("Diseño"),
            TypeConverter(typeof(WidgetTypesListConverter)),    
            Description("Tipo de widget."),
            Localizable(false),
            DisplayName("Tipo"),
            ReadOnly(false)
        ]
        public string TipoDato
        {
            get {
                ChangeReadOnlyProperty(this, "TipoDato", this.existe);
                return tipoWidget;
                }
            set { 
                    tipoWidget = value;
                    tipodatokey = GetWidgetTypesKey(tipoWidget);
                    WidgetTypes loTypoWidget = GetWidgetTypesKeyEnum(tipoWidget);

                    switch (loTypoWidget)
                    {
                        case WidgetTypes.Círculo:
                            Plantilla = Resources.WidgetCirculo;
                            PlantillaDesigner = Resources.WidgetCirculo_Designer;
                            break;
                        case WidgetTypes.Etiqueta:
                            Plantilla = Resources.WidgetEtiqueta;
                            PlantillaDesigner = Resources.WidgetEtiqueta_Designer;
                            break;
                        case WidgetTypes.Botón:
                            Plantilla = Resources.WidgetBoton;
                            PlantillaDesigner = "";
                            break;
                        case WidgetTypes.Texto:
                            Plantilla = Resources.WidgetTexto;
                            PlantillaDesigner = "";
                            break;
                        case WidgetTypes.EtiquetaRatio:
                            Plantilla = Resources.WidgetContabilidadRatio;
                            PlantillaDesigner = Resources.WidgetContabilidadRatio_Designer;
                            break;
                        case WidgetTypes.PlataformaWeb:
                            Plantilla = Resources.WidgetPlataformaWeb;
                            PlantillaDesigner = "";
                            break;
                        default:
                                Plantilla = "";
                                PlantillaDesigner = "";
                                break;
                    }   
            }
 
        }


        private bool existe = false;
        [
            Bindable(false),
            Category("Apariencia"),
            DefaultValue(typeof(bool), "false"),
            Description("Existe widget."),
            Localizable(false),
            DisplayName("Existe"),
            Browsable(false),
            ReadOnly(false)
        ]
        public bool Existe
        {
            get { return existe; }
            set {
                ChangeReadOnlyProperty(this, "Nombre", value);
                ChangeReadOnlyProperty(this, "TipoDato", value);
                existe = value; 
                }
        }


        private string plantilla = "";
        [
            Bindable(false),
            Category("Apariencia"),
            DefaultValue(typeof(string), ""),
            Description("Plantilla."),
            Localizable(false),
            DisplayName("Plantilla"),
            Browsable(false),
            ReadOnly(false)
        ]        
        public string Plantilla
        {
            get { return plantilla; }
            set { plantilla = value; }
        }

        private string plantillaDesigner = "";
        [
            Bindable(false),
            Category("Apariencia"),
            DefaultValue(typeof(string), ""),
            Description("Plantilla Designer."),
            Localizable(false),
            DisplayName("Plantilla Designer"),
            Browsable(false),
            ReadOnly(false)
        ]        
        public string PlantillaDesigner
        {
            get { return plantillaDesigner; }
            set { plantillaDesigner = value; }
        }

        private string tipodatokey = "";
        [
            Bindable(false),
            Category("Apariencia"),
            DefaultValue(typeof(string), ""),
            Description("Tipo dato clave."),
            Localizable(false),
            DisplayName("Tipo dato clave"),
            Browsable(false),
            ReadOnly(false)
        ]
        public string TipoDatoKey
        {
            get { return tipodatokey; }
            set { 
                    if (tipodatokey != value)
                    {
                       tipodatokey = value;
                       if (dicWidgetTypes.ContainsKey(tipodatokey))
                            TipoDato = dicWidgetTypes[tipodatokey];
                    }
            }
        }



        private void ChangeReadOnlyProperty(object toObj, string tcField, bool tlReadOnly)
        {
            PropertyDescriptor descriptor = TypeDescriptor.GetProperties(toObj.GetType())[tcField];
            ReadOnlyAttribute attrib = (ReadOnlyAttribute)descriptor.Attributes[typeof(ReadOnlyAttribute)];
            FieldInfo loField = attrib.GetType().GetField("isReadOnly", BindingFlags.NonPublic | BindingFlags.Instance);
            loField.SetValue(attrib, tlReadOnly);
        }

        public string[] GetWidgetTypes()
        {
            int nTipos = dicWidgetTypes.Count;   
            string [] Widgets = new string[nTipos];

            int n1 = 0;
            foreach (KeyValuePair<string, string> entry in dicWidgetTypes)
            {
                Widgets[n1] = entry.Value;
                ++n1;
            }

            return Widgets;
        }

        public string GetWidgetTypesKey(string tcValue)
        {
            string lcKey = "";
            foreach (KeyValuePair<string, string> entry in dicWidgetTypes)
            {
                if (entry.Value == tcValue)
                {
                    lcKey = entry.Key;
                    break;
                }
            }
            
            return lcKey;
        }

        public WidgetTypes GetWidgetTypesKeyEnum(string tcValue)
        {
            WidgetTypes loTypeReturn = WidgetTypes.Botón;
            foreach (WidgetTypes loType in Enum.GetValues(typeof(WidgetTypes)))
            {
                string lcDesc = GetEnumDescription(loType);
                if (lcDesc == tcValue)
                {
                    loTypeReturn = loType;
                    break;
                }
            }

            return loTypeReturn;
        }


        private void LoadDictionaryTipoWidgets()
        {
            dicWidgetTypes = new Dictionary<string, string>();
            foreach (WidgetTypes loType in Enum.GetValues(typeof(WidgetTypes)))
                dicWidgetTypes.Add(loType.ToString(), GetEnumDescription(loType));
        }

        private string GetEnumDescription(Enum value)
        {
            FieldInfo fi = value.GetType().GetField(value.ToString());

            DescriptionAttribute[] attributes = fi.GetCustomAttributes(typeof(DescriptionAttribute), false) as DescriptionAttribute[];

            if (attributes != null && attributes.Any())
            {
                return attributes.First().Description;
            }

            return value.ToString();
        }



    }


    public class ewCampoTRelAddons : ew.ewbase.ewCampoTRel
    {
        private string _nombre = "";
        [
            Bindable(false),
            Category("Diseño"),
            DefaultValue(typeof(string), ""),
            Description("Nombre del campo."),
            Localizable(false),
            DisplayName("(nombre)"),
            Browsable(true)
        ]
        public new string _Nombre
        {
            get { return _nombre; }
            set
            {
                string oldname = _nombre;
                _nombre = value;

                if (Nombre_Changed != null)
                    Nombre_Changed(this, value, oldname);
            }
        }

        private bool esClave = false;
        [
            Bindable(false),
            Category("Claves"),
            DefaultValue(typeof(bool), "false"),
            Description("Indica si el campo es parte de la clave principal de la tabla."),
            Localizable(false),
            DisplayName("Es clave"),
            Browsable(true)
        ]
        public new bool EsClave
        {
            get { return esClave; }
            set { esClave = value; }
        }

        private bool esFiltro = false;
        [
            Bindable(false),
            Category("Claves"),
            DefaultValue(typeof(bool), "false"),
            Description("Indica si el campo actuará de filtro para recuperar los datos de la tabla."),
            Localizable(false),
            DisplayName("Es filtro"),
            Browsable(true)
        ]
        public new bool EsFiltro
        {
            get { return esFiltro; }
            set { esFiltro = value; }
        }

        private bool esCampoLinea = false;
        [
            Bindable(false),
            Category("Claves"),
            DefaultValue(typeof(bool), "false"),
            Description("Indica si el campo es del tipo línea."),
            Localizable(false),
            DisplayName("Es campo línea"),
            Browsable(true)
        ]
        public new bool EsCampoLinea
        {
            get { return esCampoLinea; }
            set { esCampoLinea = value; }
        }

        private bool campoAgregado = false;
        [
            Bindable(false),
            Category("Claves"),
            DefaultValue(typeof(bool), "false"),
            Description("Indica si es un campo agregado."),
            Localizable(false),
            DisplayName("Es campo línea"),
            Browsable(false)
        ]
        public new bool CampoAgregado
        {
            get { return campoAgregado; }
            set { campoAgregado = value; }
        }

        internal static string BaseDatosList = "";
        internal static string BaseDatosLogicaList = "";
        private string _validar_Dato_BaseDatos = "";
        [
            Bindable(false),
            Category("Enlace"),
            DefaultValue(typeof(string), ""),
            Description("Base de datos donde se validará si el dato existe."),
            Localizable(false),
            DisplayName("Base datos validar"),
            TypeConverter(typeof(DataBasesList))
        ]
        public new string _Validar_Dato_BaseDatos
        {
            get { return _validar_Dato_BaseDatos; }
            set
            {
                if (_validar_Dato_BaseDatos == value)
                    return;

                _validar_Dato_BaseDatos = value;

                BaseDatosLogicaList = value;
                BaseDatosList = sage.ew.db.DB._oAliasDB[value];

                if (!string.IsNullOrWhiteSpace(BaseDatosList))
                {
                    BaseDatosList = BaseDatosList.Replace("[", "");
                    BaseDatosList = BaseDatosList.Replace("].dbo.", "");
                }
                else
                {
                    BaseDatosList = value;
                }

                _Validar_Dato_Tabla = "";
            }
        }

        internal static string TablaList = "";
        private string _validar_Dato_Tabla = "";
        [
            Bindable(false),
            Category("Enlace"),
            DefaultValue(typeof(string), ""),
            Description("Tabla donde se validará si el dato existe."),
            Localizable(false),
            DisplayName("Tabla validar"),
            TypeConverter(typeof(TablesList))
        ]
        public new string _Validar_Dato_Tabla
        {
            get { return _validar_Dato_Tabla; }
            set
            {
                if (_validar_Dato_Tabla == value)
                    return;

                _validar_Dato_Tabla = value;
                TablaList = value;

                _Validar_Dato_Clave = "";
                _Validar_Dato_Campos = "";
            }
        }

        private string _validar_Dato_Clave = "";
        [
            Bindable(false),
            Category("Enlace"),
            DefaultValue(typeof(string), ""),
            Description("Clave por la cual se buscará el valor a la tabla de validación."),
            Localizable(false),
            DisplayName("Clave validar"),
            TypeConverter(typeof(FieldsList))
        ]
        public new string _Validar_Dato_Clave
        {
            get { return _validar_Dato_Clave; }
            set { _validar_Dato_Clave = value; }
        }

        private string _validar_Dato_Campos = "";
        [
            Bindable(false),
            Category("Enlace"),
            DefaultValue(typeof(string), ""),
            Description("Campos que se recuperarán en la consulta de validación."),
            Localizable(false),
            DisplayName("Campos recuperar"),
            TypeConverter(typeof(FieldsList))
        ]
        public new string _Validar_Dato_Campos
        {
            get { return _validar_Dato_Campos; }
            set { _validar_Dato_Campos = value; }
        }

        internal static string CampoList = "";
        private string _campoTabla = "";
        [
            Bindable(false),
            Category("Enlace"),
            DefaultValue(typeof(string), ""),
            Description("Valor de la tabla actual que se comparará con la clave de la tabla de validación."),
            Localizable(false),
            DisplayName("Campo"),
            TypeConverter(typeof(CamposList))
        ]
        public new string _CampoTabla
        {
            get { return _campoTabla; }
            set
            {
                if (_campoTabla == value)
                    return;

                _campoTabla = value;                
                CampoList = value;
            }
        }

        private string _validar_Dato_CampoTRel_Asignar = "";
        [
            Bindable(false),
            Category("Enlace"),
            DefaultValue(typeof(string), ""),
            Description("Destino de los valores recuperados en la consulta de validación."),
            Localizable(false),
            DisplayName("Campos asignar"),
            TypeConverter(typeof(CamposList))
        ]
        public new string _Validar_Dato_CampoTRel_Asignar
        {
            get { return _validar_Dato_CampoTRel_Asignar; }
            set { _validar_Dato_CampoTRel_Asignar = value; }
        }

        private ewMascara _mascara;
        [
            Bindable(false),
            Category("Diseño"),
            DefaultValue(typeof(ewMascara), null),
            Description("Máscara para columnas numéricas."),
            Localizable(false),
            DisplayName("Máscara números"),
            Browsable(false)
        ]
        public ewMascara _Mascara
        {
            get { return _mascara; }
            set { _mascara = value; }
        }

        private int numeroDecimales = 0;
        [
            Bindable(false),
            Category("Diseño"),
            DefaultValue(typeof(int), "0"),
            Description("Número de decimales para columnas numéricas."),
            Localizable(false),
            DisplayName("Número de decimales")
        ]
        public int NumeroDecimales
        {
            get { return numeroDecimales; }
            set { numeroDecimales = value; }
        }

        private int longitud = 0;
        [
            Bindable(false),
            Category("Diseño"),
            DefaultValue(typeof(int), "0"),
            Description("Longitud del campo."),
            Localizable(false),
            DisplayName("Longitud")
        ]
        public int Longitud
        {
            get { return longitud; }
            set { longitud = value; }
        }

        private bool debeExistir = false;
        [
            Bindable(false),
            Category("Diseño"),
            DefaultValue(typeof(bool), "false"),
            Description("Indica si el campo debe existir al crear nuevas tablas."),
            Localizable(false),
            DisplayName("Debe existir"),
            Browsable(false)
        ]
        public bool DebeExistir
        {
            get { return debeExistir; }
            set { debeExistir = value; }
        }

        public event Nombre_Change_Handler Nombre_Changed;

        public delegate void Nombre_Change_Handler(ewCampoTRelAddons sender, string newname, string oldname);

        public void SetObjectType(string dataType)
        {
            if (dataType == "char")
                _TipoColumna = gridColumnsTypes.Texto;

            if (dataType == "bit")
                _TipoColumna = gridColumnsTypes.Lógico;

            if (dataType == "text")
                _TipoColumna = gridColumnsTypes.Texto;

            if (dataType == "int")
                _TipoColumna = gridColumnsTypes.Entero;

            if (dataType == "date" || dataType == "datetime")
                _TipoColumna = gridColumnsTypes.Fecha;

            if (dataType == "numeric" || dataType == "decimal")
                _TipoColumna = gridColumnsTypes.Número;
        }

        public class DataBasesList : sage.ew.objetos.Widgets.cmb_List
        {
            public override List<string> _CargarDatos(ITypeDescriptorContext context)
            {
                List<string> databasesList = new List<string>();
                if (context != null && context.Instance != null && context.PropertyDescriptor != null)
                {
                    try
                    {
                        // Tomamos las bases de datos cargadas en la DB que son las que se pueden utilizar
                        databasesList = sage.ew.db.DB._oAliasDB.Keys.ToList();

                        // Filtrar las bases de datos que no hay que mostrar
                        for (int i = databasesList.Count - 1; i >= 0; i--)
                        {
                            if (databasesList[i].Length > 4 && databasesList[i].Substring(0, 4) == "COMU" && databasesList[i] != "COMUNES")
                            {
                                databasesList.RemoveAt(i);
                            }

                            if (databasesList[i] == "EUROWINSYS")
                            {
                                databasesList.RemoveAt(i);
                            }

                            if (databasesList[i].All(char.IsDigit))
                            {
                                databasesList.RemoveAt(i);
                            }

                        }
                    }
                    catch (Exception)
                    {
                        databasesList = new List<string>();
                    }
                }
                return databasesList;
            }
        }
        
        public class TablesList : sage.ew.objetos.Widgets.cmb_List
        {
            public override List<string> _CargarDatos(ITypeDescriptorContext context)
            {
                List<string> tablesList = new List<string>();
                if (context != null && context.Instance != null && context.PropertyDescriptor != null)
                {
                    try
                    {
                        DataTable tablesBD = sage.ew.db.DB._DBsInformationSchema(BaseDatosList)._INFORMATION_SCHEMA_TABLES;
                        DataView tablesDBView = tablesBD.DefaultView;
                        tablesDBView.Sort = "TABLE_NAME";

                        foreach (DataRowView table in tablesDBView)
                        {
                            // TODO: Filtrar taules de sistema
                            tablesList.Add(table["TABLE_NAME"].ToString());
                        }
                    }
                    catch (Exception)
                    {
                        tablesList = new List<string>();
                    }
                }

                return tablesList;
            }
        }

        public class FieldsList : sage.ew.objetos.Widgets.cmb_List
        {
            public override List<string> _CargarDatos(ITypeDescriptorContext context)
            {
                List<string> fieldsList = new List<string>();
                DataTable fieldsBD = new DataTable();

                if (context != null && context.Instance != null && context.PropertyDescriptor != null)
                {
                    try
                    {
                        // Campos de la tabla seleccionada
                        fieldsBD = sage.ew.db.DB._TablesInformationSchema(BaseDatosLogicaList, TablaList)._INFORMATION_SCHEMA;
                        DataView fieldsBDView = fieldsBD.DefaultView;
                        fieldsBDView.Sort = "column_name";

                        foreach (DataRowView field in fieldsBDView)
                        {
                            fieldsList.Add(field["column_name"].ToString());
                        }
                    }
                    catch (Exception)
                    {
                        fieldsList = new List<string>();
                    }
                }

                return fieldsList;
            }
        }

        public class CamposList : sage.ew.objetos.Widgets.cmb_List
        {
            public override List<string> _CargarDatos(ITypeDescriptorContext context)
            {
                List<string> tablesList = new List<string>();
                if (context != null && context.Instance != null && context.PropertyDescriptor != null)
                {
                    try
                    {
                        // Campos de la tabla actual incluidos en el asistente
                        foreach (dynamic objectProperties in AddonsExecute.FuncsSourceForProperties.ClassMod.Campos)
                        {
                            if (objectProperties is ewCampoTRelAddons)
                            {
                                tablesList.Add(((ewCampoTRelAddons)objectProperties)._Nombre);
                            }
                        }
                    }
                    catch (Exception)
                    {
                        tablesList = new List<string>();
                    }
                }
                return tablesList;
            }
        }
    }

    public enum ObjectsManteTypes
    {
        TextBox,
        NumericUpDown,
        CheckBox,
        TxtCodLabel,
        DateTimePicker
    }

    public class ManteProperties
    {
        private string nombre = "";
        [
            Bindable(false),
            Category("Diseño"),
            DefaultValue(typeof(string), ""),
            Description("Nombre del mantenimiento."),
            Localizable(false),
            DisplayName("(nombre)"),
            Browsable(false)
        ]
        public string Nombre
        {
            get { return nombre; }
            set { nombre = value; }
        }

        private string titulo = "";
        [
            Bindable(false),
            Category("Diseño"),
            DefaultValue(typeof(string), ""),
            Description("Título del formulario."),
            Localizable(false),
            DisplayName("Título"),
            Browsable(true)
        ]
        public string Titulo
        {
            get { return titulo; }
            set { titulo = value; }
        }

        private string textomenu = "";
        [
            Bindable(false),
            Category("Diseño"),
            DefaultValue(typeof(string), ""),
            Description("Texto que se mostrará en la opción de menú."),
            Localizable(false),
            DisplayName("Texto menú"),
            Browsable(true)
        ]
        public string TextoMenu
        {
            get { return textomenu; }
            set { textomenu = value; }
        }

        private int numtabs = 1;
        [
            Bindable(false),
            Category("Diseño"),
            DefaultValue(typeof(int), "1"),
            Description("Número de páginas donde se colocará el control."),
            Localizable(false),
            DisplayName("Páginas"),
            Browsable(true)
        ]
        public int NumTabs
        {
            get { return numtabs; }
            set 
            {
                if (value == null || value == 0)
                    value = 1;

                numtabs = value;
            }
        }

        private bool addCeros = true;
        [
            Bindable(false),
            Category("Diseño"),
            DefaultValue(typeof(bool), "true"),
            Description("Activado, se añadirán ceros a la izquierda del código hasta cumplimentar su longitud."),
            Localizable(false),
            DisplayName("Añadir ceros"),
            Browsable(true)
        ]
        public bool AddCeros
        {
            get { return addCeros; }
            set
            {
                addCeros = value;
            }
        }

        //private PaginasCollection paginas = new PaginasCollection();
        //[
        //    Bindable(false),
        //    Category("Diseño"),
        //    DefaultValue(typeof(PaginasCollection), null),
        //    Description("Páginas del mantenimiento."),
        //    Localizable(false),
        //    DisplayName("Páginas")
        //]
        //public PaginasCollection Paginas
        //{
        //    get { return paginas; }
        //}

        //public ManteProperties()
        //{
            //paginas.AddPagina += new PaginasCollection.AddPagina_Handler(paginas_AddPagina);
        //}

        //private void paginas_AddPagina(Pagina sender)
        //{
        //    if (AddPagina != null)
        //        AddPagina(sender);
        //}

        //public event AddPagina_Handler AddPagina;

        //public delegate void AddPagina_Handler(Pagina sender);
    }

    public class ModManteProperties
    {
        private string nombre = "";
        [
            Bindable(false),
            Category("Diseño"),
            DefaultValue(typeof(string), ""),
            Description("Nombre del mantenimiento."),
            Localizable(false),
            DisplayName("(nombre)"),
            Browsable(false)
        ]
        public string Nombre
        {
            get { return nombre; }
            set { nombre = value; }
        }

        private string nombretabla = "";
        [
            Bindable(false),
            Category("Diseño"),
            DefaultValue(typeof(string), ""),
            Description("Nombre de la tabla."),
            Localizable(false),
            DisplayName("(nombre tabla)"),
            Browsable(false)
        ]
        public string NombreTabla
        {
            get { return nombretabla; }
            set
            {
                nombretabla = value;

                NombreTabla_Changed?.Invoke(this, value);
            }
        }

        private string titulo = "";
        [
            Bindable(false),
            Category("Diseño"),
            DefaultValue(typeof(string), ""),
            Description("Título del formulario."),
            Localizable(false),
            DisplayName("Título"),
            Browsable(false)
        ]
        public string Titulo
        {
            get { return titulo; }
            set { titulo = value; }
        }

        private string textomenu = "";
        [
            Bindable(false),
            Category("Diseño"),
            DefaultValue(typeof(string), ""),
            Description("Texto que se mostrará en la opción de menú."),
            Localizable(false),
            DisplayName("Texto menú"),
            Browsable(false)
        ]
        public string TextoMenu
        {
            get { return textomenu; }
            set { textomenu = value; }
        }

        private int numtabs = 1;
        [
            Bindable(false),
            Category("Diseño"),
            DefaultValue(typeof(int), "1"),
            Description("Número de páginas donde se colocará el control."),
            Localizable(false),
            DisplayName("Páginas"),
            Browsable(false)
        ]
        public int NumTabs
        {
            get { return numtabs; }
            set
            {
                if (value == null || value == 0)
                    value = 1;

                numtabs = value;
            }
        }

        private bool addCeros = true;
        [
            Bindable(false),
            Category("Diseño"),
            DefaultValue(typeof(bool), "true"),
            Description("Activado, se añadirán ceros a la izquierda del código hasta cumplimentar su longitud."),
            Localizable(false),
            DisplayName("Añadir ceros"),
            Browsable(false)
        ]
        public bool AddCeros
        {
            get { return addCeros; }
            set
            {
                addCeros = value;
            }
        }

        public event NombreTabla_Change_Handler NombreTabla_Changed;

        public delegate void NombreTabla_Change_Handler(ModManteProperties sender, string nombreTabla);
    }
    
    public class ToolStripTextBoxAddon : ToolStripTextBox
    {

        private int position = -1;
        [
            Bindable(false),
            Category("Diseño"),
            DefaultValue(typeof(int), "-1"),
            Description("Posición del botón dentro del ToolStrip."),
            Localizable(false),
            DisplayName("Posición"),
            Browsable(true)
        ]
        public int Position
        {
            get { return position; }
            set
            {                
                position = value;
            }
        }

        [
            Browsable(false)
        ]
        public override System.Drawing.Size Size
        {
            get
            {
                return base.Size;
            }
            set
            {
                base.Size = value;
            }
        }
    }

    public class ToolStripSplitButtonAddon : ToolStripSplitButton
    {

        private int position = -1;
        [
            Bindable(false),
            Category("Diseño"),
            DefaultValue(typeof(int), "-1"),
            Description("Posición del botón dentro del ToolStrip."),
            Localizable(false),
            DisplayName("Posición"),
            Browsable(true)
        ]
        public int Position
        {
            get { return position; }
            set
            {                
                position = value;
            }
        }

        [
            Browsable(false)
        ]
        public override System.Drawing.Size Size
        {
            get
            {
                return base.Size;
            }
            set
            {
                base.Size = value;
            }
        }
    }

    public class ToolStripSeparatorAddon : ToolStripSeparator
    {

        private int position = -1;
        [
            Bindable(false),
            Category("Diseño"),
            DefaultValue(typeof(int), "-1"),
            Description("Posición del botón dentro del ToolStrip."),
            Localizable(false),
            DisplayName("Posición"),
            Browsable(true)
        ]
        public int Position
        {
            get { return position; }
            set
            {                
                position = value;
            }
        }

        [
            Browsable(false)
        ]
        public override System.Drawing.Size Size
        {
            get
            {
                return base.Size;
            }
            set
            {
                base.Size = value;
            }
        }
    }

    public class ToolStripProgressBarAddon : ToolStripProgressBar
    {

        private int position = -1;
        [
            Bindable(false),
            Category("Diseño"),
            DefaultValue(typeof(int), "-1"),
            Description("Posición del botón dentro del ToolStrip."),
            Localizable(false),
            DisplayName("Posición"),
            Browsable(true)
        ]
        public int Position
        {
            get { return position; }
            set
            {                
                position = value;
            }
        }

        [
            Browsable(false)
        ]
        public override System.Drawing.Size Size
        {
            get
            {
                return base.Size;
            }
            set
            {
                base.Size = value;
            }
        }
    }

    public class ToolStripLabelAddon : ToolStripLabel
    {

        private int position = -1;
        [
            Bindable(false),
            Category("Diseño"),
            DefaultValue(typeof(int), "-1"),
            Description("Posición del botón dentro del ToolStrip."),
            Localizable(false),
            DisplayName("Posición"),
            Browsable(true)
        ]
        public int Position
        {
            get { return position; }
            set
            {                
                position = value;
            }
        }

        [
            Browsable(false)
        ]
        public override System.Drawing.Size Size
        {
            get
            {
                return base.Size;
            }
            set
            {
                base.Size = value;
            }
        }
    }

    public class ToolStripDropDownButtonAddon : ToolStripDropDownButton
    {

        private int position = -1;
        [
            Bindable(false),
            Category("Diseño"),
            DefaultValue(typeof(int), "-1"),
            Description("Posición del botón dentro del ToolStrip."),
            Localizable(false),
            DisplayName("Posición"),
            Browsable(true)
        ]
        public int Position
        {
            get { return position; }
            set
            {                
                position = value;
            }
        }

        [
            Browsable(false)
        ]
        public override System.Drawing.Size Size
        {
            get
            {
                return base.Size;
            }
            set
            {
                base.Size = value;
            }
        }
    }

    public class ToolStripComboBoxAddon : ToolStripComboBox
    {

        private int position = -1;
        [
            Bindable(false),
            Category("Diseño"),
            DefaultValue(typeof(int), "-1"),
            Description("Posición del botón dentro del ToolStrip."),
            Localizable(false),
            DisplayName("Posición"),
            Browsable(true)
        ]
        public int Position
        {
            get { return position; }
            set
            {                
                position = value;
            }
        }

        [
            Browsable(false)
        ]
        public override System.Drawing.Size Size
        {
            get
            {
                return base.Size;
            }
            set
            {
                base.Size = value;
            }
        }
    }

    public class ToolStripButtonAddon : ToolStripButton
    {

        private int position = -1;
        [
            Bindable(false),
            Category("Diseño"),
            DefaultValue(typeof(int), "-1"),
            Description("Posición del botón dentro del ToolStrip."),
            Localizable(false),
            DisplayName("Posición"),
            Browsable(true)
        ]
        public int Position
        {
            get { return position; }
            set
            {                
                position = value;
            }
        }

        [
            Browsable(false)
        ]
        public override System.Drawing.Size Size
        {
            get
            {
                return base.Size;
            }
            set
            {
                base.Size = value;
            }
        }

        [Browsable(false)]
        public override bool AllowDrop
        {
            get
            {
                return base.AllowDrop;
            }
            set
            {
                base.AllowDrop = value;
            }
        }

        [Browsable(false)]
        public override System.Drawing.Rectangle Bounds
        {
            get
            {
                return base.Bounds;
            }
        }

        [Browsable(false)]
        public override bool CanSelect
        {
            get
            {
                return base.CanSelect;
            }
        }

        [Browsable(false)]
        public override System.Drawing.Font Font
        {
            get
            {
                return base.Font;
            }
            set
            {
                base.Font = value;
            }
        }

    }

    //public class PaginasCollection : CollectionBase, ICustomTypeDescriptor
    //{
    //    //public PaginasCollection()
    //    //{
            
    //    //}

    //    // Collection methods implementation 

    //    //System.Collections.ArrayList list = new System.Collections.ArrayList();

    //    //protected override System.Collections.ArrayList List
    //    //{
    //    //    get
    //    //    {
    //    //        //if (base.List == null)
    //    //        //    return new System.Collections.ArrayList();
    //    //        //else
    //    //        return base.List;
                
    //    //        //return list;
    //    //    }
    //    //}


    //    /// <summary>
    //    /// Handler del evento para capturar el cambio de Visible
    //    /// </summary>
    //    public event AddPagina_Handler AddPagina;

    //    /// <summary>
    //    /// Handler del evento para capturar el cambio de Visible
    //    /// </summary>
    //    public delegate void AddPagina_Handler(PaginaManteProperties sender);

    //    /// <summary>
    //    /// Añade la página a la colección
    //    /// </summary>
    //    /// <param name="pagina"></param>
    //    public void Add(PaginaManteProperties pagina)
    //    {
    //        this.List.Add(pagina);

    //        pagina.ColeccionPaginas = this;

    //        if (AddPagina != null)
    //            AddPagina(pagina);
    //    }

    //    /// <summary>
    //    /// Elimina la página de la colección
    //    /// </summary>
    //    /// <param name="pagina"></param>
    //    public void Remove(PaginaManteProperties pagina)
    //    {
    //        this.List.Remove(pagina);
    //    }

    //    /// <summary>
    //    /// Devuelve la página correspondiente al índice
    //    /// </summary>
    //    /// <param name="index"></param>
    //    /// <returns></returns>
    //    public PaginaManteProperties this[int index]
    //    {
    //        get
    //        {
    //            return (PaginaManteProperties)this.List[index];
    //        }
    //    }


    //    // Implementation of ICustomTypeDescriptor:

    //    /// <summary>
    //    /// Devuelve el nombre de la clase
    //    /// </summary>
    //    /// <returns></returns>
    //    public String GetClassName()
    //    {
    //        return TypeDescriptor.GetClassName(this, true);
    //    }

    //    /// <summary>
    //    /// Devuelve una colección de atributos
    //    /// </summary>
    //    /// <returns></returns>
    //    public AttributeCollection GetAttributes()
    //    {
    //        return TypeDescriptor.GetAttributes(this, true);
    //    }

    //    /// <summary>
    //    /// Devuelve el nombre del componente
    //    /// </summary>
    //    /// <returns></returns>
    //    public String GetComponentName()
    //    {
    //        return TypeDescriptor.GetComponentName(this, true);
    //    }

    //    /// <summary>
    //    /// Devuelve el convertidor de tipos
    //    /// </summary>
    //    /// <returns></returns>
    //    public TypeConverter GetConverter()
    //    {
    //        return TypeDescriptor.GetConverter(this, true);
    //    }

    //    /// <summary>
    //    /// Devvuelve el evento predeterminado
    //    /// </summary>
    //    /// <returns></returns>
    //    public EventDescriptor GetDefaultEvent()
    //    {
    //        return TypeDescriptor.GetDefaultEvent(this, true);
    //    }

    //    /// <summary>
    //    /// Devuelve la propiedad predeterminada
    //    /// </summary>
    //    /// <returns></returns>
    //    public PropertyDescriptor GetDefaultProperty()
    //    {
    //        return TypeDescriptor.GetDefaultProperty(this, true);
    //    }

    //    /// <summary>
    //    /// Devuelve un editor con el tipo base especificado
    //    /// </summary>
    //    /// <param name="editorBaseType"></param>
    //    /// <returns></returns>
    //    public object GetEditor(Type editorBaseType)
    //    {
    //        return TypeDescriptor.GetEditor(this, editorBaseType, true);
    //    }

    //    /// <summary>
    //    /// Devuelve la colección de eventos
    //    /// </summary>
    //    /// <param name="attributes"></param>
    //    /// <returns></returns>
    //    public EventDescriptorCollection GetEvents(Attribute[] attributes)
    //    {
    //        return TypeDescriptor.GetEvents(this, attributes, true);
    //    }

    //    /// <summary>
    //    /// Devuelve la colección de eventos
    //    /// </summary>
    //    /// <returns></returns>
    //    public EventDescriptorCollection GetEvents()
    //    {
    //        return TypeDescriptor.GetEvents(this, true);
    //    }

    //    /// <summary>
    //    /// Devuelve la instancia del objeto
    //    /// </summary>
    //    /// <param name="pd"></param>
    //    /// <returns></returns>
    //    public object GetPropertyOwner(PropertyDescriptor pd)
    //    {
    //        return this;
    //    }

    //    /// <summary>
    //    /// Devuelve el descriptor de las propiedades
    //    /// </summary>
    //    /// <param name="attributes"></param>
    //    /// <returns></returns>
    //    public PropertyDescriptorCollection GetProperties(Attribute[] attributes)
    //    {
    //        return GetProperties();
    //    }

    //    /// <summary>
    //    /// Devuelve el descriptor de las propiedades
    //    /// </summary>
    //    /// <returns></returns>
    //    public PropertyDescriptorCollection GetProperties()
    //    {
    //        // Create a new collection object PropertyDescriptorCollection
    //        PropertyDescriptorCollection pds = new PropertyDescriptorCollection(null);

    //        // Iterate the list of employees
    //        for (int i = 0; i < this.List.Count; i++)
    //        {
    //            // For each employee create a property descriptor 
    //            // and add it to the 
    //            // PropertyDescriptorCollection instance
    //            PaginaCollectionPropertyDescriptor pd = new PaginaCollectionPropertyDescriptor(this, i);
    //            pds.Add(pd);
    //        }
    //        return pds;
    //    }
    //}

    //public class PaginaCollectionPropertyDescriptor : PropertyDescriptor
    //{
    //    private PaginasCollection collection = null;
    //    private int index = -1;

    //    public PaginaCollectionPropertyDescriptor(PaginasCollection coll, int idx)
    //        : base("#" + idx.ToString(), null)
    //    {
    //        this.collection = coll;
    //        this.index = idx;
    //    }

    //    public override AttributeCollection Attributes
    //    {
    //        get
    //        {
    //            return new AttributeCollection(null);
    //        }
    //    }

    //    public override bool CanResetValue(object component)
    //    {
    //        return true;
    //    }

    //    public override Type ComponentType
    //    {
    //        get
    //        {
    //            return this.collection.GetType();
    //        }
    //    }

    //    public override string DisplayName
    //    {
    //        get
    //        {
    //            PaginaManteProperties pagina = this.collection[index];
    //            return pagina.Nombre;
    //        }
    //    }

    //    public override string Description
    //    {
    //        get
    //        {
    //            PaginaManteProperties pagina = this.collection[index];
    //            StringBuilder sb = new StringBuilder();
    //            sb.Append(pagina.Nombre);

    //            return sb.ToString();
    //        }
    //    }

    //    public override object GetValue(object component)
    //    {
    //        return this.collection[index];
    //    }

    //    public override bool IsReadOnly
    //    {
    //        get { return true; }
    //    }

    //    public override string Name
    //    {
    //        get { return "#" + index.ToString(); }
    //    }

    //    public override Type PropertyType
    //    {
    //        get { return this.collection[index].GetType(); }
    //    }

    //    public override void ResetValue(object component) { }

    //    public override bool ShouldSerializeValue(object component)
    //    {
    //        return true;
    //    }

    //    public override void SetValue(object component, object value)
    //    {
    //        // this.collection[index] = value;
    //    }
    //}

    //internal class PaginaConverter : ExpandableObjectConverter
    //{
    //    public override object ConvertTo(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destType)
    //    {
    //        if (destType == typeof(string) && value is PaginaManteProperties)
    //        {
    //            // Cast the value to an Employee type
    //            PaginaManteProperties emp = (PaginaManteProperties)value;

    //            // Return department and department role separated by comma.
    //            return emp.Nombre;
    //        }
    //        return base.ConvertTo(context, culture, value, destType);
    //    }
    //}

    //internal class PaginaCollectionConverter : ExpandableObjectConverter
    //{
    //    public override object ConvertTo(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destType)
    //    {
    //        if (destType == typeof(string) && value is PaginasCollection)
    //        {
    //            // Return department and department role separated by comma.
    //            return "(colección de páginas)";
    //        }
    //        return base.ConvertTo(context, culture, value, destType);
    //    }
    //}

    //[TypeConverter(typeof(PaginaConverter))]
    public class PaginaManteProperties
    {
        //public PaginasCollection ColeccionPaginas;

        private string nombre = "";
        [
            Bindable(false),
            Category("Diseño"),
            DefaultValue(typeof(string), ""),
            Description("Nombre de la página."),
            Localizable(false),
            DisplayName("(nombre)"),
            Browsable(false)
        ]
        public string Nombre
        {
            get { return nombre; }
            set { nombre = value; }
        }

        private string titulo = "";
        [
            Bindable(false),
            Category("Diseño"),
            DefaultValue(typeof(TabControl.TabPageCollection), null),
            Description("Título de la página."),
            Localizable(false),
            DisplayName("Título")
        ]
        public string Titulo
        {
            get { return titulo; }
            set 
            { 
                titulo = value;

                if (TituloPagina_Changed != null)
                    TituloPagina_Changed(this, value);
            }
        }

        public event TituloPagina_Change_Handler TituloPagina_Changed;

        public delegate void TituloPagina_Change_Handler(PaginaManteProperties sender, string tituloPagina);
    }

    public class ObjectsManteProperties : object
    {
        private string nombre = "";
        [
            Bindable(false),
            Category("Diseño"),
            DefaultValue(typeof(string), ""),
            Description("Nombre del campo."),
            Localizable(false),
            DisplayName("(nombre)"),
            Browsable(false)
        ]
        public string Nombre
        {
            get { return nombre; }
            set
            {
                nombre = value;
            }
        }

        private bool visible = false;
        [
            Bindable(false),
            Category("Diseño"),
            DefaultValue(typeof(bool), "false"),
            Description("Determina si el campo será visible o no."),
            Localizable(false),
            DisplayName("Visible")
        ]
        public bool Visible
        {
            get { return visible; }
            set
            {
                visible = value;


                if (Visible_Changed != null)
                    Visible_Changed(this, value);
            }
        }

        private bool mostrarTitulo = true;
        [
            Bindable(false),
            Category("Diseño"),
            DefaultValue(typeof(bool), "true"),
            Description("Muestra u oculta el título del campo."),
            Localizable(false),
            DisplayName("Mostrar título")
        ]
        public bool MostrarTitulo
        {
            get { return mostrarTitulo; }
            set
            {
                mostrarTitulo = value;

                if (MostrarTitulo_Changed != null)
                    MostrarTitulo_Changed(this, value);
            }
        }

        private int tab = 1;
        [
            Bindable(false),
            Category("Diseño"),
            DefaultValue(typeof(int), "1"),
            Description("Índice de la página donde se colocará el control."),
            Localizable(false),
            DisplayName("Página"),
            Browsable(false)
        ]
        public int Tab
        {
            get { return tab; }
            set { tab = value; }
        }

        private Int32 numericupdowndecimals = 0;
        [
            Bindable(false),
            Category("Diseño"),
            DefaultValue(typeof(int), "0"),
            Description("Posiciones decimales. Solo para los controles NumericUpDown"),
            Localizable(false),
            DisplayName("Posiciones decimales")
        ]
        public Int32 NumericUpDownDecimals
        {
            get { return numericupdowndecimals; }
            set 
            {
                numericupdowndecimals = value;

                if (NumericUpDownProperties_Changed != null)
                    NumericUpDownProperties_Changed(this);
            }
        }

        private Int32 numericupdownincrement = 1;
        [
            Bindable(false),
            Category("Diseño"),
            DefaultValue(typeof(int), "1"),
            Description("Incremento. Solo para los controles NumericUpDown"),
            Localizable(false),
            DisplayName("Incremento")
        ]
        public Int32 NumericUpDownIncrement
        {
            get { return numericupdownincrement; }
            set
            {
                numericupdownincrement = value;

                if (NumericUpDownProperties_Changed != null)
                    NumericUpDownProperties_Changed(this);
            }
        }

        private Int32 numericupdownmaximum = 9999999;
        [
            Bindable(false),
            Category("Diseño"),
            DefaultValue(typeof(int), "9999999"),
            Description("Valor máximo. Solo para los controles NumericUpDown"),
            Localizable(false),
            DisplayName("Máximo")
        ]
        public Int32 NumericUpDownMaximum
        {
            get { return numericupdownmaximum; }
            set
            {
                numericupdownmaximum = value;

                if (NumericUpDownProperties_Changed != null)
                    NumericUpDownProperties_Changed(this);
            }
        }

        private Int32 numericupdownminimum = 0;
        [
            Bindable(false),
            Category("Diseño"),
            DefaultValue(typeof(int), "0"),
            Description("Valor mínimo. Solo para los controles NumericUpDown"),
            Localizable(false),
            DisplayName("Mínimo")
        ]
        public Int32 NumericUpDownMinimum
        {
            get { return numericupdownminimum; }
            set
            {
                numericupdownminimum = value;

                if (NumericUpDownProperties_Changed != null)
                    NumericUpDownProperties_Changed(this);
            }
        }

        private Int32 top = 0;
        [
            Bindable(false),
            Category("Diseño"),
            DefaultValue(typeof(int), "0"),
            Description("Posición vertical del control."),
            Localizable(false),
            DisplayName("Top")
        ]
        public Int32 Top
        {
            get { return top; }
            set
            {
                top = value;

                if (Location_Changed != null)
                    Location_Changed(this);
            }
        }

        private Int32 left = 0;
        [
            Bindable(false),
            Category("Diseño"),
            DefaultValue(typeof(int), "0"),
            Description("Posición horizontal del control."),
            Localizable(false),
            DisplayName("Left")
        ]
        public Int32 Left
        {
            get { return left; }
            set
            {
                left = value;

                if (Location_Changed != null)
                    Location_Changed(this);
            }
        }

        private Int32 controlleft = 0;
        [
            Bindable(false),
            Category("Diseño"),
            DefaultValue(typeof(int), "0"),
            Description("Posición horizontal del control."),
            Localizable(false),
            DisplayName("Left"),
            Browsable(false)
        ]
        public Int32 ControlLeft
        {
            get { return controlleft; }
            set
            {
                controlleft = value;
            }
        }

        private ObjectsManteTypes objectType = ObjectsManteTypes.TextBox;
        [
            Bindable(false),
            Category("Diseño"),
            DefaultValue(typeof(ObjectsManteTypes), "TextBox"),
            Description("Control enlazado al campo."),
            Localizable(false),
            DisplayName("Control")
        ]
        public ObjectsManteTypes ObjectType
        {
            get { return objectType; }
            set
            {
                if (value != null && objectType != null && objectType != value)
                {
                    if (objectType == ObjectsManteTypes.TxtCodLabel)
                    {
                        TxtCodLabel = "";
                    }
                }

                objectType = value;

                if (ObjectType_Changed != null)
                    ObjectType_Changed(this, value);
            }
        }

        private string txtCodLabel = "";
        [
            Bindable(false),
            Category("Diseño"),
            DefaultValue(""),
            Description("Objeto TxtCodLabel que se insertará en el control de usuario."),
            Localizable(false),
            DisplayName("TxtCodLabel"),
            TypeConverter(typeof(cmb_txtCodLabel))
        ]
        public string TxtCodLabel
        {
            get { return txtCodLabel; }
            set
            {
                if (txtCodLabel != value)
                {
                    if (!string.IsNullOrWhiteSpace(value))
                    {
                        ObjectType = ObjectsManteTypes.TxtCodLabel;
                    }
                }
                
                txtCodLabel = value;
            }
        }

        //private DataTypes dataType = DataTypes.Carácter;
        //[
        //    Bindable(false),
        //    Category("Diseño"),
        //    DefaultValue(typeof(DataTypes), "Carácter"),
        //    Description("Tipos de datos del campo asociado."),
        //    Localizable(false),
        //    DisplayName("Tipo de datos"),
        //    Browsable(false)
        //]
        //public DataTypes DataType
        //{
        //    get { return dataType; }
        //    set { dataType = value; }
        //}

        private string tituloCampo = "";
        [
            Bindable(false),
            Category("Diseño"),
            DefaultValue(typeof(string), ""),
            Description("Título del campo."),
            Localizable(false),
            DisplayName("Título")
        ]
        public string TituloCampo
        {
            get { return tituloCampo; }
            set
            {
                tituloCampo = value;

                if (TituloCampo_Changed != null)
                    TituloCampo_Changed(this, value);
            }
        }

        private bool debeExistir = false;
        [
            Bindable(false),
            Category("Diseño"),
            DefaultValue(typeof(bool), "false"),
            Description("Indica si el campo debe existir al crear nuevas tablas."),
            Localizable(false),
            DisplayName("Debe existir"),
            Browsable(false)
        ]
        public bool DebeExistir
        {
            get { return debeExistir; }
            set { debeExistir = value; }
        }

        private bool esFiltro = false;
        [
            Bindable(false),
            Category("Diseño"),
            DefaultValue(typeof(bool), "false"),
            Description("Indica si el campo actuará como filtro de la tabla del addon."),
            Localizable(false),
            DisplayName("Es filtro"),
            Browsable(true)
        ]
        public bool EsFiltro
        {
            get { return esFiltro; }
            set { esFiltro = value; }
        }
        
        public void SetObjectProperties(DataRowView fieldProperties)
        {
            // Tipo de datos
            string dataType = fieldProperties["Data_Type"].ToString();
            SetObjectType(dataType);

            if (dataType == "numeric")
            {
                int decimals = Convert.ToInt32(fieldProperties["numeric_scale"]);
                NumericUpDownDecimals = decimals;
            }
        }
        
        public void SetObjectType(string dataType)
        {
            if (dataType == "char")
                ObjectType = ObjectsManteTypes.TextBox;

            if (dataType == "bit")
                ObjectType = ObjectsManteTypes.CheckBox;

            if (dataType == "text")
                ObjectType = ObjectsManteTypes.TextBox;

            if (dataType == "int")
                ObjectType = ObjectsManteTypes.NumericUpDown;

            if (dataType == "date" || dataType == "datetime")
                ObjectType = ObjectsManteTypes.DateTimePicker;

            if (dataType == "numeric" || dataType == "decimal")
                ObjectType = ObjectsManteTypes.NumericUpDown;
        }

        public event ObjectType_Change_Handler ObjectType_Changed;

        public delegate void ObjectType_Change_Handler(ObjectsManteProperties sender, ObjectsManteTypes value);

        public event TituloCampo_Change_Handler TituloCampo_Changed;

        public delegate void TituloCampo_Change_Handler(ObjectsManteProperties sender, string tituloCampo);

        public event Visible_Change_Handler Visible_Changed;

        public delegate void Visible_Change_Handler(object sender, bool visible);

        public event MostrarTitulo_Change_Handler MostrarTitulo_Changed;

        public delegate void MostrarTitulo_Change_Handler(ObjectsManteProperties sender, bool visible);

        public event NumericUpDownProperties_Change_Handler NumericUpDownProperties_Changed;

        public delegate void NumericUpDownProperties_Change_Handler(ObjectsManteProperties sender);

        public event Location_Changed_Handler Location_Changed;

        public delegate void Location_Changed_Handler(ObjectsManteProperties sender);
    }

    public class UserControlProperties
    {
        private string nombre = "";
        [
            Bindable(false),
            Category("Diseño"),
            DefaultValue(typeof(string), ""),
            Description("Nombre del control de usuario."),
            Localizable(false),
            DisplayName("(nombre)"),
            Browsable(false)
        ]
        public string Nombre
        {
            get { return nombre; }
            set { nombre = value; }
        }

        private int numtabs = 1;
        [
            Bindable(false),
            Category("Diseño"),
            DefaultValue(typeof(int), "1"),
            Description("Número de páginas que tendrá el control de usuario."),
            Localizable(false),
            DisplayName("Páginas"),
            Browsable(true)
        ]
        public int NumTabs
        {
            get { return numtabs; }
            set
            {
                if (value == null || value == 0)
                    value = 1;

                numtabs = value;
            }
        }
    }

    //public class ObjecstUserControlProperties : ObjectsManteProperties
    //{
    //    private bool esFiltro = false;
    //    /// <summary>
    //    /// Indica si el campo relacionado actuarà de filtro de la tabla
    //    /// </summary>
    //    [
    //        Bindable(false),
    //        Category("Diseño"),
    //        DefaultValue(typeof(bool), "false"),
    //        Description("Indica si el campo actuará como filtro de la tabla del addon."),
    //        Localizable(false),
    //        DisplayName("Es filtro"),
    //        Browsable(true)
    //    ]
    //    public bool EsFiltro
    //    {
    //        get { return esFiltro; }
    //        set { esFiltro = value; }
    //    }
    //}

    public class CodigoNombreManteProperties
    {
        private string nombre = "";
        [
            Bindable(false),
            Category("Diseño"),
            DefaultValue(typeof(string), ""),
            Description("Nombre del campo."),
            Localizable(false),
            DisplayName("(nombre)"),
            Browsable(false)
        ]
        public string Nombre
        {
            get { return nombre; }
            set { nombre = value; }
        }

        private string tituloCampo = "";
        [
            Bindable(false),
            Category("Diseño"),
            DefaultValue(typeof(string), ""),
            Description("Título del campo."),
            Localizable(false),
            DisplayName("Título")
        ]
        public string TituloCampo
        {
            get { return tituloCampo; }
            set
            {
                tituloCampo = value;

                if (TituloCampo_Changed != null)
                    TituloCampo_Changed(this, value);
            }
        }

        public event TituloCampo_Change_Handler TituloCampo_Changed;

        public delegate void TituloCampo_Change_Handler(CodigoNombreManteProperties sender, string tituloCampo);
    }

    
    public class DocumentProperties
    {
        private string nombre = "";
        [
            Bindable(false),
            Category("Diseño"),
            DefaultValue(typeof(string), ""),
            Description("Nombre del documento."),
            Localizable(false),
            DisplayName("(nombre)"),
            Browsable(true)
        ]
        public string Nombre
        {
            get { return nombre; }
            set { nombre = value; }
        }

        private string titulo = "";
        [
            Bindable(false),
            Category("Diseño"),
            DefaultValue(typeof(string), ""),
            Description("Título del formulario."),
            Localizable(false),
            DisplayName("Título"),
            Browsable(true)
        ]
        public string Titulo
        {
            get { return titulo; }
            set { titulo = value; }
        }

        private int capHeight = 108;
        [
            Bindable(false),
            Category("Diseño"),
            DefaultValue(typeof(int), "108"),
            Description("Alto de la cabecera del documento."),
            Localizable(false),
            DisplayName("Altro cabecera"),
            Browsable(true)
        ]
        public int CapHeight
        {
            get { return capHeight; }
            set { capHeight = value; }
        }

        private string textomenu = "";
        [
            Bindable(false),
            Category("Diseño"),
            DefaultValue(typeof(string), ""),
            Description("Texto que se mostrará en la opción de menú."),
            Localizable(false),
            DisplayName("Texto menú"),
            Browsable(true)
        ]
        public string TextoMenu
        {
            get { return textomenu; }
            set { textomenu = value; }
        }

        //private int numtabs = 1;
        //[
        //    Bindable(false),
        //    Category("Diseño"),
        //    DefaultValue(typeof(int), "1"),
        //    Description("Número de páginas donde se colocará el control."),
        //    Localizable(false),
        //    DisplayName("Páginas"),
        //    Browsable(true)
        //]
        //public int NumTabs
        //{
        //    get { return numtabs; }
        //    set
        //    {
        //        if (value == null || value == 0)
        //            value = 1;

        //        numtabs = value;
        //    }
        //}
    }

    public class cmb_txtCodLabel : cmb_List
    {
        public override  List<string> _CargarDatos(ITypeDescriptorContext context)
        {
            List<string> lstModulos = new List<string>();
            if (context != null && context.Instance != null && context.PropertyDescriptor != null)
            {
                try
                {
                    FuncsDataBase funcsDataBase = new FuncsDataBase();
                    List<string> usercontrolsList = funcsDataBase.GetFiltrosTxtCodLabel();
                    lstModulos = usercontrolsList;
                }
                catch (Exception)
                {
                    lstModulos = new List<string>();
                }
            }
            return lstModulos;
        }
    }

}