ColumnDefinition.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ComponentModel;
using sage.ew.interficies;
using System.Xml.Linq;
using System.Data;
using System.Drawing;
using sage.ew.db;
using sage.ew.listados.Clases;
using System.Drawing.Design;
using System.Windows.Forms.Design;
using System.Windows.Forms;
using sage.ew.formul.Forms;
using System.Reflection;
using sage.ew.global;
using sage.ew.functions;
using System.Globalization;
using sage.ew.reports;
using sage.ew.global.Diccionarios;
using Sage.ES.S50.Addons;
using sage.ew.objetos;

namespace sage.ew.formul.Clases
{

    [DefaultPropertyAttribute("_Titulo")]
    public class ColumnDefinition
        : ColumnDefinitionBase, ICustomTypeDescriptor
    {
        #region variables
        
        private String _cTituloOriginal = "";
        private String _cTituloNavegacion = "";
        private String _cMante = "";
        private String _cType = "";
        private Int32 _nWidth = 100;
        private Int32 _nUserWidth = 100;
        private Int32 _nPosicion;
        private Int32 _nTipoCampo = 0;
        private Boolean _lIncluirSageReports = true;
        private Boolean _lIncluirCSV = true;
        private Boolean _lPermitirNavegacion = false;
        private Boolean _bVisible = true;
        private Boolean _bInmobilizada = false;
        private Boolean _bIncluirComunicados = true; 
        private Boolean _bOculta = false;
        private Accion _oAccion;
        private Color _oColorLetra = Color.Black;
        private Color _oColorFondo = Color.White;
        private TipoMascara _oMascara = TipoMascara.GrandTotal;
        private Dictionary<String, ColumnDefinition> _oColumnsList;
        private GoogleMapsConfig _oGoogleMapsConfig;
        private DefinicionValores _oDefinicionValores;
        private List<IListadoComunicado> _oComunicados = new List<IListadoComunicado>();

        private static List<Type> _oTypesComunicados;

        #endregion variables

        #region propiedades

        public enum TipoMascara
        {
            [Description("Ninguna")]
            Ninguna,
            [Description("Porcentaje")]
            Porcentaje,
            [Description("Total")]
            Total,
            [Description("Gran total")]
            GrandTotal,
            [Description("Peso")]
            Peso,
            [Description("Unidades")]
            Unidades,
            [Description("Cajas")]
            Cajas,
            [Description("Precio/Coste")]
            PrecioCoste
        }

        public enum Accion
        {
            [Description("Ninguna")]
            Ninguna,
            [Description("Contador")]
            Contador,
            [Description("Media")]
            Media,
            [Description("Mínimo")]
            Minimo,
            [Description("Máximo")]
            Maximo,
            [Description("Suma")]
            Suma,
        }

        public enum Activo
        {
            [Description("Sí")]
            Si = 1,
            [Description("No")]
            No = 0
        }


        private static List<Type> _TypesComunicados
        {
            get
            {
                if ( _oTypesComunicados == null)
                {

                    _oTypesComunicados = Assembly.GetAssembly(typeof(ListadoComunicadoBase))?.GetTypes().Where(f => typeof(IListadoComunicado).IsAssignableFrom(f) && !f.IsAbstract).ToList();

                    foreach (IModulo loModulo in AddonsController.Instance.AddonsManager.GetAddons().Values)
                    {
                        if (loModulo._Assembly is Assembly)
                        {
                            try
                            {
                                _oTypesComunicados.AddRange(loModulo._Assembly.GetTypes().Where(f => typeof(IListadoComunicado).IsAssignableFrom(f) && !f.IsAbstract).ToList());
                            }
                            catch (Exception loEx)
                            {
                                DB.Registrar_Error(loEx);
                            }
                        }
                    }
                }

                return _oTypesComunicados;
            }
        }

        [Browsable(false)]
        public bool _ColumnAdded
        {
            get
            {
                return _DefEntidad is ColumnDefEntidad;
            }
        }

        [Browsable(false)]
        public Boolean _Oculta
        {
            get
            {
                return _bOculta;
            }
            set
            {
                _bOculta = value;

                if (value)
                {
                    _IncluirSageReports = ColumnDefinition.Activo.No;
                    _Visible = false;
                }
            }
        }

        [Browsable(false)]
        public List<IListadoComunicado> _Comunicados
        {
            get
            {
                return _oComunicados;
            }
        }

        [ComunicadoAttribute, CategoryAttribute("Propiedades de la columna"), DisplayName("Comunicados"), Description("Incluir los comunicados de la columna al listado"), DefaultValueAttribute(1)]
        [Editor(typeof(EnumEditor), typeof(UITypeEditor))]
        [TypeConverter(typeof(EnumConverter<Activo>))]
        public Activo _IncluirComunicados
        {
            get
            {
                return _bIncluirComunicados ? Activo.Si : Activo.No;
            }
            set
            {
                _bIncluirComunicados = (value == Activo.Si);
            }
        }

        [Browsable(false)]
        public Boolean _Inmobilizada
        {
            get
            {
                return _bInmobilizada;
            }
            set
            {
                _bInmobilizada = value;
            }
        }

        [CategoryAttribute("Propiedades de la columna"), DisplayName("Título"), Description("Título de la columna")]
        [RefreshProperties(RefreshProperties.All)]
        public override String _Titulo
        {
            get
            {
                return base._Titulo;
            }
            set
            {
                _cTituloOriginal = value;
                if (value.Length > 0)
                {
                    if (value.Substring(0, 1) == "*")
                    {
                        value = value.Substring(1).ToUpper();
                    }
                    else if (value.Substring(0, 1) == "@")
                    {
                        value = value.Substring(1);
                    }
                    else
                    {
                        value = FUNCTIONS._Proper(value);
                    }
                }
                base._Titulo = value;
            }
        }

        [CategoryAttribute("Propiedades de la columna"), DisplayName("Tamaño"), Description("Tamaño de la columna"), DefaultValueAttribute(100)]
        [RefreshProperties(RefreshProperties.All)]
        public Int32 _Width
        {
            get
            {
                return _nWidth;
            }
            set
            {
                _nWidth = value;
            }
        }

        [Browsable(false)]
        public Int32 _UserWidth
        {
            get
            {
                return _nUserWidth;
            }
            set
            {
                _nUserWidth = value;
            }
        }


        [NumericAttribute, CategoryAttribute("Propiedades de la columna"), DisplayName("Máscara"), Description("Máscara"), DefaultValueAttribute(3)]
        [RefreshProperties(RefreshProperties.All)]
        [Editor(typeof(EnumEditor), typeof(UITypeEditor))]
        [TypeConverter(typeof(EnumConverter<TipoMascara>))]
        public TipoMascara _Mascara
        {
            get
            {
                return _IsNumeric ? _oMascara : TipoMascara.Ninguna;
            }
            set
            {
                _oMascara = value;
            }
        }

        [Browsable(false)]
        public override List<ColumnDefEntidad> _ListPath
        {
            get
            {
                return base._ListPath;
            }
            set
            {
                base._ListPath = value;
                _ActualizarComunicados();

            }
        }

        [NumericAttribute, CategoryAttribute("Propiedades de la columna"), DisplayName("Totalizar"), Description("Acción a realizar"), DefaultValueAttribute(0)]
        [RefreshProperties(RefreshProperties.All)]
        [Editor(typeof(EnumEditor), typeof(UITypeEditor))]
        [TypeConverter(typeof(EnumConverter<Accion>))]
        public Accion _Accion
        {
            get
            {
                return _oAccion;
            }
            set
            {
                _oAccion = value;
            }
        }

        [EnumerationDefinitionAttribute, CategoryAttribute("Propiedades de la columna"), DisplayName("Valores"), Description("Valores de la columna"), DefaultValueAttribute(0)]
        [RefreshProperties(RefreshProperties.All)]
        [Editor(typeof(ValuesEditor), typeof(UITypeEditor))]
        [TypeConverter(typeof(EmptyConverter))]
        public DefinicionValores _DefinicionValores
        {
            get
            {
                if (_oDefinicionValores == null) _oDefinicionValores = new EmptyDefinition(this);
                return _oDefinicionValores;
            }
            set
            {
                _oDefinicionValores = value;
            }
        }


        [Browsable(false)]
        public Listados._Operacion_Calculo _OperacionCalculo
        {
            get
            {
                switch (_oAccion)
                {
                    case Accion.Suma:
                        return Listados._Operacion_Calculo.Suma;
                    case Accion.Media:
                        return Listados._Operacion_Calculo.Avg;
                    case Accion.Minimo:
                        return Listados._Operacion_Calculo.Min;
                    case Accion.Maximo:
                        return Listados._Operacion_Calculo.Max;
                    case Accion.Contador:
                        return Listados._Operacion_Calculo.Count;
                    default:
                        return Listados._Operacion_Calculo.Count;
                }
            }
        }

        [ManteAttribute, CategoryAttribute("Navegación"), DisplayName("Permitir"), Description("Permitir la navegabilidad"), DefaultValueAttribute(0)]
        [RefreshProperties(RefreshProperties.All)]
        [Editor(typeof(EnumEditor), typeof(UITypeEditor))]
        [TypeConverter(typeof(EnumConverter<Activo>))]
        public Activo _PermitirNavegacion
        {
            get
            {
                return _lPermitirNavegacion ? Activo.Si : Activo.No;
            }
            set
            {
                _lPermitirNavegacion = (value == Activo.Si);
                _SetReadOnlyProperty("_TituloNavegacion", !_lPermitirNavegacion);
            }
        }

        [CategoryAttribute("Sage Reports"), DisplayName("Añadir"), Description("Si se establece el valor a \"Sí\", al editar un report la columna se añadirá automáticamente al documento"), DefaultValueAttribute(1)]
        [RefreshProperties(RefreshProperties.All)]
        [Editor(typeof(EnumEditor), typeof(UITypeEditor))]
        [TypeConverter(typeof(EnumConverter<Activo>))]
        public Activo _IncluirSageReports
        {
            get
            {
                return _lIncluirSageReports ? Activo.Si : Activo.No;
            }
            set
            {
                _lIncluirSageReports = (value == Activo.Si);
            }
        }

        [CategoryAttribute("Sage Reports"), DisplayName("Fichero CSV"), Description("Si se establece el valor a \"Sí\", el campo se incluirá en la exportación a CSV aunque no este definido en el report"), DefaultValueAttribute(1)]
        [RefreshProperties(RefreshProperties.All)]
        [Editor(typeof(EnumEditor), typeof(UITypeEditor))]
        [TypeConverter(typeof(EnumConverter<Activo>))]
        public Activo _IncluirExportacionCSV
        {
            get
            {
                return _lIncluirCSV ? Activo.Si : Activo.No;
            }
            set
            {
                _lIncluirCSV = (value == Activo.Si);
            }
        }

        [Browsable(false)]
        public Boolean _PermiteNavegacion
        {
            get
            {
                return _lPermitirNavegacion;
            }
        }

        [Browsable(false)]
        public Boolean _PermiteGoogleMaps
        {
            get
            {
                return _NTipoCampo > 0;
            }
        }

        [Browsable(false)]
        public Boolean _IncluidoSageReports
        {
            get
            {
                return _lIncluirSageReports;
            }
        }

        [Browsable(false)]
        public Boolean _IncluidoCSV
        {
            get
            {
                return _lIncluirCSV;
            }
        }

        [Browsable(false)]
        public Boolean _ColorsChanged
        {
            get
            {
                return _oColorFondo.ToArgb() != Color.White.ToArgb() || _ColorLetra.ToArgb() != Color.Black.ToArgb();
            }
        }

        [ManteAttribute, CategoryAttribute("Navegación"), DisplayName("Título"), Description("Título del botón de navegación")]
        [RefreshProperties(RefreshProperties.All)]
        [ReadOnly(false)]
        public String _TituloNavegacion
        {
            get
            {
                return _cTituloNavegacion;
            }
            set
            {
                _cTituloNavegacion = value;
            }
        }

        [Editor(typeof(PosicionEditor), typeof(UITypeEditor))]
        [CategoryAttribute("Posición"), DisplayName("Posición"), Description("Posición de la columna ")]
        [RefreshProperties(RefreshProperties.All)]
        [TypeConverter(typeof(EmptyConverter))]
        public Int32 _Posicion
        {
            get
            {
                return _nPosicion;
            }
            set
            {
                _nPosicion = value;
            }
        }

        [Browsable(false)]
        public String _Mante
        {
            get
            {
                return _cMante;
            }
            set
            {
                _cMante = value;
            }
        }

        [CategoryAttribute("Diseño"), DisplayName("Color de fondo"), Description("Color de fondo"), DefaultValue(typeof(Color), "White")]
        [RefreshProperties(RefreshProperties.All)]
        public Color _ColorFondo
        {
            get
            {
                return _oColorFondo;
            }
            set
            {
                _oColorFondo = value;
            }
        }

        [CategoryAttribute("Diseño"), DisplayName("Color de la letra"), Description("Colorde la letra"), DefaultValue(typeof(Color), "Black")]
        [RefreshProperties(RefreshProperties.All)]
        public Color _ColorLetra
        {
            get
            {
                return _oColorLetra;
            }
            set
            {
                _oColorLetra = value;
                _DefinicionValores._DefaultColor = _oColorLetra;
            }
        }

        [GoogleMapsAttribute, CategoryAttribute("Google maps"), DisplayName("Presentar"), Description("Permitir la navegación a google maps"), DefaultValueAttribute(0)]
        [RefreshProperties(RefreshProperties.All)]
        [Editor(typeof(EnumEditor), typeof(UITypeEditor))]
        [TypeConverter(typeof(EnumConverter<Activo>))]
        public Activo _GoogleMaps
        {
            get
            {
                return _GoogleMapsConfig._Activo ? Activo.Si : Activo.No;
            }
            set
            {
                _GoogleMapsConfig._Activo = value == Activo.Si;
                _SetReadOnlyProperty("_GoogleMapsConfig", !_GoogleMapsConfig._Activo);
            }
        }

        [GoogleMapsAttribute, CategoryAttribute("Google maps"), DisplayName("Columnas"), Description("Selecciona las columnas de navegación a google maps")]
        [RefreshProperties(RefreshProperties.All)]
        [Editor(typeof(GoogleMapsEditor), typeof(UITypeEditor))]
        [ReadOnly(false)]
        [TypeConverter(typeof(EmptyConverter))]
        public GoogleMapsConfig _GoogleMapsConfig
        {
            get
            {
                if (_oGoogleMapsConfig == null) _oGoogleMapsConfig = new GoogleMapsConfig();

                return _oGoogleMapsConfig;
            }
            set
            {
                _oGoogleMapsConfig = value;
            }
        }

        [Browsable(false)]
        public GoogleMapsConfig.TipoCampo _TipoCampo
        {
            get
            {
                return (GoogleMapsConfig.TipoCampo)_NTipoCampo;
            }
            set
            {
                _NTipoCampo = Convert.ToInt32(value);
            }
        }

        [Browsable(false)]
        public Int32 _NTipoCampo
        {
            get
            {
                return _nTipoCampo;
            }
            set
            {
                _nTipoCampo = value;
            }
        }

        [Browsable(false)]
        public Boolean _IsNumeric
        {
            get
            {
                return _Type == "numerico";
            }
        }

        [Browsable(false)]
        public Boolean _IsMemo
        {
            get
            {
                return _Type == "memo";
            }
        }

        [Browsable(false)]
        public Boolean _IsBoolean
        {
            get
            {
                return _Type == "logico";
            }
        }

        private String _Type
        {
            get
            {
                if (String.IsNullOrEmpty(_cType) && _DefEntidad is IDefEntidad)
                {
                    _cType = DB.SQLTipoCampo(_DefEntidad._DB, _DefEntidad._Tabla, _DefEntidad._Campo);

                    if (_cType == "caracter")
                    {
                        String lcTipoTmp = DB._TablesInformationSchema(_DefEntidad._DB, _DefEntidad._Tabla)._TipoCampo(_DefEntidad._Campo);
                        if (lcTipoTmp == "text" || lcTipoTmp == "ntext") _cType = "memo";
                    }
                }

                return _cType;
            }
        }

        [Browsable(false)]
        public Boolean _IsDate
        {
            get
            {
                if (String.IsNullOrEmpty(_cType) && _DefEntidad is IDefEntidad) _cType = DB.SQLTipoCampo(_DefEntidad._DB, _DefEntidad._Tabla, _DefEntidad._Campo);

                return _cType == "fecha";
            }
        }

        [Browsable(false)]
        public Dictionary<String, ColumnDefinition> _ColumnsList
        {
            get
            {
                return _oColumnsList;
            }
            set
            {
                _oColumnsList = value;
            }
        }

        [Browsable(false)]
        public Boolean _Visible
        {
            get
            {
                return _bVisible;
            }
            set
            {
                _bVisible = value;
            }
        }

        [Browsable(false)]
        public String _Entidad
        {
            get
            {
                return _GetCodigo(_ListPath, 1);
            }
        }

        public static String _GetCodigo(List<ColumnDefEntidad> loList, Int32 lnPosMax)
        {
            if (lnPosMax < 0) lnPosMax = 0;
            if (loList.Count < lnPosMax) lnPosMax = loList.Count;

            List<String> loCodigos = (from loDef in loList.GetRange(0, lnPosMax)
                                      select loDef._Codigo).ToList();


            return loCodigos.Count > 0 ? loCodigos.Aggregate((a, b) => a + "_" + b) : "";
        }

        #endregion propiedades

        private void _SetReadOnlyProperty(string tcPropertyName, bool tlValue)
        {
            PropertyDescriptor propDescr = TypeDescriptor.GetProperties(this.GetType())[tcPropertyName];
            ReadOnlyAttribute attr = propDescr.Attributes[typeof(ReadOnlyAttribute)] as ReadOnlyAttribute;

            if (attr != null)
            {
                FieldInfo aField = attr.GetType().GetField("isReadOnly", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
                aField.SetValue(attr, tlValue);
            }
        }

        public void _ResetSpecialProperties()
        {
            _SetReadOnlyProperty("_GoogleMapsConfig", !_GoogleMapsConfig._Activo);
            _SetReadOnlyProperty("_TituloNavegacion", !_lPermitirNavegacion);
        }

        public String _GetMascara()
        {
            String lcMascara = "";

            if (_IsNumeric)
            {
                switch (_Mascara)
                {
                    case TipoMascara.Porcentaje:
                        lcMascara = Convert.ToString(EW_GLOBAL._GetMascaraNet(KeyDiccionarioMascara.wc_tpc));
                        break;
                    case TipoMascara.Total:
                        lcMascara = Convert.ToString(EW_GLOBAL._GetMascaraNet(KeyDiccionarioMascara.wc_total));
                        break;
                    case TipoMascara.GrandTotal:
                        lcMascara = Convert.ToString(EW_GLOBAL._GetMascaraNet(KeyDiccionarioMascara.wc_grantotal));
                        break;
                    case TipoMascara.Peso:
                        lcMascara = Convert.ToString(EW_GLOBAL._GetMascaraNet(KeyDiccionarioMascara.wc_mascarapeso));
                        break;
                    case TipoMascara.Unidades:
                        lcMascara = Convert.ToString(EW_GLOBAL._GetMascaraNet(KeyDiccionarioMascara.wc_unidades));
                        break;
                    case TipoMascara.Cajas:
                        lcMascara = Convert.ToString(EW_GLOBAL._GetMascaraNet(KeyDiccionarioMascara.wc_mascaracajas));
                        break;
                    case TipoMascara.PrecioCoste:
                        lcMascara = Convert.ToString(EW_GLOBAL._GetMascaraNet(KeyDiccionarioMascara.wc_precioven));
                        break;
                }
            }
            else if (_IsDate)
            {
                lcMascara = "dd/MM/yyyy";
            }
            return lcMascara;
        }

        public String _GetCodigoParent()
        {
            return _ListPath.Count - 1 > 0 ? _GetCodigo(_ListPath, _ListPath.Count - 1) : _Codigo;
        }

        private DefinicionValores _GetDefinicionValores(String tcValores)
        {
            DefinicionValores loDef = null;

            if(_IsBoolean)
            {
                loDef = new BooleanDefinition(this);
            }
            else if(_IsNumeric && !String.IsNullOrEmpty(tcValores))
            {
                loDef = new NumericDefinition(this, tcValores);
            }
            else
            {
                loDef = new EmptyDefinition(this);
            }

            return loDef;
        }

        private DefinicionValores _GetDefinicionValores(XElement toValores)
        {
            DefinicionValores loDef = null;

            if (_IsBoolean)
            {
                if(toValores is XElement)
                {
                    loDef = new BooleanDefinition(this, toValores);
                }
                else
                {
                    loDef = new BooleanDefinition(this);
                }
            }
            else if (_IsNumeric && toValores is XElement)
            {
                loDef = new NumericDefinition(this, toValores);
            }
            else
            {
                loDef = new EmptyDefinition(this);
            }

            return loDef;
        }

        public String _ToSQLColumnName(String tcAlias)
        {
            String lcCampoParseado;

            if (!String.IsNullOrEmpty(tcAlias) && !tcAlias.Trim().EndsWith(".")) tcAlias = String.Format("{0}.", tcAlias.Trim());
            lcCampoParseado = String.Format("{0}{1}", tcAlias, _DefEntidad._Campo);

            if (_DefinicionValores._Count > 0)
            {
                lcCampoParseado = _DefinicionValores._ToSQL(lcCampoParseado);
            }
            else if(_IsMemo)
            {
                lcCampoParseado = $"CAST({lcCampoParseado} as varchar(254))";
            }
            else if(_DefEntidad._Campo == "FECHABAJA" && _DefEntidad._Tabla == "ARTICULO")
            {
                lcCampoParseado = DB.SQLIif($"{tcAlias}BAJA = 1", $"{tcAlias}FECHABAJA", "NULL");
            }
  
            return $"{lcCampoParseado} as '{_Codigo}'";


        }

        #region constructor

        public ColumnDefinition()
            : base()
        {
        }

        public ColumnDefinition(String tcTitulo)
            : base(tcTitulo)
        {

        }

        public ColumnDefinition(DataRow toRow,  Boolean tlInicial = false)
            : base(toRow, tlInicial)
        {
            _Mante = Convert.ToString(toRow["MANTE"]).Trim();
            _NTipoCampo = Convert.ToInt32(toRow["GOOGLE"]);

            _oDefinicionValores = _GetDefinicionValores(Convert.ToString(toRow["VALORES"]).Trim());
            _oComunicados = _GetComunicados(Convert.ToString(toRow["COMUNICADOS"]).Trim());

            //Asignamos el nombre de la columna añadida
            _ActualizarComunicados();

        }

        private List<IListadoComunicado> _GetComunicados(string tcComunicados)
        {
            List<string> loClasses;
            List<IListadoComunicado> loComunidados = new List<IListadoComunicado>();

            if (!string.IsNullOrEmpty(tcComunicados))
            {
                loClasses = tcComunicados.Split(new char[] { ',', ';' }).ToList();
                loComunidados = _GetComunicadosByType(loClasses);
            }

            return loComunidados;
        }
        
        public static List<IListadoComunicado> _GetComunicadosByType(List<string> toClasses = null)
        {
            dynamic loObjeto;
            List<Type> loTypes;
            List<IListadoComunicado> loComunidados = new List<IListadoComunicado>();

            loTypes = (toClasses == null || toClasses.Count == 0) ? _TypesComunicados : _TypesComunicados.Where(f => toClasses.Contains(f.FullName, new StringComparerToLower())).ToList();

            loTypes.ForEach(f =>
            {
                try
                { 
                    loObjeto = Activator.CreateInstance(f);
                    if (loObjeto is IListadoComunicado) loComunidados.Add(loObjeto);
                }
                catch (Exception ex)
                {
                    DB.Registrar_Error(ex);
                }
            });

            return loComunidados;
        }


        private void _ActualizarComunicados()
        {
            _oComunicados.ForEach(f => f._KeyCampoListado = _Codigo);
        }

        public ColumnDefinition(XElement toElement)
        {
            TipoMascara loMask;
            Accion loAccion;
            bool lInmo = false;

            _Nombre = toElement.Element("Nombre").Value;
            _Titulo = toElement.Element("Caption") != null ? toElement.Element("Caption").Value : _Nombre;
            _Width = Convert.ToInt32(toElement.Element("Ancho").Value);
            _UserWidth = toElement.Element("AnchoVisible") is XElement ? Convert.ToInt32(toElement.Element("AnchoVisible").Value) : _Width;
            _Posicion = Convert.ToInt32(toElement.Element("DisplayIndex").Value);
            _Visible = toElement.Element("Visible") is XElement ?  Convert.ToBoolean(toElement.Element("Visible").Value) : true;
            _Inmobilizada = toElement.Element("Inmobilizada") is XElement && Boolean.TryParse(toElement.Element("Inmobilizada").Value, out lInmo) ? lInmo : false;

            _ColorFondo = toElement.Element("BackColor") is XElement ? _ToColor(toElement.Element("BackColor").Value, Color.White) : Color.White;
            _ColorLetra = toElement.Element("ForeColor") is XElement ? _ToColor(toElement.Element("ForeColor").Value, Color.Black) : Color.Black;

            _PermitirNavegacion = toElement.Element("PermitirNavegacion") is XElement && Boolean.TryParse(toElement.Element("PermitirNavegacion").Value, out lInmo) ? lInmo ? Activo.Si : Activo.No : Activo.No;
            _TituloNavegacion = toElement.Element("TituloNavegacion") is XElement ? toElement.Element("TituloNavegacion").Value : String.Empty;
            _Mante = toElement.Element("Mante") is XElement ? toElement.Element("Mante").Value : String.Empty;

            _IncluirSageReports = toElement.Element("IncluirSageReports") is XElement && Boolean.TryParse(toElement.Element("IncluirSageReports").Value, out lInmo) ? lInmo ? Activo.Si : Activo.No : Activo.Si;
            _IncluirExportacionCSV = toElement.Element("IncluirExportacionCSV") is XElement && Boolean.TryParse(toElement.Element("IncluirExportacionCSV").Value, out lInmo) ? lInmo ? Activo.Si : Activo.No : Activo.Si;

            _oMascara = toElement.Element("Mascara") is XElement && Enum.TryParse<TipoMascara>(toElement.Element("Mascara").Value, out loMask) ?  loMask : TipoMascara.Ninguna;
            _oAccion = toElement.Element("Totalizar") is XElement && Enum.TryParse<Accion>(toElement.Element("Totalizar").Value, out loAccion) ? loAccion : Accion.Ninguna;

            _NTipoCampo = toElement.Element("TipoCampo") is XElement ? Convert.ToInt32(toElement.Element("TipoCampo").Value) : 0;

            _bOculta = toElement.Element("Oculta") is XElement && Boolean.TryParse(toElement.Element("Oculta").Value, out lInmo) ? lInmo : false;

            _DefinicionEntidades.Clear();
            if (toElement.Element("Path") is XElement)
            {
                XElement loElement = toElement.Element("Path");

                foreach (XElement loDef in loElement.Elements("Def"))
                {
                    ColumnDefEntidad loDefEntidad = new ColumnDefEntidad(loDef.Element("Codigo").Value, loDef.Element("Campo").Value, loDef.Element("Tabla").Value, loDef.Element("Relacion").Value, loDef.Element("DB").Value);

                    if (loDef.Elements("DataRel").Count() > 0)
                    {
                        XElement loDefRel = loDef.Element("DataRel");
                        loDefEntidad._DataFieldRelation = new ColumnDefEntidad("", loDefRel.Element("Campo").Value, loDefRel.Element("Tabla").Value, "", loDefRel.Element("DB").Value);
                    }

                    if(loDef.Element("CampoRel") is XElement) loDefEntidad._CampoRel = Convert.ToInt32(loDef.Element("CampoRel").Value);

                    _oListDefEntidad.Add(loDefEntidad);
                    _oDefEntidad = loDefEntidad;
                }
            }

            if (toElement.Element("GoogleMapsConfig") is XElement)
            {
                _GoogleMapsConfig = new GoogleMapsConfig(toElement.Element("GoogleMapsConfig"));
            }

            _oDefinicionValores = _GetDefinicionValores(toElement.Element("ValoresDefinidos") is XElement ? toElement.Element("ValoresDefinidos") : null);

            XElement loComunicados;

            loComunicados = toElement.Element("Comunicados");

            if(loComunicados is XElement)
            {
                _IncluirComunicados = loComunicados.Element("Incluir") is XElement && Boolean.TryParse(loComunicados.Element("Incluir").Value, out lInmo) ? lInmo ? Activo.Si : Activo.No : Activo.No;
                _oComunicados = _GetComunicados(loComunicados.Element("Clases") is XElement ? loComunicados.Element("Clases").Value : null);

                //Asignamos el nombre de la columna añadida
                _ActualizarComunicados();
            }
        }

        public ColumnDefinition(DataColumn toElement)
        {
            _Nombre = toElement.ColumnName;
            _Titulo = toElement.Caption;

            if (toElement.ExtendedProperties.ContainsKey("Width")) _Width = Convert.ToInt32(toElement.ExtendedProperties["Width"]);
            if (toElement.ExtendedProperties.ContainsKey("NoSeleccionada")) _Visible = !Convert.ToBoolean(toElement.ExtendedProperties["NoSeleccionada"]);
        }

        #endregion constructor

        private Color _ToColor(String tcColor, Color toColorDefecte)
        {
            Int32 lnColorInt = 0;
            Color loColor = toColorDefecte;

            if (!String.IsNullOrEmpty(tcColor) && Int32.TryParse(tcColor, out lnColorInt))
            {
                loColor = Color.FromArgb(lnColorInt);
            }
            return loColor;
        }

        public XElement _ToXElement()
        {
            XElement loElement;
            List<XElement> loList = new List<XElement>();
            List<XElement> loPath = new List<XElement>();
            List<XElement> loValores = new List<XElement>();

            loList.Add(new XElement("Nombre", _Nombre));
            loList.Add(new XElement("Ancho", _Width));
            loList.Add(new XElement("AnchoVisible", _UserWidth));
            loList.Add(new XElement("Visible", _Visible));
            loList.Add(new XElement("DisplayIndex", _Posicion));
            loList.Add(new XElement("Caption", _cTituloOriginal));
            loList.Add(new XElement("Inmobilizada", _Inmobilizada ? Boolean.TrueString : Boolean.FalseString));
            loList.Add(new XElement("BackColor", _ColorFondo.ToArgb()));
            loList.Add(new XElement("ForeColor", _ColorLetra.ToArgb()));
            loList.Add(new XElement("IncluirSageReports", _IncluidoSageReports ? Boolean.TrueString : Boolean.FalseString));
            loList.Add(new XElement("IncluirExportacionCSV", _IncluidoCSV ? Boolean.TrueString : Boolean.FalseString));
            loList.Add(new XElement("PermitirNavegacion", _PermiteNavegacion ? Boolean.TrueString : Boolean.FalseString));
            loList.Add(new XElement("TituloNavegacion", _TituloNavegacion ));
            loList.Add(new XElement("Mante", _Mante));
            loList.Add(new XElement("Mascara", Convert.ToInt32(_Mascara)));
            loList.Add(new XElement("Totalizar", Convert.ToInt32(_Accion)));
            loList.Add(new XElement("TipoCampo", _NTipoCampo));
            loList.Add(new XElement("Oculta", _Oculta));
            loList.Add(new XElement("Comunicados", new XElement("Incluir", _bIncluirComunicados ? Boolean.TrueString : Boolean.FalseString), new XElement("Clases", _Comunicados.Count > 0 ? string.Join(",", _Comunicados.Select(f => f.GetType().ToString())) : "")));

            if (_ListPath.Count > 0)
            {
                foreach (ColumnDefEntidad loDef in _ListPath)
                {
                    loPath.Add(new XElement("Def", new XElement("Codigo", loDef._Codigo), new XElement("DB", loDef._DB), new XElement("Tabla", loDef._Tabla), new XElement("Campo", loDef._Campo), new XElement("Relacion", loDef._Relacion), new XElement("CampoRel", loDef._CampoRel), new XElement("DataRel", new XElement("DB", loDef._DataFieldRelation._DB), new XElement("Tabla", loDef._DataFieldRelation._Tabla), new XElement("Campo", loDef._DataFieldRelation._Campo))));
                }
                loList.Add(new XElement("Path", loPath.ToArray()));
            }

            if(_GoogleMapsConfig._Activo) loList.Add(_GoogleMapsConfig._ToXElement());

            if ((_IsBoolean || _IsNumeric)  && _DefinicionValores is DefinicionValores) loList.Add(((DefinicionValores)_DefinicionValores)._ToXElement());
            
            loElement = new XElement("Columna", loList.ToArray());

            return loElement;
        }

        public static List<ColumnDefinition> _ValidaCondicion(List<ColumnDefinition> toColumns)
        {
            if (toColumns == null)
                return null;

            string lcSQL;
            List<string> loIds;
            List<DataRow> loRows;
            ColumnDefinition loCol;
            DataTable loDt = new DataTable();

            loIds = toColumns.Where(f => f._ColumnAdded).Select(f => $"(ca.campo = '{f._DefEntidad._Campo}' AND ta.BASEDATOS = '{f._DefEntidad._DB}' AND ta.TABLA = '{f._DefEntidad._Tabla}') ").ToList();

            if (loIds.Count > 0)
            {
                lcSQL = $@"SELECT ca.CAMPO,ta.BASEDATOS, ta.TABLA, ca.CONDICION FROM {DB.SQLDatabase("COMUNES", "CAMPOS")} ca " +
                        $@"INNER JOIN { DB.SQLDatabase("COMUNES", "TABLAS")} ta ON ca.IDTABLA = ta.ID " +
                        $@"WHERE CONDICION <> '' AND ({string.Join(" OR ", loIds)})";

                if (DB.SQLExec(lcSQL, ref loDt) && loDt.Rows.Count > 0)
                {
                    loRows = (from loRow in loDt.AsEnumerable()
                              where !_ValidateCondition(Convert.ToString(loRow["CONDICION"]))
                              select loRow).ToList();

                    loRows.ForEach(loRow =>
                    {
                        loCol = toColumns.Where(f => f._ColumnAdded && f._DefEntidad._Campo.Trim() == Convert.ToString(loRow["CAMPO"]).Trim() && f._DefEntidad._DB.Trim() == Convert.ToString(loRow["BASEDATOS"]).Trim() && f._DefEntidad._Tabla.Trim() == Convert.ToString(loRow["TABLA"]).Trim()).FirstOrDefault();
                        if (loCol is ColumnDefinition) toColumns.Remove(loCol);
                    });
                    
                }
            }

            return toColumns;
        }

        private static bool _ValidateCondition(string tcCondition)
        {
            tcCondition = tcCondition.Trim();

            return (string.IsNullOrEmpty(tcCondition) || (!string.IsNullOrEmpty(tcCondition) && Menu50._EvaluarCondicion(tcCondition))) ? true : false;
        }

        #region "TypeDescriptor Implementation"

        public String GetClassName()
        {
            return TypeDescriptor.GetClassName(this, true);
        }

        public AttributeCollection GetAttributes()
        {
            return TypeDescriptor.GetAttributes(this, true);
        }

        public String GetComponentName()
        {
            return TypeDescriptor.GetComponentName(this, true);
        }

        public TypeConverter GetConverter()
        {
            return TypeDescriptor.GetConverter(this, true);
        }

        public EventDescriptor GetDefaultEvent()
        {
            return TypeDescriptor.GetDefaultEvent(this, true);
        }

        public PropertyDescriptor GetDefaultProperty()
        {
            return TypeDescriptor.GetDefaultProperty(this, true);
        }

        public object GetEditor(Type editorBaseType)
        {
            return TypeDescriptor.GetEditor(this, editorBaseType, true);
        }

        public EventDescriptorCollection GetEvents(Attribute[] attributes)
        {
            return TypeDescriptor.GetEvents(this, attributes, true);
        }

        public EventDescriptorCollection GetEvents()
        {
            return TypeDescriptor.GetEvents(this, true);
        }

        public PropertyDescriptorCollection GetProperties(Attribute[] attributes)
        {
            List<PropertyDescriptor> fullList = new List<PropertyDescriptor>();

            //gets the base properties  (omits custom properties)
            PropertyDescriptorCollection defaultProperties = TypeDescriptor.GetProperties(this, attributes, true);

            foreach (PropertyDescriptor prop in defaultProperties)
            {
                if (prop.Attributes.OfType<NumericAttribute>().Count() > 0)
                {
                    if (_IsNumeric &&  _DefinicionValores._Count == 0) fullList.Add(prop);
                }
                else if(prop.Attributes.OfType<EnumerationDefinitionAttribute>().Count() > 0)
                {
                    if ((_IsNumeric || _IsBoolean) && _DefinicionValores._Count > 0) fullList.Add(prop);
                }
                else if (prop.Attributes.OfType<ManteAttribute>().Count() > 0)
                {
                    if (!String.IsNullOrEmpty(_Mante)) fullList.Add(prop);
                }
                else if (prop.Attributes.OfType<GoogleMapsAttribute>().Count() > 0)
                {
                    if (_PermiteGoogleMaps) fullList.Add(prop);
                }
                else if (prop.Attributes.OfType<ComunicadoAttribute>().Count() > 0)
                {
                    if (Convert.ToBoolean(EW_GLOBAL._GetVariable("WL_COMUNICADOS")) && _Comunicados.Count > 0) fullList.Add(prop);
                }
                else
                {
                    fullList.Add(prop);
                }
            }

            return new PropertyDescriptorCollection(fullList.ToArray());
        }

        public PropertyDescriptorCollection GetProperties()
        {

            return TypeDescriptor.GetProperties(this, true);

        }

        public object GetPropertyOwner(PropertyDescriptor pd)
        {
            return this;
        }
        #endregion        
    }

    #region attributtes 
   
    public class NumericAttribute : Attribute
    {

    }

    public class ComunicadoAttribute : Attribute
    {

    }

    public class ManteAttribute : Attribute
    {

    }

    public class GoogleMapsAttribute : Attribute
    {

    }

    public class BooleanAttribute : Attribute
    {

    }

    public class EnumerationDefinitionAttribute : Attribute
    {

    }

    #endregion attributtes 

    public class ColumnDefEntidad : DefEntidad
    {
        private String _cCodigo;
        private String _cTablaId;
        private ColumnDefEntidad _oDataFieldRelation = null;

        private Int32 _nCampoRel = 0;
        private ColumnDefEntidad _oColumnRel = null;

        [Browsable(false)]
        public Int32 _CampoRel
        {
            get
            {
                return _nCampoRel;
            }
            set
            {
                if (_nCampoRel != value)
                {
                    _nCampoRel = value;
                    _oColumnRel = null;
                }
            }
        }


        public ColumnDefEntidad _ColumnRel
        {
            get
            {
                if (_oColumnRel == null && _nCampoRel > 0)
                {
                    DataTable loDt = ColumnDefinition._GetColumns(String.Format("ca.IDCAMPO = {0}", _nCampoRel), Convert.ToInt32(_Relacion));
                    if (loDt.Rows.Count > 0) _oColumnRel = new ColumnDefEntidad(loDt.Rows[0], false);
                }
                return _oColumnRel;
            }
        }

        public String _Codigo
        {
            get
            {
                return _cCodigo;
            }
            set
            {
                _cCodigo = value;
            }
        }
    
        public String _TablaId
        {
            get
            {
                return _cTablaId;
            }
            set
            {
                _cTablaId = value;
            }
        }

        public ColumnDefEntidad _DataFieldRelation
        {
            get
            {
                if (_oDataFieldRelation == null) _oDataFieldRelation = new ColumnDefEntidad();
                return _oDataFieldRelation;
            }
            set
            {
                _oDataFieldRelation = value;
            }
        }

        public ColumnDefEntidad()
            : base()
        {
        }

        public ColumnDefEntidad(DataRow toRow, Boolean tlInicial = false)
            : base()
        {
            String tcTitulo = Convert.ToString(toRow["NOMBRE"]).Trim();
            String tcIdMante = Convert.ToString(toRow[tlInicial ? "ID" : "IDMANTE"]);
            String tcIdTabla = Convert.ToString(toRow["ID"]);
            String lcCodigo = Convert.ToString(toRow["IDCAMPO"]).Trim();
            String lcCampo = Convert.ToString(toRow["CAMPO"]).Trim();
            String lcMante = Convert.ToString(toRow["MANTE"]).Trim().ToLower();
            Int32 lnIdCampoRel = Convert.ToInt32(toRow["IDCAMPOR"]);

            lcCodigo = String.IsNullOrWhiteSpace(lcMante) ? String.Format("{0}", lcCampo).ToLower() : String.Format("{0}_{1}", lcMante, lcCampo).ToLower();

            ColumnDefEntidad loDefEntidadRel = new ColumnDefEntidad() { _DB = Convert.ToString(toRow["BASEDATOS_REL"]).Trim(), _Tabla = Convert.ToString(toRow["TABLA_REL"]).Trim(), _Campo = Convert.ToString(toRow["CAMPO_REL"]).Trim(), _Empresa = false };

            _Codigo = lcCodigo;
             _DB = Convert.ToString(toRow["BASEDATOS"]).Trim();
            _TablaId = tcIdTabla;
            _Tabla = Convert.ToString(toRow["TABLA"]).Trim();
            _Campo = lcCampo;
            _Relacion = tcIdMante;
            _Empresa = false;
            _DataFieldRelation = loDefEntidadRel;
            _CampoRel = lnIdCampoRel;


        }

        public ColumnDefEntidad(string tcCodigo, string tcCampo, string tcTabla, string tcRelacion, string tcDb = "GESTION", bool tlEmpresa = false)
            : base(tcCampo, tcTabla, tcRelacion, tcDb, tlEmpresa)
        {
            _cCodigo = tcCodigo;          
        }
    }

    public class GoogleMapsEditor : UITypeEditor
    {
        public override UITypeEditorEditStyle GetEditStyle(ITypeDescriptorContext context)
        {
            ReadOnlyAttribute attr = context.PropertyDescriptor.Attributes[typeof(ReadOnlyAttribute)] as ReadOnlyAttribute;
            return attr.IsReadOnly ? UITypeEditorEditStyle.None : UITypeEditorEditStyle.Modal;
        }

        public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value)
        {
            IWindowsFormsEditorService svc = provider.GetService(typeof(IWindowsFormsEditorService)) as IWindowsFormsEditorService;
            ReadOnlyAttribute attr = context.PropertyDescriptor.Attributes[typeof(ReadOnlyAttribute)] as ReadOnlyAttribute;

            if (svc != null && !attr.IsReadOnly)
            {
                ColumnDefinition loDef = (ColumnDefinition)context.Instance;

                FormListadoGogleMapsColumnas loForm = new FormListadoGogleMapsColumnas();

                loForm._ColumnsList = loDef._ColumnsList;
                loForm._GoogleMapsColumns = (GoogleMapsConfig)value;
                loForm._ShowDialog();

                if (DialogResult.OK == loForm.DialogResult)
                {
                    loDef._GoogleMapsConfig._Columns = loForm._GoogleMapsColumns._Columns;
                }
            }

            return value;
        }
    }

    public class PosicionEditor : UITypeEditor
    {
        public override UITypeEditorEditStyle GetEditStyle(ITypeDescriptorContext context)
        {
            return UITypeEditorEditStyle.Modal;
        }

        public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value)
        {
            IWindowsFormsEditorService svc = provider.GetService(typeof(IWindowsFormsEditorService)) as IWindowsFormsEditorService;

            if (svc != null)
            {
                ColumnDefinition loDef = (ColumnDefinition)context.Instance;

                FormListadoPosicionColumnas loForm = new FormListadoPosicionColumnas();

                loForm._ColumnsList = loDef._ColumnsList;
                loForm._ShowDialog();

                if (DialogResult.OK == loForm.DialogResult)
                {
                    loDef._ColumnsList = loForm._ColumnsList;
                }
            }

            return value;
        }
    }


    public class ValuesEditor : UITypeEditor
    {
        public override UITypeEditorEditStyle GetEditStyle(ITypeDescriptorContext context)
        {
            return UITypeEditorEditStyle.Modal;
        }

        public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value)
        {
            IWindowsFormsEditorService svc = provider.GetService(typeof(IWindowsFormsEditorService)) as IWindowsFormsEditorService;

            if (svc != null)
            {
                ColumnDefinition loDef = (ColumnDefinition)context.Instance;

                FormListadoValoresColumnas loForm = new FormListadoValoresColumnas();

                loForm._ColumnName = loDef._Titulo;
                loForm._DefinicionValores = loDef._DefinicionValores;
                loForm._ShowDialog();

                if (DialogResult.OK == loForm.DialogResult)
                {
                    loDef._DefinicionValores = loForm._DefinicionValores;
                }
            }

            return value;
        }
    }
    
    public class EnumEditor : UITypeEditor
    {
        private IWindowsFormsEditorService _editorService;
        private bool _cancel;

        public override UITypeEditorEditStyle GetEditStyle(ITypeDescriptorContext context)
        {
            return UITypeEditorEditStyle.DropDown;
        }

        public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value)
        {
            ListBox loListBox;

            _editorService = (IWindowsFormsEditorService)provider.GetService(typeof(IWindowsFormsEditorService));

            loListBox = _GetListBox();
           
            Type enumType = value.GetType();
            if (enumType.IsEnum)
            {
                foreach (FieldInfo fi in _GetFields(context, enumType))
                {
                    EnumItem item = new EnumItem();
                    item.Value = fi.GetValue(null);

                    object[] atts = fi.GetCustomAttributes(typeof(DescriptionAttribute), true);
                    if (atts != null && atts.Length > 0)
                    {
                        item.Name = ((DescriptionAttribute)atts[0]).Description;
                    }
                    else
                    {
                        item.Name = fi.Name;
                    }

                    int index = loListBox.Items.Add(item);

                    if (fi.Name == value.ToString())
                    {
                        loListBox.SetSelected(index, true);
                    }
                }
            }           
            else
            {
                throw new InvalidOperationException(); 
            }

            loListBox.Height = Convert.ToInt32(loListBox.Items.Count * (loListBox.ItemHeight + 5));

            _cancel = false; ;
            _editorService.DropDownControl(loListBox);
            if (_cancel || loListBox.SelectedIndices.Count == 0)
                return value;

            return ((EnumItem)loListBox.SelectedItem).Value;
        }

        private ListBox _GetListBox()
        {
            ListBox loListBox = new ListBox();

            loListBox.DisplayMember = "Name"; 
            loListBox.IntegralHeight = true;
            loListBox.SelectionMode = SelectionMode.One;
            loListBox.MouseClick += OnListBoxMouseClick;
            loListBox.KeyDown += OnListBoxKeyDown;
            loListBox.PreviewKeyDown += OnListBoxPreviewKeyDown;
            loListBox.BorderStyle = BorderStyle.None;

            return _ConfigureListBox(loListBox);
        }

        protected virtual ListBox _ConfigureListBox(ListBox toListBox)
        {
            return toListBox;
        }

        protected virtual IEnumerable<FieldInfo> _GetFields(ITypeDescriptorContext context, Type toEnumType)
        {
            return toEnumType.GetFields(BindingFlags.Public | BindingFlags.Static);
        }

        private class EnumItem
        {
            public object Value { get; set; }
            public string Name { get; set; }
        }

        private void OnListBoxPreviewKeyDown(object sender, PreviewKeyDownEventArgs e)
        {
            if (e.KeyCode == Keys.Escape)
            {
                _cancel = true;
                _editorService.CloseDropDown();
            }
        }

        private void OnListBoxMouseClick(object sender, MouseEventArgs e)
        {
            int index = ((ListBox)sender).IndexFromPoint(e.Location);
            if (index >= 0)
            {
                _editorService.CloseDropDown();
            }
        }

        private void OnListBoxKeyDown(object sender, KeyEventArgs e)
        {
            if (e.KeyCode == Keys.Enter)
            {
                _editorService.CloseDropDown();
            }
        }
    }

    public class EmptyConverter: TypeConverter 
    {
        public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
        {
            return String.Empty ;
        }
    }

    public class EnumConverter<TEnum> : TypeConverter where TEnum : struct
    {
        public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
        {
            return sourceType == typeof(string) || base.CanConvertFrom(context, sourceType);
        }

        public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
        {
            string svalue = string.Format(culture, "{0}", value);
            TEnum e;
            if (Enum.TryParse(svalue, out e))
                return e;

            foreach (FieldInfo fi in typeof(TEnum).GetFields(BindingFlags.Public | BindingFlags.Static))
            {
                object[] atts = fi.GetCustomAttributes(typeof(DescriptionAttribute), true);
                if (atts != null && atts.Length > 0)
                {
                    if (string.Compare(((DescriptionAttribute)atts[0]).Description, svalue, StringComparison.OrdinalIgnoreCase) == 0)
                        return fi.GetValue(null);
                }
            }

            return base.ConvertFrom(context, culture, value);
        }

        public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
        {
            return destinationType == typeof(string) || base.CanConvertTo(context, destinationType);
        }

        public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
        {
            if (destinationType == typeof(string))
            {
                string svalue = string.Format(culture, "{0}", value);
                foreach (FieldInfo fi in typeof(TEnum).GetFields(BindingFlags.Public | BindingFlags.Static))
                {
                    object[] atts = fi.GetCustomAttributes(typeof(DescriptionAttribute), true);
                    if (atts != null && atts.Length > 0)
                    {
                        if (string.Compare(fi.Name, svalue, StringComparison.OrdinalIgnoreCase) == 0)
                            return ((DescriptionAttribute)atts[0]).Description;
                    }
                }
            }
            return base.ConvertTo(context, culture, value, destinationType);
        }
    }

    #region ValuesDefinition 

    public class EmptyDefinition
        : DefinicionValores
    {
        public override List<DefinicionValor> _Values
        {
            get
            {
                return new List<DefinicionValor>();
            }            
        }

        public EmptyDefinition(ColumnDefinition toColumnDefinition)
            : base(toColumnDefinition)
        {
        }
    }

    public class BooleanDefinition
        : DefinicionValores
    {
        private String _cDefaultDefinicionValorTrue = "Sí";
        private String _cDefaultDefinicionValorFalse = "No";

        public BooleanDefinition(ColumnDefinition toColumnDefinition)
            : base(toColumnDefinition)
        {
            _SetValue(true, _cDefaultDefinicionValorTrue, "Verdadero");
            _SetValue(false, _cDefaultDefinicionValorFalse, "Falso");
        }

        public override String _ToSQL(String tcFieldName)
        {
            Dictionary<String, String> loDic = new Dictionary<string, string>();

            loDic.Add(DB.SQLTrue(), DB.SQLString(_GetValue(true)));
            loDic.Add(DB.SQLFalse(), DB.SQLString(_GetValue(false)));

            return DB.SQLCase(tcFieldName, loDic, "''");
        }

        public BooleanDefinition(ColumnDefinition toColumnDefinition, XElement toValores)
            :base(toColumnDefinition, toValores)
        {
            _SetKeyDescription(true, "Verdadero");
            _SetKeyDescription(false, "Falso");
        }
    }

    public class NumericDefinition
        : DefinicionValores
    {
        public NumericDefinition(ColumnDefinition toColumnDefinition, String tcValores)
            :base(toColumnDefinition)
        {
            _SetValores(tcValores);            
        }

        public NumericDefinition(ColumnDefinition toColumnDefinition, XElement toValores)
            : base(toColumnDefinition, toValores)
        {
            _ComprobarValores();
        }

        private void _ComprobarValores()
        {
            String lcSql;
            DataTable loDt = new DataTable();

            lcSql = String.Format("SELECT c.VALORES FROM {0} c INNER JOIN {1} t ON t.ID = c.IDTABLA WHERE c.CAMPO = '{2}' AND t.TABLA = '{3}' AND t.BASEDATOS = '{4}' ", DB.SQLDatabase("COMUNES", "CAMPOS"), DB.SQLDatabase("COMUNES", "TABLAS"), _ColumDefinition._DefEntidad._Campo, _ColumDefinition._DefEntidad._Tabla, _ColumDefinition._DefEntidad._DB);

            if(DB.SQLExec(lcSql , ref loDt) && loDt.Rows.Count > 0)
            {
                List<DefinicionValor> loDefTmp;
                List<DefinicionValor> loTmp = _Values.Where(f=>f._ColorChanged()).ToList();

                _SetValores(Convert.ToString(loDt.Rows[0]["VALORES"]));

                foreach(DefinicionValor loDef in loTmp)
                {
                    loDefTmp = _Values.Where(f => f._Key == loDef._Key).ToList();
                    if (loDefTmp.Count > 0) loDefTmp.First()._Color = loDef._Color;
                }
            }
        }

        private void _SetValores(String tcValores)
        {
            String[] loValores;
            String lcKey, lcValue, lcValorTmp;
            
            _Values.Clear();

            try
            {
                if (!String.IsNullOrEmpty(tcValores.Trim()))
                {
                    loValores = tcValores.Split(',');

                    foreach (String lcValor in loValores)
                    {
                        lcValorTmp = lcValor.Trim();
                        lcKey = lcValorTmp.Substring(0, lcValorTmp.IndexOf(' '));
                        lcValue = lcValorTmp.Trim().Substring(lcValorTmp.IndexOf(' ') + 1);

                        _SetValue(lcKey, lcValue);
                    }
                }
            }
            catch
            {
                _Values.Clear();
            }
        }
    }

    public abstract class DefinicionValores
    {
        private ColumnDefinition _oColumnDefinition;
        private List<DefinicionValor> _oValues = new List<DefinicionValor>();
        private Color _oDefaultColor = Color.Black;

        public Color _DefaultColor
        {
            get
            {
                return _oDefaultColor;
            }
            internal set
            {
                _oDefaultColor = value;

                foreach(DefinicionValor loDefinicionValor in _Values)
                {
                    loDefinicionValor._DefaultColor = _oDefaultColor;
                }                
            }
        }

        public String _ColumnName
        {
            get
            {
                return _oColumnDefinition._Codigo;
            }
        }

        protected ColumnDefinition _ColumDefinition
        {
            get
            {
                return _oColumnDefinition;
            }
        }

        public Int32 _Count
        {
            get
            {
                return _oValues.Count;
            }
        }

        public virtual List<DefinicionValor> _Values
        {
            get
            {
                return _oValues;
            }
            set
            {
                _oValues = value;
            }
        }

       

        public void _SetValue(Object toKey, Object toValue, Color toColor, String tcKeyDescription = "")
        {
            String lcKey;

            lcKey = toKey.ToString().Trim();
            DefinicionValor loValue = _oValues.Find(f => f._Key == lcKey);

            if (loValue is DefinicionValor)
            {
                loValue._Value = toValue.ToString();
                loValue._Color = toColor;
                loValue._DefaultColor = _oColumnDefinition._ColorLetra;
                loValue._KeyDescription = tcKeyDescription;
            }
            else
            {
                _oValues.Add(new DefinicionValor(lcKey, toValue.ToString()) { _Color = toColor, _KeyDescription = tcKeyDescription, _DefaultColor = _oColumnDefinition._ColorLetra });
            }
        }

        public void _SetValue(Object toKey, Object toValue)
        {
            _SetValue(toKey, toValue, _DefaultColor);
        }

        public void _SetValue(Object toKey, Object toValue, String tcKeyDescription)
        {
            _SetValue(toKey, toValue, _DefaultColor, tcKeyDescription);
        }

        public String _GetValue(Object toKey)
        {
            String lcKey;

            lcKey = toKey.ToString();
            DefinicionValor loValue = _oValues.Find(f => f._Key == lcKey);

            if (loValue is DefinicionValor) lcKey = loValue._Value;

            return lcKey;
        }

        protected void _SetKeyDescription(Object toKey, String tcDescription)
        {
            String lcKey;

            lcKey = toKey.ToString();
            DefinicionValor loValue = _oValues.Find(f => f._Key == lcKey);

            if (loValue is DefinicionValor)  loValue._KeyDescription = tcDescription;
        }

        public virtual String _ToSQL(String tcFieldName)
        {
            return DB.SQLCase(tcFieldName, _oValues.ToDictionary(a => a._Key, a => DB.SQLString(a._Value)), "''");
        }

        private Color _ToColor(String tcColor)
        {
            Int32 lnColorInt = 0;
            Color loColor = Color.Black;

            if (!String.IsNullOrEmpty(tcColor) && Int32.TryParse(tcColor, out lnColorInt))
            {
                loColor = Color.FromArgb(lnColorInt);
            }
            return loColor;
        }

        public XElement _ToXElement()
        {
            List<XElement> loLisXElements = new List<XElement>();

            loLisXElements = (from loValue in _Values
                              select new XElement("ValorDefinido", new XElement[] { new XElement("Key", loValue._Key), new XElement("Value", loValue._Value), new XElement("Color", loValue._Color.ToArgb()) })).ToList();

            return new XElement("ValoresDefinidos", loLisXElements);

        }

        private DefinicionValores(DefinicionValores toSageReportsValuesDefinition)
        {
            _Values = toSageReportsValuesDefinition._Values;
        }

        public DefinicionValores(ColumnDefinition toColumnDefinition, XElement toElement)
            :this(toColumnDefinition)
        {
            if (toElement.Name == "ValoresDefinidos")
            {
                foreach (XElement loe in toElement.Elements())
                {
                    if (loe.Element("Key") is XElement && loe.Element("Value") is XElement)
                    {
                        _SetValue(loe.Element("Key").Value.ToString(), loe.Element("Value").Value.ToString(), _ToColor(loe.Element("Color").Value.ToString()));
                    }
                }
            }
        }

        public DefinicionValores(ColumnDefinition toColumnDefinition)
        {
            _oColumnDefinition = toColumnDefinition;
            _oDefaultColor = toColumnDefinition._ColorLetra;
        }

        public class DefinicionValor
        {
            private String _cKey;
            private String _cKeyDescription;
            private String _cValue;
            private Color _oColor;
            private Color _oDefaultColor = Color.Black;

            internal Color _DefaultColor
            {
                set
                {
                    if (!_ColorChanged()) _oColor = value;
                    _oDefaultColor = value;
                }
            }

            public String _KeyDescription
            {
                get
                {
                    return String.IsNullOrEmpty(_cKeyDescription) ? _Key : _cKeyDescription;
                }
                set
                {
                    _cKeyDescription = value.Trim();
                }
            }

            public String _Key
            {
                get
                {
                    return _cKey;
                }
                set
                {
                    _cKey = value.Trim();
                }
            }

            public String _Value
            {
                get
                {
                    return _cValue;
                }
                set
                {
                    _cValue = value;
                }
            }

            public Color _Color
            {
                get
                {
                    return _oColor;
                }
                set
                {
                    _oColor = value;
                }
            }

            public Boolean _ColorChanged()
            {
                return _oColor.ToArgb() != _oDefaultColor.ToArgb();
            }

            public DefinicionValor(String tcKey, String tcValue)
                : this()
            {
                _Key = tcKey;
                _Value = tcValue;
            }

            public DefinicionValor()
            {
                _oColor = _oDefaultColor;
            }
        }

    }


    #endregion ValuesDefinition 

    public class StringComparerToLower
        : IEqualityComparer<string>
    {
        public bool Equals(string x, string y)
        {
            return x.ToLower() == y.ToLower();
        }

        public int GetHashCode(string obj)
        {
            return obj.GetHashCode();
        }
    }
}