frmDocumentosPorProveedor.cs

using System;
using System.Collections.Generic;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Windows.Forms;
using System.Globalization;
using sage.ew.formul.Forms;
using sage.ew.listados.Clases;
using sage.ew.global;
using sage.ew.ewbase;
using sage.ew.empresa;
using sage.ew.objetos;
using sage.ew.db;
using sage.ew.docsven;
using sage.ew.interficies;
using sage.ew.functions;
using sage.ew.ewbase.Clases;
using sage.ew.global.Diccionarios;

namespace sage.ew.docscompra.Forms
{
    public partial class frmDocumentosPorProveedor : FormSalirProveedorArticulo
    {
        #region propiedades

        public dynamic _DocumentoOrigen = null;

        private string _UltimoDocumentoSeleccionado = string.Empty;

        // Obtenemos variables de configuración
        private bool _lColor = Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_color"));
        private bool _lPeso = Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_Peso"));
        private bool _lCajas = Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_Cajas"));
        private bool _lObra = Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_obra"));
        private bool _lHera = Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_hera"));

        // Máscaras de columnas                          
        ewMascara _oMascaraImport = new ewMascara(KeyDiccionarioMascara.wc_total);
        ewMascara _oMascaraPrecio = new ewMascara(KeyDiccionarioMascara.wc_precioven);
        ewMascara _oMascaraPorcent = new ewMascara(KeyDiccionarioMascara.wc_tpc);
        ewMascara _oMascaraUnidades = new ewMascara(KeyDiccionarioMascara.wc_unidades);
        ewMascara _oMascaraPeso = new ewMascara(KeyDiccionarioMascara.wc_mascarapeso);
        ewMascara _oMascaraCajas = new ewMascara("999,999");

        //PE-102176 Descripción cajas
        string _cDesCajas = (Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_hera")) && Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_cajas"))) ?
            "Nº Agrup." : Convert.ToString(EW_GLOBAL._GetVariable("wc_descajas","Cajas")).Trim();
        //PE-102176 Descripción unidades
        string _cDesUnidades = Convert.ToString(EW_GLOBAL._GetVariable("wc_desunidades")).Trim();


        public string _Empresa = string.Empty;

        public string _Numero = string.Empty;
        
        public string _Factura = string.Empty;

        //Vinculo a la base para que aplique configuración de divisa
        public Listados _Cabeceras
        {
            get { return _Listado; }
            set {  _Listado = value; }
        }

        //Vinculo a la base para que aplique configuración de divisa
        public Listados _Detalles
        {
            get { return _ListadoDetalle; }
            set { _ListadoDetalle = value; }
        }

        protected bool _lSeleccion_Multiple = false;
        private bool _lMarcarDesmarcar = true; //Prefijamos para que marque
        private string _cNomColSeleccionar = "Sel.";

        public List<object> _Seleccion_Multiple_Lista
        {
            get { return _lis_Seleccion_Multiple_Resultados; }
        }
        private List<object> _lis_Seleccion_Multiple_Resultados = new List<object>();

        public List<string> _Seleccion_Multiple_Campos
        {
            set 
            { 
                _lis_Seleccion_Multiple_Campos = value;
                if (value != null) _Activar_Seleccion_Multiple();
            }
        }
        protected List<string> _lis_Seleccion_Multiple_Campos = new List<string>();

        //Task 150273
        public bool ModoCapturaParaTraspaso { get; set; } = false;
        private bool _lMarcarDesmarcarDetalle = true; //Prefijamos para que marque
        public eTipoDocumento TipoDeDocumentoCapturable { get; set; } = eTipoDocumento.Indeterminado;

        private bool ConfigurandoControles
        {
            get { return _configurandoControles; }
            set
            {
                _configurandoControles = value;
                if (!_configurandoControles && _recargaDatosRequerida) //Evaluo si durante las operaciones de configuración se han modificado datos que requieren recargar
                {
                    _recargaDatosRequerida = false;
                    _Refrescar_Datos();
                }
            }
        }
        private bool _configurandoControles = false; //No usar la privada
        private bool _recargaDatosRequerida = false;

        #endregion propiedades

        #region constructores

        public frmDocumentosPorProveedor()
        {
            _Init();
        }

        public frmDocumentosPorProveedor(Listados loList)
        {
            //Los detalles provienen del mismo listado del que se sacan las cabeceras
            _Init(loList, (Listados)Activator.CreateInstance(loList.GetType()));
        }

        public frmDocumentosPorProveedor(Listados loCabeceras, Listados loDetalles)
        {
            //Los detalles y la cabecera son dos listados diferentes
            _Init(loCabeceras, loDetalles);
        }

        private void _Init(Listados toCabecera = null, Listados toDetalle = null)
        {
            InitializeComponent();
            
            if (DesignMode)
                return;

            _Empresa = Convert.ToString(EW_GLOBAL._GetVariable("wc_empresa"));
            btImprimir1._Click_Before += new botones.Clases.btImprimir._Click_Before_Handler(BtImprimir1__Click_Before);
            if(toCabecera != null)
                _Cabeceras = toCabecera;
            if(toDetalle != null)
                _Detalles = toDetalle;

            _MostrarCrearAccesoDirecto = false;
            _MostrarAccesoFavoritos = false;

            ConfigurarControlesHeredados();

            ewImgInfoLineasSeleccionables.Image = sage.ew.images.Properties.Resources.info_16;
        }

        private void ConfigurarControlesHeredados()
        {
            //Task 105512 Ajustes de los controles heredados
            _oTablePpal.Width = _CalcularAnchoControlCabecera();

            //No filtramos por artículo
            _FiltrarArticulo = false;

            //habilito el botón refrescar
            //btRefrescar.Visible = true;

            //Filtros verticales
            _oFiltroVertical.Controls.Add(panelCancel);
            _oFiltroVertical.Controls.Add(panelFacturados);
            _oFiltroVertical.Controls.Add(panelTrasp);

            //Filtro horizontal
            _oFiltroHorizontal.Controls.Add(panelComentarios);

            //Determino el tamaño para los datos
            scDatos.Location = _CalcularLocationDatos();
            scDatos.Height = _CalcularAlturaDisponible();
        }

        protected override Point _CalcularLocationDatos()
        {
            return new Point (base._CalcularLocationDatos().X, base._CalcularLocationDatos().Y - 28); //Se produce algú tipo de resize  no contemplado
        }

        #endregion constructores

        #region métodos

        void ChkComentarios_CheckedChanged(object sender, EventArgs e)
        {
            if (updatingCheckComentarios == true)
                return;

            updatingCheckComentarios = true;

            if (ModoCapturaParaTraspaso && !chkComentarios.Checked)
            {
                chkComentarios.Checked = true;
                string mensaje = "Para operaciones de traspaso es necesario tener visibles los comentarios.";
                _MessageBox(mensaje, MessageBoxButtons.OK, MessageBoxIcon.Exclamation, MessageBoxDefaultButton.Button1, DialogResult.None);
            }

            _lLastSelectedIndex = 0;
            if (ewgridDatos.SelectedRows.Count > 0)
                _lLastSelectedIndex = ewgridDatos.SelectedRows[0].Index;

            _Refrescar_Detalle();

            updatingCheckComentarios = false;
        }

        private bool updatingCheckComentarios = false;

        private void _Activar_Seleccion_Multiple()
        {
            //Activo variable de control
            _lSeleccion_Multiple = true;

            //Ajusto el botón
            btNavegar.Text = "Capturar documentos";
            btNavegar.TextImageRelation = TextImageRelation.ImageBeforeText;
            btNavegar.TextAlign = ContentAlignment.MiddleCenter;
        }

        protected override void _Cargar_Datos()
        {
            base._Cargar_Datos();

            if (!DesignMode)
                _Refrescar_Datos();
        }

        private Listados GetListadosInstance(bool tlCabeceras = true)
        {
            Type loType = null;
            if(tlCabeceras)
                loType = _Cabeceras.GetType();
            else
                loType = _Detalles.GetType();
            Listados loLis = (Listados)Activator.CreateInstance(loType);
            return loLis;
        }

        private void FrmDocumentosPorProveedor_Shown(object sender, EventArgs e)
        {
            ConfigurandoControles = true;

            // Inicializar grid principal
            ewgridDatos.Parent = scDatos.Panel1;
            ewgridDatos.Top = lbDocumentos.Top + 20;
            ewgridDatos.Left = ewgridDetalle.Left;
            ewgridDatos.Size = ewgridDetalle.Size;
            ewgridDatos.Anchor = AnchorStyles.Top | AnchorStyles.Left | AnchorStyles.Right | AnchorStyles.Bottom;
            ewgridDatos.ReadOnly = true;
            ewgridDatos.AutoSizeColumnsMode = DataGridViewAutoSizeColumnsMode.DisplayedCells;
            ewgridDatos.RowHeadersWidth = 24;
            ewgridDatos.RowHeadersWidthSizeMode = DataGridViewRowHeadersWidthSizeMode.DisableResizing;            
            ewgridDatos.SelectionChanged += new EventHandler(EwgridDatos_SelectionChanged);
            ewgridDatos.CellMouseDoubleClick += new DataGridViewCellMouseEventHandler(EwgridDatos_CellMouseDoubleClick);
            ewgridDatos.AllowUserToAddRows = false;
            ewgridDatos.AllowUserToDeleteRows = false;

            // Inicializar grid detalle    
            ewgridDetalle.Parent = scDatos.Panel2;
            ewgridDetalle.Top = lbDetalle.Top + 20;
            ewgridDetalle.Anchor = AnchorStyles.Top | AnchorStyles.Left | AnchorStyles.Right | AnchorStyles.Bottom;
            ewgridDetalle.ReadOnly = true;
            ewgridDetalle.RowHeadersWidth = 24;
            ewgridDetalle.RowHeadersWidthSizeMode = DataGridViewRowHeadersWidthSizeMode.DisableResizing;            
            ewgridDetalle.AllowUserToAddRows = false;
            ewgridDetalle.AllowUserToDeleteRows = false;

            // Otras            
            txtImporte.ReadOnly = true;            
            btNavegar.Image = images.Properties.Resources.doc_navigate;
            btNavegar.ImageAlign = ContentAlignment.MiddleLeft;
            btListar.Image = images.Properties.Resources.reports;
            btListar.ImageAlign = ContentAlignment.MiddleLeft;

            //Defino la columna de selección
            if (_lSeleccion_Multiple || ModoCapturaParaTraspaso)
            {
                ewgridDatos.Columns[_cNomColSeleccionar].ReadOnly = false;
                ewgridDatos.MultiSelect = true;
                ewgridDatos.CellClick += new DataGridViewCellEventHandler(Evento_ewgridDatos_CellClick);
                ewgridDatos.ColumnHeaderMouseClick += new DataGridViewCellMouseEventHandler(Evento_ewgridDatos_ColumnHeaderMouseClick);

                if(ModoCapturaParaTraspaso) //También hay seleccioón lineas
                {
                    if (!chkComentarios.Checked) { chkComentarios.Checked = true; } //Bug 153804 => Asignación sin cambio de valor hacia saltar un refresco de datos
                    ewgridDatos.CellValueChanged += EwgridDatos_CellValueChanged;
                    ewgridDetalle.Columns[_cNomColSeleccionar].ReadOnly = false;
                    ewgridDetalle.MultiSelect = true;
                    ewgridDetalle.CellClick += new DataGridViewCellEventHandler(Evento_ewgridDetalle_CellClick);
                    ewgridDetalle.ColumnHeaderMouseClick += new DataGridViewCellMouseEventHandler(Evento_ewgridDetalle_ColumnHeaderMouseClick);
                }
            }

            // Inicializar proveedor
            if (!string.IsNullOrWhiteSpace(_Proveedor))
            {
                _Refrescar_Datos();
            }
            else
                _Configurar_Grid(); //Bug 

            txtProveedor._setTxtBoxFocus(); //Bug 112527

            //Fuerzo que me indique el símbolo actual (el cambio por evento no se dispara antes de que el formulario sea visible)
            ActualizarEtiquetaSimboloDivisa();

            //Task 150273 => Cambios para el modo de captura de datos
            InicializarModoCapturaParaTraspaso();

            ConfigurandoControles = false;
        }

        protected virtual void _Refrescar_Datos()
        {
            if (_Cabeceras == null)
                return;

            if (ConfigurandoControles)
            {
                _recargaDatosRequerida = true;
                return;
            }

            _cargandoCabeceras = true;

            DataTable ldtDatos = new DataTable();


            // Cargamos las opciones especificas del formulario
            _Listado = _Refrescar_Datos_Cargar_Opciones_Listado();

            // Preparar filtros principales
            if (!String.IsNullOrEmpty(_Proveedor)) //Bug 152566 => Ha de tener valor o se forzaba un filtrado con código de proveedor en blanco => nadie cumplia el filtro
            {
                _Listado._Filtros.Add("ProveedorUnico", _Proveedor);
            }

            // Obtener información principal            
            ldtDatos = _Listado._DataTable();

            if (ldtDatos == null)
                return;

            //Elimino las filas de acumulado
            _SuprimirDatos(ref ldtDatos);
            SuprimirLineasBold(ldtDatos);
            SuprimirCampos(ldtDatos);

            //Inserto columna de selección 
            if (_lSeleccion_Multiple || ModoCapturaParaTraspaso)
            {
                CrearColumnaDeSeleccion(ldtDatos);
            }

            // Ordenar información
            ldtDatos.DefaultView.Sort = "fecha DESC, documento DESC";

            //Filtrar resultados Bug 109818 - s'ha mogut de lloc ja que calculava l'import dels documents abans de filtrar-los
            ldtDatos = _FiltrarDataTableCabeceras(ldtDatos);

            // Asignar datos obtenidos al grid
            ewgridDatos.DataSource = ldtDatos;

            //Bug 152259 => Refactorizo
            CalcularCasillaImporte(ldtDatos);

            // Configuración del grid
            _Configurar_Grid();

            GestionarRecuperacionDeCabecerasSeleccionadas();

            _Refrescar_Detalle();

            _cargandoCabeceras = false;
        }

        protected virtual void _SuprimirDatos(ref DataTable tdtDatos)
        {
        }

        private void CalcularCasillaImporte(DataTable ldtDatos)
        {
            // Calcular total importe
            decimal lnImporteTotal = decimal.Zero;
            if (!ModoCapturaParaTraspaso) //Para operativa corriente calculo
            {
                //Bug 109093 Selección de columna para el acumulado
                string nombreCamporImporte = DeterminarNombreDelCampoImporteCabeceras(ldtDatos);
                lnImporteTotal = ldtDatos.AsEnumerable().Select(r => Convert.ToDecimal(!r.IsNull(nombreCamporImporte) ? r.Field<decimal>(nombreCamporImporte) : 0)).Sum();
            }
            EstablecerValorCasillaImporte(lnImporteTotal);
        }

        private void EstablecerValorCasillaImporte(decimal valor)
        {
            // Calcular total importe
            if (_FiltrarDivisa && _Listado._DivisaConfig._DivisaTodas)
                txtImporte.Text = "";
            else
            {
                txtImporte.Text = valor.ToString(_Listado._DivisaConfig._DivisaMascaraImporte); //Task 105512 que adapte la máscara.
            }
        }

        private string DeterminarNombreDelCampoImporteCabeceras(DataTable datos)
        {
            //Paso el listado de cabeceras y los datos recibidos
            return DeterminarNombreDelCampoImporte_Impl(_Listado, datos);
        }

        private string DeterminarNombreDelCampoImporteDetalle()
        {
            //Paso el listado del detalle y los datos asociados al grid
            DataTable datos = (DataTable)ewgridDetalle.DataSource;
            return DeterminarNombreDelCampoImporte_Impl(_Detalles, datos);
        }

        private string DeterminarNombreDelCampoImporte_Impl(Listados listado, DataTable datos)
        {
            string nombreCamporImporte = listado._DivisaConfig._DivisaEspecifica == true ? "divisa_importe" : "importe";
            if (!datos.Columns.Contains(nombreCamporImporte)) //Especifica de empresa, no trae columnas de divisa
                nombreCamporImporte = "importe";
            return nombreCamporImporte;
        }

        private void ActualizarImporteSeleccionado()
        {
            decimal acumulado = decimal.Zero;
            foreach (var item in dicDetallesSeleccionados)
            {
                acumulado += item.Value.Importe;
            }
            EstablecerValorCasillaImporte(acumulado); 
        }

        private bool _cargandoCabeceras = false;

        private void CrearColumnaDeSeleccion(DataTable ldtDatos)
        {
            using (DataColumn ldtColumnaSel = new DataColumn())
            {
                //datagridviewc

                ldtColumnaSel.DataType = Type.GetType("System.Boolean");
                ldtColumnaSel.AllowDBNull = false;
                ldtColumnaSel.Caption = _cNomColSeleccionar;
                ldtColumnaSel.ColumnName = _cNomColSeleccionar;
                ldtColumnaSel.DefaultValue = false;
                ldtDatos.Columns.Add(ldtColumnaSel);
                ldtDatos.Columns[ldtDatos.Columns.Count - 1].SetOrdinal(0);
            }
        }

        private void SuprimirCampos(DataTable ldtDatos)
        {
            List<string> llisExcluidas = new List<string>() { "EJERCICIO", "multiejercicio", "empresa" };
            foreach (string lcNomCol in llisExcluidas)
            {
                if (ldtDatos.Columns.Contains(lcNomCol)) ldtDatos.Columns.Remove(lcNomCol);
            }
        }

        private void SuprimirLineasBold(DataTable tdtDatos)
        {
            //Limpio los resultados => Elimino filas de totales y columna bold
            if (tdtDatos.Columns.Contains("bold")) //Si tengo columna bold, elimino sus filas
            {
                for (int lnIndex = tdtDatos.Rows.Count - 1; lnIndex >= 0; lnIndex--)
                {
                    if (tdtDatos.Columns.Contains("bold") && tdtDatos.Rows[lnIndex]["bold"] != DBNull.Value && Convert.ToBoolean(tdtDatos.Rows[lnIndex]["bold"])) //Si esta marcada como bold
                    {
                        tdtDatos.Rows[lnIndex].Delete();
                    }
                }
            }

            if (tdtDatos.Columns.Contains("bold")) tdtDatos.Columns.Remove("bold");
        }

        protected virtual DataTable _FiltrarDataTableCabeceras(DataTable toDatos)
        {
            return toDatos;
        }

        void BtImprimir1__Click_Before(ref bool tlOk)
        {
            Listados loLis = this._Refrescar_Datos_Cargar_Opciones_Listado();

            _AplicarConfiguracionDivisa(loLis); //Task 107788

            loLis._Filtros.Add("ProveedorUnico", _Proveedor);
            if (!loLis._Opciones.ContainsKey("lMostrarlineas"))
                loLis._Opciones.Add("lMostrarlineas", true);
            else
                loLis._Opciones["lMostrarlineas"] = true;
            loLis._Opciones.Add("lImpresion", true);
            if (!loLis._Filtros.ContainsKey("ComentariosUnico"))
                loLis._Filtros.Add("ComentariosUnico", chkComentarios.Checked);
            else
                loLis._Filtros["ComentariosUnico"] = chkComentarios.Checked;

            Proveedor loProveedor = new Proveedor(_Proveedor);
            loProveedor._Load();

            btImprimir1._Filtros.Clear();
            btImprimir1._Filtros.Add("TituloDocumentoCompra", Text.ToUpper());
            btImprimir1._Filtros.Add("Ejercicio", DB.Ejercicio_EW);
            btImprimir1._Filtros.Add("Proveedor", String.Format("{0} - {1}", _Proveedor, loProveedor._Nombre));
            btImprimir1._Filtros.Add("Empresa", String.Format("{0} - {1}", _Empresa, Empresa._GetNombreEmpresa(_Empresa)));

            _SetFiltrosReportDivisa();

            //Comprobar tambien la variable cajas para mostrar o no las columnas agrupaciones
            btImprimir1._Filtros.Add("TituloCajas", Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_hera")) && Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_cajas")) ? "Nº agrup." : "Cajas");

            //Total documento
            btImprimir1._Filtros.Add("wc_TotalDocumento", txtImporte.Text);

            //Execució per defecte : Recuperamos los datos
            //btImprimir1._DataTable = loLis._DataTable();
            btImprimir1._DataTable = _Refrescar_Datos_ExecuteListado(loLis);

            //Report generic : Cambiem el nom de l'origen de dades pel report i recuperem el Datatable generic
            listados.Listados.DocumentosProveedor loTmp = new listados.Listados.DocumentosProveedor();
            if (loTmp._ReportFile == loLis._ReportFile)
            {
                btImprimir1._DataTable.TableName = btImprimir1._Title = "Documentos por proveedor";
            }

            DataTable ldtDatos;
            if (loLis is listados.Listados.DocumentosProveedor) //Facturas cumple por herencia y tambien hay que ejecutar
                ldtDatos = ((listados.Listados.DocumentosProveedor)loLis)._ExecuteReport();
            else
                ldtDatos = _Listado._Execute(loLis._Filtros);


            //Asignem el nom del report
            if(!string.IsNullOrWhiteSpace(loLis._ReportFile))
                btImprimir1._Report = loLis._ReportFile;

            btImprimir1._DataTable = _SuprimirColumnas(ldtDatos.DefaultView.ToTable(), _Listado);
        }

        protected virtual DataTable _Refrescar_Datos_ExecuteListado(Listados toLis)
        {
            return toLis._Execute();
        }

        protected virtual Listados _Refrescar_Datos_Cargar_Opciones_Listado(Listados toList = null)
        {
            if (toList == null)
                toList = this.GetListadosInstance(tlCabeceras: true);
            return toList;
        }

        protected internal void _Refrescar_Detalle()
        {
            DataTable ldtDatos = (DataTable)ewgridDatos.DataSource;
            int lnRowAct;
            string lcNumero = "";
            if (ldtDatos.Rows.Count > 0)
            {
                lnRowAct = ewgridDatos.CurrentCell.RowIndex;
                lcNumero = ewgridDatos["Documento", lnRowAct].Value.ToString();
            }

            _Refrescar_Detalle(lcNumero);

            //Seleccionem el registre que correspongui
            if (ewgridDatos.Rows.Count > 0)
            {
                ewgridDatos.ClearSelection();
                if (_lLastSelectedIndex >= 0 && ldtDatos.Rows.Count > _lLastSelectedIndex)
                    ewgridDatos.Rows[_lLastSelectedIndex].Selected = true;
                else
                    ewgridDatos.Rows[0].Selected = true;
            }
        }
        
        private void _Refrescar_Detalle(string tcNumero)
        {
            DataTable ldtDatosDet = new DataTable();

            //Cargamos las opciones especificas del listado de detalles
            _ListadoDetalle = _Refrescar_Detalle_Cargar_Opciones_Listado();

            // Preparar filtros genéricos detalle
            _ListadoDetalle._Filtros.Add("NumeroUnico", tcNumero);
            _ListadoDetalle._Filtros.Add("ComentariosUnico", chkComentarios.Checked);
            if (!string.IsNullOrWhiteSpace(_Proveedor)) //Bug 152566 => Ha de tener valor o se forzaba un filtrado con código de proveedor en blanco => nadie cumplia el filtro
            {
                _ListadoDetalle._Filtros.Add("ProveedorUnico", _Proveedor);
            }

            // Obtener información detalle
            ldtDatosDet = _ListadoDetalle._DataTable();

            //Inserto columna de selección 
            if (ModoCapturaParaTraspaso)
            {
                CrearColumnaDeSeleccion(ldtDatosDet); //Añado columna de selección al grid de detalle
            }

            //Limpio los resultados => Elimino filas de totales y columna bold
            if (ldtDatosDet.Columns.Contains("bold")) //Si tengo columna bold, elimino sus filas
            {
                for (int lnIndex = ldtDatosDet.Rows.Count -1; lnIndex >= 0; lnIndex--)
                {
                    if (ldtDatosDet.Rows[lnIndex]["bold"] != DBNull.Value && //La columna no es null
                        Convert.ToBoolean(ldtDatosDet.Rows[lnIndex]["bold"])) //Si esta marcada como bold
                    {
                        ldtDatosDet.Rows[lnIndex].Delete();
                    }
                }
            }

            List<string> llisExcluidas = new List<string>() { "bold", "titulo", "titulo1", "titulo2", "titulo3", "titulo4", "codtitulo", "codtitulo1", "codtitulo2", "codtitulo3", "codtitulo4", "codtitulo5", "divisa", "empresa", "EJERCICIO", "multiejercicio" };  //Task 107788 Los listados con detalle no deben tener columna divisa
            foreach (string lcNomCol in llisExcluidas)
            {
                if (ldtDatosDet.Columns.Contains(lcNomCol)) ldtDatosDet.Columns.Remove(lcNomCol);
            }

            if (ldtDatosDet == null)
                return;

            // Asignar datos obtenidos al grid
            ewgridDetalle.DataSource = ldtDatosDet;

            // Configuración del grid
            _Configurar_Grid_Detalle();
         
            //Refrescar valor del campo traspasado     
            if (ewgridDetalle.Columns.Contains("servidas") && ewgridDetalle.Columns.Contains("traspasado"))
            {
                foreach (DataGridViewRow row in ewgridDetalle.Rows)
                {                    
                    if (!string.IsNullOrWhiteSpace(Convert.ToString(row.Cells["tipo_iva"].Value)) && (Convert.ToDecimal(row.Cells["unidades"].Value) - Convert.ToDecimal(row.Cells["servidas"].Value) == 0))
                        row.Cells["traspasado"].Value = true;
                }
            }

            GestionarRecuperacionDeDetallesSeleccionados();
        }

        protected virtual Listados _Refrescar_Detalle_Cargar_Opciones_Listado(Listados toList = null)
        {
            if (toList == null)
                toList = GetListadosInstance(tlCabeceras: false);
            return toList;
        }

        private void _Configurar_Grid()
        {
            // Columnas configurables
            if (ewgridDatos.Columns.Contains("obra"))
                ewgridDatos.Columns["obra"].Visible = _lObra;

            if (ModoCapturaParaTraspaso)
                ewgridDatos.Columns[_cNomColSeleccionar].AutoSizeMode = DataGridViewAutoSizeColumnMode.AllCells;

            _ConfigurarGridDivisa(_Listado, ref ewgridDatos);

            // Máscaras de columnas                        
            _ConfigurarColumnaNumerica("importe", _oMascaraImport._Mascara_Net, ref ewgridDatos);

            _Nombre_Columnas(ref ewgridDatos);

            ewgridDatos.ColumnHeadersHeightSizeMode = DataGridViewColumnHeadersHeightSizeMode.DisableResizing;

        }

        protected virtual void _Nombre_Columnas(ref ewgrid toGrid)
        {
            //Traduccions genérica
            foreach (DataGridViewColumn ldc in toGrid.Columns)
            {
                toGrid.Columns[ldc.Name].HeaderText = sage.ew.functions.Translate._This._Get(ldc.Name);
            }

            if (toGrid.Columns.Contains("nombre_proveedor"))
            {
                toGrid.Columns["nombre_proveedor"].AutoSizeMode = DataGridViewAutoSizeColumnMode.Fill;
                toGrid.Columns["nombre_proveedor"].MinimumWidth = 100;
                toGrid.Columns["nombre_proveedor"].HeaderText = "Nombre proveedor";
            }
            if (toGrid.Columns.Contains("f_entreg"))
            {
                toGrid.Columns["f_entreg"].HeaderText = "Entrega";
            }

            //Task 107788 Tratamiento captions divisa (pq utiliza el grid y no el gridviewlist)
            if (toGrid.Columns.Contains("divisa_precio") && _Listado != null)
            {
                toGrid.Columns["divisa_precio"].HeaderText = "Precio (" + _Listado._DivisaConfig.ObtenerSimboloDivisa()+")";
                toGrid.Columns["divisa_precio"].AutoSizeMode = DataGridViewAutoSizeColumnMode.AllCells;
            }

            if (toGrid.Columns.Contains("divisa_importe") && _Listado != null)
            {
                toGrid.Columns["divisa_importe"].HeaderText = "Importe (" + _Listado._DivisaConfig.ObtenerSimboloDivisa()+")";
                toGrid.Columns["divisa_importe"].AutoSizeMode = DataGridViewAutoSizeColumnMode.AllCells;
            }

            if (toGrid.Columns.Contains("divisa_total") && _Listado != null)
            {
                toGrid.Columns["divisa_total"].HeaderText = "Total (" + _Listado._DivisaConfig.ObtenerSimboloDivisa()+")";
                toGrid.Columns["divisa_total"].AutoSizeMode = DataGridViewAutoSizeColumnMode.AllCells;
            }

            // Primera letra en mayúscula en la cabecera de las columnas
            foreach (DataGridViewColumn ldcCololumna in toGrid.Columns)
            {
                ldcCololumna.HeaderText = ldcCololumna.HeaderText.Replace('_', ' '); //Cambio _ por espacios
                ldcCololumna.HeaderText = ldcCololumna.HeaderText.Replace("albaran","albarán"); //Acentuo albarán
                ldcCololumna.HeaderText = ldcCololumna.HeaderText.Replace("definicion", "definición"); //Acentuo definición
                ldcCololumna.HeaderText = ldcCololumna.HeaderText.Replace("articulo", "artículo"); //Acentuo artículo
                ldcCololumna.HeaderText = ldcCololumna.HeaderText.Replace("linia", "línea"); //Cambio y acentuo línea
                ldcCololumna.HeaderText = CultureInfo.CurrentCulture.TextInfo.ToTitleCase(ldcCololumna.HeaderText).Trim();
            }
        }

        void Evento_ewgridDatos_CellClick(object sender, DataGridViewCellEventArgs e)
        {
            if (e.RowIndex >= 0)
            {
                if (e.ColumnIndex == ewgridDatos.Columns[_cNomColSeleccionar].Index)
                {
                    if (IsValidCabecera(e.RowIndex))
                    {
                        bool llNouEstat = !(bool)ewgridDatos[e.ColumnIndex, e.RowIndex].Value;
                        ewgridDatos[e.ColumnIndex, e.RowIndex].Value = llNouEstat;
                        GestionarCabecerasSeleccionadas(((DataRowView)ewgridDatos.Rows[e.RowIndex].DataBoundItem).Row, llNouEstat);
                    }
                    else
                    {
                        //Notificar motivo de la invalidez del registro
                        _MessageBox(MotivoCabeceraInvalida, MessageBoxButtons.OK, MessageBoxIcon.Exclamation, MessageBoxDefaultButton.Button1, DialogResult.None);
                    }
                }
            }
        }

        void Evento_ewgridDatos_ColumnHeaderMouseClick(object sender, DataGridViewCellMouseEventArgs e)
        {
            if (ModoCapturaParaTraspaso)
                return; //No soportamos esta operativa => falla el marcado de detalles no cargados

            if (e.ColumnIndex == ewgridDatos.Columns[_cNomColSeleccionar].Index)
            {
                ewgridDatos.SelectionChanged -= new EventHandler(EwgridDatos_SelectionChanged);

                MarcarDesmarcarTodoElGridDeDatos(_lMarcarDesmarcar);

                //Cambio el valor de _lMarcarDesmarcar
                _lMarcarDesmarcar = !_lMarcarDesmarcar;
            }
        }

        private void EwgridDatos_CellValueChanged(object sender, DataGridViewCellEventArgs e)
        {
            if (sender == null || !ewgridDatos.Columns.Contains(_cNomColSeleccionar) || e.ColumnIndex < 0 || e.RowIndex < 0 || _cargandoCabeceras)
                return;

            if (e.ColumnIndex == ewgridDatos.Columns[_cNomColSeleccionar].Index) //Si es la columna de selección
            {
                bool valor = Convert.ToBoolean(ewgridDatos[e.ColumnIndex, e.RowIndex].Value);
                if (!_marcandoDesdeDetalle) //Sino estoy marcando desde el propio detalle
                {
                    MarcarDesmarcarTodoElGridDeDetalle(valor); //Marco su detalle
                }
            }
        }

        void Evento_ewgridDetalle_CellClick(object sender, DataGridViewCellEventArgs e)
        {
            if (e.RowIndex >= 0)
            {
                if (e.ColumnIndex == ewgridDetalle.Columns[_cNomColSeleccionar].Index)
                {
                    if (IsValidDetalle(e.RowIndex))
                    {
                        bool llNouEstat = !(bool)ewgridDetalle[e.ColumnIndex, e.RowIndex].Value;
                        MarcarFilaDeDetalle(e.ColumnIndex, e.RowIndex, llNouEstat);
                    }
                    else
                    {
                        //Notificar condiciones de invalidez
                        _MessageBox(MotivoDetalleInvalido, MessageBoxButtons.OK, MessageBoxIcon.Exclamation, MessageBoxDefaultButton.Button1, DialogResult.None);
                    }
                }
            }
        }

        void Evento_ewgridDetalle_ColumnHeaderMouseClick(object sender, DataGridViewCellMouseEventArgs e)
        {
            if (e.ColumnIndex == ewgridDetalle.Columns[_cNomColSeleccionar].Index)
            {
                MarcarDesmarcarTodoElGridDeDetalle(_lMarcarDesmarcarDetalle);

                //Cambio el valor de _lMarcarDesmarcarDetalle
                _lMarcarDesmarcarDetalle = !_lMarcarDesmarcarDetalle;
            }
        }

        
        private void MarcarDesmarcarTodoElGridDeDatos(bool valor)
        {
            if (ewgridDatos != null && ewgridDatos.Rows.Count > 0)
            {
                int colSeleccionarIndex = ewgridDatos.Columns[_cNomColSeleccionar].Index;
                for (int rowIndex = 0; rowIndex < ewgridDatos.Rows.Count; rowIndex++)
                {
                    if (valor && !IsValidCabecera(rowIndex)) //Si trato de marcar y no es válido me lo salto
                        continue;
                    ewgridDatos[colSeleccionarIndex, rowIndex].Value = valor;
                }
            }
        }

        private void MarcarDesmarcarTodoElGridDeDetalle(bool valor)
        {
            if (ewgridDetalle != null && ewgridDetalle.Rows.Count > 0)
            {
                int colSeleccionarIndex = ewgridDetalle.Columns[_cNomColSeleccionar].Index;
                for (int rowIndex = 0; rowIndex < ewgridDetalle.Rows.Count; rowIndex++)
                {
                    if (valor && !IsValidDetalle(rowIndex)) //Si trato de marcar y no es válido me lo salto => Sin mensajes para el proceso masivo
                        continue;
                    MarcarFilaDeDetalle(colSeleccionarIndex, rowIndex, valor);
                }
            }
        }


        private void MarcarFilaDeDetalle(int colIndex, int rowIndex, bool valor)
        {
            if (ModoCapturaParaTraspaso && EsUnEscandallo(ewgridDetalle.Rows[rowIndex]))
            {
                string escandal = Convert.ToString(ewgridDetalle[ewgridDetalle.Columns["escandal"].Index, rowIndex].Value).TrimEnd();
                if (!escandal.EndsWith("LIN"))
                {
                    var escandallos = ((DataTable)ewgridDetalle.DataSource).AsEnumerable().Cast<DataRow>().Where(r => r.Field<string>("escandal").StartsWith(escandal)).ToList();
                    if (escandallos.Any())
                    {
                        foreach (DataGridViewRow rowView in ewgridDetalle.Rows)
                        {
                            foreach (DataRow escandallosRow in escandallos)
                            {
                                if (((DataRowView)rowView.DataBoundItem).Row == escandallosRow)
                                {
                                    rowView.Cells[_cNomColSeleccionar].Value = valor;
                                    GestionarDetallesSeleccionados(escandallosRow, valor);
                                    break; //No sigo buscando
                                }
                            }
                        }
                    }
                }
            }
            else
            {
                ewgridDetalle[colIndex, rowIndex].Value = valor;
                GestionarDetallesSeleccionados(((DataRowView)ewgridDetalle.Rows[rowIndex].DataBoundItem).Row, valor);
            }

            //Bug 152230 => Evaluo la cabecera
            EvaluarMarcarFilaCabecera();
            //Bug 152259 => Importe incremental
            ActualizarImporteSeleccionado();
        }

        private void EvaluarMarcarFilaCabecera()
        {
            _marcandoDesdeDetalle = true; //Marco que el cambio de valor lo provoca el detalle

            //Determino si hay alguna línea de detalle marcada
            bool algunoMarcado = false;
            foreach (DataGridViewRow rowView in ewgridDetalle.Rows)
            {
                bool rowSeleccionado = Convert.ToBoolean(rowView.Cells[_cNomColSeleccionar].Value);
                if(rowSeleccionado)
                {
                    algunoMarcado = true;
                    break;
                }
            }

            //Actualizo el valor de cabecera si es necesario
            int colSeleccionarIndex = ewgridDatos.Columns[_cNomColSeleccionar].Index;
            bool valorActualCabecera = Convert.ToBoolean(ewgridDatos[colSeleccionarIndex, ewgridDatos.CurrentRow.Index].Value);
            if (valorActualCabecera != algunoMarcado)
            {
                ewgridDatos[colSeleccionarIndex, ewgridDatos.CurrentRow.Index].Value = algunoMarcado;
                GestionarCabecerasSeleccionadas(((DataRowView)ewgridDatos.CurrentRow.DataBoundItem).Row, algunoMarcado);
            }

            _marcandoDesdeDetalle = false;
        }

        private bool _marcandoDesdeDetalle = false;

        void GestionarDetallesSeleccionados(DataRow row, bool seleccionado)
        {
            if (!ModoCapturaParaTraspaso) return;

            LineaDetalleId detalleId = new LineaDetalleId(row, DeterminarNombreDelCampoImporteDetalle());
            string itemKey = detalleId.GetKeyLinea();
            if (seleccionado)
            {
                if (dicDetallesSeleccionados.ContainsKey(itemKey))
                    dicDetallesSeleccionados[itemKey] = detalleId;
                else
                    dicDetallesSeleccionados.Add(itemKey, detalleId);
            }
            else
            {
                if (dicDetallesSeleccionados.ContainsKey(itemKey))
                    dicDetallesSeleccionados.Remove(itemKey);
            }
        }

        void GestionarCabecerasSeleccionadas(DataRow row, bool seleccionado)
        {
            if (!ModoCapturaParaTraspaso) return;

            LineaCabeceraId cabeceraId = new LineaCabeceraId(row);
            string itemKey = cabeceraId.GetKeyDocumento();
            if (seleccionado)
            {
                if (dicCabecerasSeleccionadas.ContainsKey(itemKey))
                    dicCabecerasSeleccionadas[itemKey] = cabeceraId;
                else
                    dicCabecerasSeleccionadas.Add(itemKey, cabeceraId);
            }
            else
            {
                if (dicCabecerasSeleccionadas.ContainsKey(itemKey))
                    dicCabecerasSeleccionadas.Remove(itemKey);
            }
        }

        void GestionarRecuperacionDeDetallesSeleccionados()
        {
            if (!ModoCapturaParaTraspaso) return;

            //Debe recuperar los valores del campo 'Sel.' si había alguno
            if(dicDetallesSeleccionados.Count > 0 && ewgridDetalle.DataSource != null && ewgridDetalle.Rows.Count > 0)
            {
                var row = ((DataRowView)ewgridDetalle.Rows[0].DataBoundItem).Row; //Todo el detalle pertenece al mismo documento
                LineaDetalleId cabeceraBuscada = new LineaDetalleId(row);
                var seleccionadosDelMismoDocumento = dicDetallesSeleccionados.Values.Where(v => v.GetKeyDocumento() == cabeceraBuscada.GetKeyDocumento()).ToList();
                if(seleccionadosDelMismoDocumento.Any())
                {
                    foreach (DataGridViewRow rowGridView in ewgridDetalle.Rows)
                    {
                        DataRowView rowView = (DataRowView)rowGridView.DataBoundItem;
                        string key = LineaDetalleId.GetKeyLinea(rowView);
                        if(seleccionadosDelMismoDocumento.Where(s => s.GetKeyLinea() == key).Any())
                        {
                            ewgridDetalle[_cNomColSeleccionar, ewgridDetalle.Rows.IndexOf(rowGridView)].Value = true;
                        }
                    }
                }
            }
        }

        void GestionarRecuperacionDeCabecerasSeleccionadas()
        {
            if (!ModoCapturaParaTraspaso) return;

            //Debe recuperar los valores del campo 'Sel.' si había alguno
            if (dicCabecerasSeleccionadas.Count > 0 && ewgridDatos.DataSource != null && ewgridDatos.Rows.Count > 0)
            {
                foreach (DataGridViewRow rowGridView in ewgridDatos.Rows) //Por cada row de cabeceras
                {
                    DataRowView rowView = (DataRowView)rowGridView.DataBoundItem;
                    string key = LineaCabeceraId.GetKeyDocumento(rowView);
                    var seleccionadosDelMismoDocumento = dicCabecerasSeleccionadas.Values.Where(v => v.GetKeyDocumento() == key).ToList();
                    if (seleccionadosDelMismoDocumento.Any())
                    {
                        ewgridDatos[_cNomColSeleccionar, ewgridDatos.Rows.IndexOf(rowGridView)].Value = true;
                    }
                }
            }
        }

        Dictionary<string, LineaCabeceraId> dicCabecerasSeleccionadas = new Dictionary<string, LineaCabeceraId>();
        Dictionary<string, LineaDetalleId> dicDetallesSeleccionados = new Dictionary<string, LineaDetalleId>();

        class LineaCabeceraId : IComparable<LineaCabeceraId>  //, IEquatable<LineaDetalleId>
        {
            readonly string _empresa = Convert.ToString(EW_GLOBAL._GetVariable("wc_empresa"));
            string _documento = string.Empty;
            string _proveedor = string.Empty;

            public LineaCabeceraId(DataRow row)
            {
                _documento = row.Field<string>("documento");
                _proveedor = row.Field<string>("proveedor");
            }

            public int CompareTo(LineaCabeceraId other)
            {
                if (other == null)
                    return 1;

                int comparacionEmpresa = _empresa.CompareTo(other._empresa);
                if (comparacionEmpresa == 0)
                {
                    int comparacionProveedor = _proveedor.CompareTo(other._proveedor);
                    if (comparacionProveedor == 0)
                    {
                        return _documento.CompareTo(other._documento);
                    }
                    else
                        return comparacionProveedor;
                }
                else
                    return comparacionEmpresa;
            }

            public string GetKeyDocumento()
            {
                return $"--||{_empresa}||{_proveedor}||{_documento}||--";
            }

            public static string GetKeyDocumento(DataRowView rowView)
            {
                string empresa = Convert.ToString(EW_GLOBAL._GetVariable("wc_empresa"));
                string proveedor = rowView.Row.Field<string>("proveedor");
                string documento = rowView.Row.Field<string>("documento");
                return $"--||{empresa}||{proveedor}||{documento}||--";
            }

            public string GetEmpresa()
            {
                return _empresa;
            }

            public string GetProveedor()
            {
                return _proveedor;
            }

            public string GetDocumento()
            {
                return _documento;
            }
        }

        class LineaDetalleId : IComparable<LineaDetalleId>  //, IEquatable<LineaDetalleId>
        {
            readonly string _empresa = Convert.ToString(EW_GLOBAL._GetVariable("wc_empresa"));
            string _documento = string.Empty;
            string _proveedor = string.Empty;
            //string _linia = string.Empty;
            int _linia = 0;

            //Bug 152259 => Importe incremental
            public decimal Importe = decimal.Zero;

            public LineaDetalleId(DataRow row, string campoImporte = "")
            {
                _documento = row.Field<string>("documento");
                _proveedor = row.Field<string>("proveedor");
                //_linia = row.Field<string>("linia");
                _linia = row.Field<int>("linia");

                if (!string.IsNullOrWhiteSpace(campoImporte))
                    Importe = row.Field<decimal>(campoImporte);
            }

            public int CompareTo(LineaDetalleId other)
            {
                if (other == null)
                    return 1;

                int comparacionEmpresa = _empresa.CompareTo(other._empresa);
                if (comparacionEmpresa == 0)
                {
                    int comparacionProveedor = _proveedor.CompareTo(other._proveedor);
                    if (comparacionProveedor == 0)
                    {
                        int comparacionDocumento = _documento.CompareTo(other._documento);
                        if (comparacionDocumento == 0)
                        {
                            return _linia.CompareTo(other._linia);
                        }
                        else
                            return comparacionDocumento;
                    }
                    else
                        return comparacionProveedor;
                }
                else
                    return comparacionEmpresa;
            }

            public string GetKeyDocumento()
            {
                return $"--||{_empresa}||{_proveedor}||{_documento}||--";
            }

            public string GetKeyLinea()
            {
                return $"--||{_empresa}||{_proveedor}||{_documento}||{_linia.ToString()}||--";
            }

            public static string GetKeyDocumento(DataRowView rowView)
            {
                string empresa = Convert.ToString(EW_GLOBAL._GetVariable("wc_empresa"));
                string proveedor = rowView.Row.Field<string>("proveedor");
                string documento = rowView.Row.Field<string>("documento");
                return $"--||{empresa}||{proveedor}||{documento}||--";
            }

            public static string GetKeyLinea(DataRowView rowView)
            {
                string empresa = Convert.ToString(EW_GLOBAL._GetVariable("wc_empresa"));
                string proveedor = rowView.Row.Field<string>("proveedor");
                string documento = rowView.Row.Field<string>("documento");
                string linia = rowView.Row.Field<int>("linia").ToString();
                //string linia = rowView.Row.Field<string>("linia");
                return $"--||{empresa}||{proveedor}||{documento}||{linia}||--";
            }

            public string GetEmpresa()
            {
                return _empresa;
            }

            public string GetProveedor()
            {
                return _proveedor;
            }

            public string GetDocumento()
            {
                return _documento;
            }

            public int GetLinia()
            {
                return _linia;
            }
        }

        private bool IsValidCabecera(int indexRow)
        {
            MotivoCabeceraInvalida = string.Empty;

            if (!ModoCapturaParaTraspaso)
                return true;

            bool esValido = true;
            if(ewgridDatos.Columns.Contains("cancelado") && Convert.ToBoolean(ewgridDatos[ewgridDatos.Columns["cancelado"].Index, indexRow].Value) == true)
            {
                MotivoCabeceraInvalida = "No se pueden seleccionar documentos cancelados.";
                esValido = false;
            }
            if (ewgridDatos.Columns.Contains("traspasado") && Convert.ToBoolean(ewgridDatos[ewgridDatos.Columns["traspasado"].Index, indexRow].Value) == true)
            {
                MotivoCabeceraInvalida = "No se pueden seleccionar documentos traspasados.";
                esValido = false;
            }
            return esValido;
        }

        string MotivoCabeceraInvalida = string.Empty;
        string MotivoDetalleInvalido = string.Empty;

        private bool IsValidDetalle(int indexRow)
        {
            MotivoDetalleInvalido = string.Empty; ;

            if (!ModoCapturaParaTraspaso)
                return true;

            bool esValido = true;
            if (ewgridDetalle.Columns.Contains("cancelado") && Convert.ToBoolean(ewgridDetalle[ewgridDetalle.Columns["cancelado"].Index, indexRow].Value) == true)
            {
                MotivoDetalleInvalido = "No se pueden seleccionar líneas canceladas.";
                esValido = false;
            }
            //Bug 152280 => Valido que el documento general (cabeceras) no esté cancelado
            if (ewgridDatos.Columns.Contains("cancelado") && Convert.ToBoolean(ewgridDatos[ewgridDatos.Columns["cancelado"].Index, ewgridDatos.CurrentRow.Index].Value) == true)
            {
                MotivoDetalleInvalido = "No se pueden seleccionar lineas que pertenecen a documentos cancelados.";
                esValido = false;
            }

            if (ewgridDetalle.Columns.Contains("traspasado") && Convert.ToBoolean(ewgridDetalle[ewgridDetalle.Columns["traspasado"].Index, indexRow].Value) == true)
            {
                MotivoDetalleInvalido = "No se pueden seleccionar líneas traspasadas.";
                esValido = false;
            }
            //Bug 152394 => Valido que el documento general (cabeceras) no esté traspasado (marcado como tal)
            if (ewgridDatos.Columns.Contains("traspasado") && Convert.ToBoolean(ewgridDatos[ewgridDatos.Columns["traspasado"].Index, ewgridDatos.CurrentRow.Index].Value) == true)
            {
                MotivoDetalleInvalido = "No se pueden seleccionar lineas que pertenecen a documentos traspasados.";
                esValido = false;
            }


            if (ewgridDetalle.Columns.Contains("servidas") && Convert.ToDecimal(ewgridDetalle[ewgridDetalle.Columns["servidas"].Index, indexRow].Value) != decimal.Zero)
            {
                MotivoDetalleInvalido = "No se pueden seleccionar líneas con unidades servidas.";
                esValido = false;
            }
            if (ewgridDetalle.Columns.Contains("escandal") && !String.IsNullOrWhiteSpace(Convert.ToString(ewgridDetalle[ewgridDetalle.Columns["escandal"].Index, indexRow].Value)))
            {
                //Evaluación de escandallos
                string escandal = Convert.ToString(ewgridDetalle[ewgridDetalle.Columns["escandal"].Index, indexRow].Value).TrimEnd();
                if(escandal.EndsWith("LIN")) //Es línea => Manda el padre... no es válido
                {
                    MotivoDetalleInvalido = "No se pueden seleccionar individualmente líneas de componentes.";
                    esValido = false;
                }
            }

            return esValido;
        }

        private bool EsUnEscandallo(DataGridViewRow row)
        {
            if (ewgridDetalle.Columns.Contains("escandal") && !String.IsNullOrWhiteSpace(Convert.ToString(row.Cells["escandal"].Value)))
            {
                string escandal = Convert.ToString(row.Cells["escandal"].Value);
                if (escandal.ToUpper().EndsWith("TYC")) //No es un escandallo de bloque
                {
                    return false;
                }
                 return true;
            }
            else
                return false;
        }

        private bool EsEscandalloDeDefinicionAmpliada(string tcEscandal)
        {
            //Empiezan o acaban en AMP
            return tcEscandal.ToUpper().EndsWith("AMP") || tcEscandal.ToUpper().StartsWith("AMP");
        }

        private void _Configurar_Grid_Detalle()
        {
            bool llPaso = false;

            if (ewgridDetalle.Columns.Contains("talla")) ewgridDetalle.Columns["talla"].Visible = _lColor;
            if (ewgridDetalle.Columns.Contains("color")) ewgridDetalle.Columns["color"].Visible = _lColor;
            if (ewgridDetalle.Columns.Contains("cajas")) ewgridDetalle.Columns["cajas"].Visible = _lCajas;
            if (ewgridDetalle.Columns.Contains("peso")) ewgridDetalle.Columns["peso"].Visible = _lPeso;

            if (ewgridDetalle.Columns.Contains("nombre_articulo"))
            {
                //Task 107788 Se observa que hay dos columnas definición. Se opta solución hibrida. Si ha columna definición especifica se oculta la de artículo, sino asume su rol
                //Customer Change Request 104943 : la columna con el nombre de arículo debe verse
                if(ewgridDetalle.Columns.Contains("definicion"))
                    ewgridDetalle.Columns["nombre_articulo"].Visible = false;
                else
                    ewgridDetalle.Columns["nombre_articulo"].HeaderText = "Definición";
            }

            //Task 105512 Supresión de código repetido
            // Ocultamos columnas que no interesan
            List<string> lisColumnasInvisibles = new List<string>() { "proveedor", "nombre_proveedor", "tipo_iva", "preciodiv", "importediv", "importeiva", "importepte", "refercli",
                                                                      "familia", "subfamilia", "cajaserv", "pendientes", "escandal", "linia" };
            CambiarVisibilidadColumnas(lisColumnasInvisibles, false, ref ewgridDetalle);

            if (ModoCapturaParaTraspaso)
                ewgridDetalle.Columns[_cNomColSeleccionar].AutoSizeMode = DataGridViewAutoSizeColumnMode.AllCells;

            _ConfigurarGridDivisa(_ListadoDetalle, ref ewgridDetalle); //Task 107003 //Task 105512 Método centralizado

            if (ewgridDetalle.Columns.Contains("definicion"))
            {
                ewgridDetalle.Columns["definicion"].AutoSizeMode = DataGridViewAutoSizeColumnMode.Fill;
                ewgridDetalle.Columns["definicion"].MinimumWidth = 80;
                llPaso = true;
            }

            if (ewgridDetalle.Columns.Contains("nombre_articulo"))
            {
                ewgridDetalle.Columns["nombre_articulo"].AutoSizeMode = DataGridViewAutoSizeColumnMode.Fill;
                ewgridDetalle.Columns["nombre_articulo"].MinimumWidth = 80;
                llPaso = true;
            }

            //Task 105512 Supresión de código repetido
            _ConfigurarColumnaNumerica("peso", _oMascaraPeso._Mascara_Net, ref ewgridDetalle);
            _ConfigurarColumnaNumerica("unidades", _oMascaraUnidades._Mascara_Net, ref ewgridDetalle, _cDesUnidades);
            _ConfigurarColumnaNumerica("servidas", _oMascaraUnidades._Mascara_Net, ref ewgridDetalle);
            _ConfigurarColumnaNumerica("precio", _oMascaraPrecio._Mascara_Net, ref ewgridDetalle);
            _ConfigurarColumnaNumerica("dto1", _oMascaraPorcent._Mascara_Net, ref ewgridDetalle);
            _ConfigurarColumnaNumerica("dto2", _oMascaraPorcent._Mascara_Net, ref ewgridDetalle);
            _ConfigurarColumnaNumerica("importe", _oMascaraImport._Mascara_Net, ref ewgridDetalle);
            _ConfigurarColumnaNumerica("cajas", _oMascaraCajas._Mascara_Net, ref ewgridDetalle, _cDesCajas, false);

            //Se trata de ajustar campos que no requieren mucho espacio
            if (ewgridDetalle.Columns.Contains("documento"))
            {
                ewgridDetalle.Columns["documento"].AutoSizeMode = DataGridViewAutoSizeColumnMode.None;
                ewgridDetalle.Columns["documento"].Width = 80;
            }

            if(!llPaso)
                ewgridDetalle.AutoSizeColumnsMode = DataGridViewAutoSizeColumnsMode.Fill;
            else
                ewgridDetalle.AutoSizeColumnsMode = DataGridViewAutoSizeColumnsMode.DisplayedCells;

            // Arreglo un poco los nombres de las columnas
            _Nombre_Columnas(ref ewgridDetalle);

            ewgridDetalle.AutoSizeColumnsMode = ewgridDetalle.Rows.Count > 0 ? DataGridViewAutoSizeColumnsMode.Fill : DataGridViewAutoSizeColumnsMode.DisplayedCells;

            //Nuevo check de Traspasado en el detalle (unidades - servidas = 0)
            if (!ewgridDetalle.Columns.Contains("traspasado"))
            {
                DataGridViewCheckBoxColumn CBColumn = new DataGridViewCheckBoxColumn
                {
                    Name = "traspasado",
                    HeaderText = "Traspasado",
                    FalseValue = "0",
                    TrueValue = "1"
                };
                if (ewgridDetalle.Columns.Contains("servidas"))
                {
                    ewgridDetalle.Columns.Insert(ewgridDetalle.Columns["servidas"].Index + 1, CBColumn);
                    ewgridDetalle.Columns["traspasado"].AutoSizeMode = DataGridViewAutoSizeColumnMode.DisplayedCells;
                }
            }

            //Quan hi ha 0 no mostra res i treu els espais per darrera
            ewgridDetalle.CellFormatting += new DataGridViewCellFormattingEventHandler(ExtensionesGrids.__Grid_CellFormatting);
        }

        //Task 105512 Supresión de código repetido
        private void CambiarVisibilidadColumnas(IEnumerable<string> tlisColumnas, bool tlVisible, ref ewgrid toGrid)
        {
            foreach (var nombreColumna in tlisColumnas) //Recorro la lista
            {
                if (toGrid.Columns.Contains(nombreColumna)) 
                    toGrid.Columns[nombreColumna].Visible = tlVisible;    
            }
        }

        protected override void OnRefrescarClick()
        {
            base.OnRefrescarClick();

            _Refrescar_Datos();
        }

        private void EwgridDatos_SelectionChanged(object sender, EventArgs e)
        {
            if (ewgridDatos.CurrentCell == null) 
                return;
            int lnRowAct = 0;
            string lcNumero = "";

            if (ewgridDatos.SelectedRows.Count > 0)
                lnRowAct = ewgridDatos.SelectedRows[0].Index;
            else
                lnRowAct = ewgridDatos.CurrentCell.RowIndex;

            lcNumero = ewgridDatos["Documento", lnRowAct].Value.ToString();
            if (_UltimoDocumentoSeleccionado != lcNumero)
            {
                _UltimoDocumentoSeleccionado = lcNumero;
                _Refrescar_Detalle(lcNumero);
            }
        }

        void EwgridDatos_CellMouseDoubleClick(object sender, DataGridViewCellMouseEventArgs e)
        {
            if (ModoCapturaParaTraspaso)
                NavegarDocumento(e.RowIndex);
            else
                BtNavegar_Click(null, null);
        }

        private void LbDetalle_Click(object sender, EventArgs e)
        {
            scDatos.Panel1Collapsed = !scDatos.Panel1Collapsed;
            toolTipEW.SetToolTip(lbDetalle, (scDatos.Panel1Collapsed ? "Minimizar" : "Maximizar") + " detalle");
        }

        private void LbDocumentos_Click(object sender, EventArgs e)
        {
            scDatos.Panel2Collapsed = !scDatos.Panel2Collapsed;
            toolTipEW.SetToolTip(lbDocumentos, (scDatos.Panel2Collapsed ? "Minimizar" : "Maximizar") + " documentos");
        }

        private void ScDatos_Paint(object sender, PaintEventArgs e)
        {
            if (sender is SplitContainer scSplit)
            {
                Pen loPen = new Pen(Color.DimGray, 30);

                int lnTop = 5;
                int lnBottom = scSplit.Height - 10;
                int lnLeft = scSplit.Width / 2;

                e.Graphics.DrawLine(loPen, lnLeft, lnTop, lnLeft, lnBottom);
            }
        }

        protected virtual void BtNavegar_Click(object sender, EventArgs e)
        {
            //Si tengo activa la selección múltiple con una lista de campos (no null) que tiene elementos
            if (_lSeleccion_Multiple && _lis_Seleccion_Multiple_Campos != null && _lis_Seleccion_Multiple_Campos.Count > 0)
            {
                IEnumerable<DataGridViewRow> ldgrRowsSeleccionats =
                         from DataGridViewRow ldgrRow in ewgridDatos.Rows
                         where (bool)ldgrRow.Cells[_cNomColSeleccionar].Value == true
                         select ldgrRow;

                //Recorro los elementos seleccionados
                foreach (DataGridViewRow ldgrRow in ldgrRowsSeleccionats) 
                {
                    //Declaro un array para contener los campos
                    Dictionary<string, object> ldicCampos = new Dictionary<string,object>();
                    //object[] laElemento = new object[_lis_Seleccion_Multiple_Campos.Count];
                    int lnIndex = 0;
                    foreach (string lcNombreCampo in _lis_Seleccion_Multiple_Campos) //Recorro todos los campos
                    {
                        if (ewgridDatos.Columns.Contains(lcNombreCampo)) //Si existe el campo
                        {
                            ldicCampos.Add(lcNombreCampo, ewgridDatos[lcNombreCampo, ldgrRow.Index].Value);
                            //laElemento[lnIndex] = ewgridDatos[lcNombreCampo, ldgrRow.Index].Value;
                        }
                        else
                        {
                            ldicCampos.Add(lcNombreCampo, null);
                            //laElemento[lnIndex] = string.Empty;
                        }
                        lnIndex++;
                    }

                    _lis_Seleccion_Multiple_Resultados.Add(ldicCampos);
                }

                btSalir1.PerformClick();
            }
            else
            {
                if (ewgridDatos.CurrentCell == null)
                {
                    _MessageBox("Debe seleccionar el documento al que desea navegar.", MessageBoxButtons.OK, MessageBoxIcon.Information, MessageBoxDefaultButton.Button1, DialogResult.OK);
                    return;
                }

                // Obtener documento
                int lnRowAct = ewgridDatos.CurrentCell.RowIndex;

                if (ModoCapturaParaTraspaso)
                    NavegarDocumento(lnRowAct);
                else
                {
                    _Numero = ewgridDatos["Documento", lnRowAct].Value.ToString();

                    if (ewgridDatos.Columns.Contains("Factura"))
                        _Factura = ewgridDatos["Factura", lnRowAct].Value.ToString();
                    else if (_Cabeceras is listados.Listados.FacturasProveedor)
                        _Factura = _Numero;

                    if (string.IsNullOrWhiteSpace(_Numero))
                        return;

                    //CCR 157238 => Ver documento sin proveedor filtrado
                    if(String.IsNullOrWhiteSpace(_Proveedor) && ewgridDatos.Columns.Contains("Proveedor"))
                    {
                        //Asigno el proveedor. Esta asignación no elude las validaciones de divisa asociadas. Se ejecutan de igual forma
                        _Proveedor = ewgridDatos["Proveedor", lnRowAct].Value.ToString();
                    }

                    btSalir1.PerformClick();
                }
            }
        }

        

        protected virtual void btCapturar_Click(object sender, EventArgs e)
        {
            //TODO : Que fem en aquest cas?
            //throw new Exception("Se debe implementar la accion de aceptacion del formulario");
            return;
        }

        private void EwgridDetalle_RowPrePaint(object sender, DataGridViewRowPrePaintEventArgs e)
        {            
            string lcDefinicion = ewgridDetalle.Columns.Contains("definicion") ? ewgridDetalle["definicion", e.RowIndex].Value.ToString() : String.Empty;
            string lcTipoIva = ewgridDetalle.Columns.Contains("tipo_iva") ? ewgridDetalle["tipo_iva", e.RowIndex].Value.ToString() : String.Empty;

            if (!string.IsNullOrWhiteSpace(lcDefinicion) && string.IsNullOrWhiteSpace(lcTipoIva)) 
            {
                Font loFont;
                loFont = new Font(ewgridDetalle.DefaultCellStyle.Font, FontStyle.Italic);

                ewgridDetalle.Rows[e.RowIndex].Cells["Definicion"].Style.Font = loFont;
                ewgridDetalle.Rows[e.RowIndex].DefaultCellStyle.ForeColor = Color.Blue;
            }
        }

        protected void _ShowTraspasados(bool tlShow = true)
        {
            panelTrasp.Visible = tlShow;
        }

        protected void _ShowCancelados(bool tlShow = true)
        {
            panelCancel.Visible = tlShow;
        }

        protected void _ShowFacturados(bool tlShow = true)
        {
            panelFacturados.Visible = tlShow;
        }


        #endregion métodos

        private void Generic_CheckedChanged(object sender, EventArgs e)
        {
            if (sender is ewradiobutton && (sender as ewradiobutton).Checked)
            {
                _lLastSelectedIndex = 0;
                _Refrescar_Datos();
            }
        }

        protected override void OnDivisaChanged()
        {
            base.OnDivisaChanged();

            ActualizarEtiquetaSimboloDivisa();
        }

        private void ActualizarEtiquetaSimboloDivisa()
        {
            if (_FiltrarDivisa && !Divisa._EsDivisaEmpresa(_Divisa))
                lblSimboloDivisa.Text = _ObtenerSimboloDivisa();
            else
                lblSimboloDivisa.Text = "";
        }

        private void InicializarModoCapturaParaTraspaso()
        {
            if (DesignMode) //En modo diseño no oculto nada
                return;

            if(ModoCapturaParaTraspaso)
            {
                PanelCapturaParaTraspaso.Visible = true;
                PanelCapturaParaTraspasoInfo.Visible = true;
                PanelCapturaParaTraspasoInfo.Location = new Point(PanelCapturaParaTraspasoInfo.Location.X, (scDatos.Location.Y + scDatos.Height + 3)); //Afino un poco el posicionamiento
                _lSeleccion_Multiple = false; //Son bastante incompatibles
                btSalir1.Text = @"&Cancelar";
                btSalir1.Size = new Size(120, btSalir1.Height); //Me cambian el tamaño... lo corrijo

                //Traspaso => botón verde => Le cargo el estilo de un btDocAceptar
                if (!DesignMode)
                {
                    btCapturarParaTraspaso._PropiedadesDeEstilos = new ewbuttonEstilosBase(btCapturarParaTraspaso);
                    btCapturarParaTraspaso._PropiedadesDeEstilos._CargarEstilo("sage.ew.botones.btDocAceptar");
                }

                //Prefijamos Pendientes no canceldos
                rbTrasp1.Checked = true;
                if (!LosDocumentosOrigenSonDepositos())
                    rbCancel1.Checked = true; //No cancelados

                //Botones normales que no han de aparecer
                btListar.Visible = false;
                btImprimir1.Visible = false;
                
            }
            else
            {
                PanelCapturaParaTraspaso.Visible = false;
                PanelCapturaParaTraspasoInfo.Visible = false;
                btSalir1.Text = @"&Salir";
                btSalir1.Size = new Size(120, btSalir1.Height); //Me cambian el tamaño... lo corrijo
            }
        }

        private void BtCapturarParaTraspaso_Click(object sender, EventArgs e)
        {
            if(_DocumentoOrigen._EnUso)
            {
                NotificarAlUsuario("No se permite traspasar líneas a un documento en uso.");
                return;
            }

            if (dicDetallesSeleccionados.Count > 0)
            {
                var linkForm = _DocumentoOrigen._oForm;
                _DocumentoOrigen._oForm = null;

                bool ejecutado = EjecutarCapturaParaTraspaso(); //Bug 152437 => Encapsulo la ejecución para poder restablecer el vículo con _oForm sea cual sea el resultado

                _DocumentoOrigen._oForm = linkForm;

                _Numero = _DocumentoOrigen._Numero;
                _Proveedor = _DocumentoOrigen._Cabecera._Proveedor;

                if (ejecutado)
                {
                    Close();
                }
            }
            else
            {
                //Notificar falta de selección
                NotificarAlUsuario("No se han seleccionado líneas para la operación de traspaso");
            }
        }

        private bool EjecutarCapturaParaTraspaso()
        {
            Queue<LineaDetalleId> documentosDistintos = ObtenerIdsDeDocumentosOrigen(); //Obtengo los documentos de los que voy a traspasar líneas

            _UsarDivisa = TrabajarTraspasoConDivisa(); //Determino si trabajamos con divisa

            if (!TengoDocumentoDestino() || !TengoDestinatario()) //Destinatario => el cliente o proveedor del documento destino
            {
                //Recupero los datos necesarios del primer documento
                LineaDetalleId primerDocumento = documentosDistintos.Peek();
                if (!EstablecerDatosDestinoDesdePrimerElemento(primerDocumento))
                {
                    string mensajeError = "No se ha podido crear el documento destino.";
                    if (!string.IsNullOrWhiteSpace(_DocumentoOrigen._Mensaje_Error))
                        mensajeError = _DocumentoOrigen._Mensaje_Error;
                    NotificarAlUsuario(mensajeError);
                    return false;
                }
            }
            else
            {
                //Valido que sea válido => Facturados no lo son
                if (!string.IsNullOrWhiteSpace(_DocumentoOrigen._Cabecera._Factura))
                {
                    NotificarAlUsuario("No se permite traspasar líneas a un documento ya facturado");
                    return false;
                }
            }

            //Valido el Solo_Lectura => En este punto si es necesario ya ha intanciado un documento y es mensaje es mas fiable (incluye control de meses cerrados)
            if (_DocumentoOrigen._Solo_Lectura)
            {
                string mensajeError = "No se permite traspasar líneas a un documento de sólo lectura.";
                if (!string.IsNullOrWhiteSpace(_DocumentoOrigen._Mensaje_Error))
                    mensajeError = _DocumentoOrigen._Mensaje_Error;
                NotificarAlUsuario(mensajeError);
                return false;
            }

            List<dynamic> documentosOrigen = new List<dynamic>();
            while (documentosDistintos.Count > 0)
            {
                LineaDetalleId idDocumentoOrigen = documentosDistintos.Dequeue();
                documentosOrigen.Add(PrepararDocumentoOrigenTraspasoLineas(idDocumentoOrigen));
            }

            //Bug 153724 => Control de divisas cruzadas
            if (documentosOrigen.Any())
            {
                string divisaDocumentos = documentosOrigen.First()._Cabecera._Divisa;
                string divisaDestino = _DocumentoOrigen._Cabecera._Divisa;
                if (!divisaDestino.Equals(divisaDocumentos))
                {
                    NotificarAlUsuario("El documento destino tiene una divisa distinta. " + Environment.NewLine + "Este tipo de traspasos no están permitidos.");
                    return false;
                }
            }

            if (LosDocumentosOrigenContienenDocumentosEnUso(documentosOrigen, out string documentosEnUso))
            {
                string mensaje = "No se permite traspasar desde documentos en uso. " + Environment.NewLine + "Documentos en uso:" + Environment.NewLine + documentosEnUso;
                NotificarAlUsuario(mensaje);
                return false;
            }

            //Control de obras
            GestionDeObras(documentosOrigen);

            //Bug 152376 => Control de observaciones
            GestionDeObservaciones(documentosOrigen);

            //Bug 152253 => Refinamiento de mensaje de error para distintos proveedores
            if (!documentosOrigen.All(d => ValidarMismoProveedor(d, _DocumentoOrigen)))
            {
                NotificarAlUsuario("No se permite traspasar líneas de distintos proveedores a un mismo documento");
                return false;
            }


            if (documentosOrigen.All(d => ValidarCompatibilidadOrigenDestino(d, _DocumentoOrigen)))
            {
                documentosOrigen.ForEach(d => EjecutarTraspsasoDocumento(d));

                //Bug 152376 => Control de observaciones
                AsignarObservaciones();

                _DocumentoOrigen._SaveData();
            }

            return true;
        }

        private bool LosDocumentosOrigenContienenDocumentosEnUso(List<dynamic> documentosOrigen, out string documentosEnUso)
        {
            documentosEnUso = string.Empty;

            var enUso = documentosOrigen.Where(d => EnUso.EstaEnUsoElDocumento(d) == true).ToList();
            if (enUso.Any())
            {
                string detalleDocumentosEnUso = string.Empty;
                enUso.ForEach(d => detalleDocumentosEnUso += $"Proveedor {d._Cabecera._Proveedor} - '{d._Numero}' {Environment.NewLine}");
                documentosEnUso = detalleDocumentosEnUso;
                return true;
            }

            return false;
        }

        private void NotificarAlUsuario(string mensaje)
        {
            _MessageBox(mensaje, MessageBoxButtons.OK, MessageBoxIcon.Exclamation, MessageBoxDefaultButton.Button1, DialogResult.None);
        }

        void EjecutarTraspsasoDocumento(dynamic documentoOrigen)
        {
            Dictionary<string, object> loDicParamTraspaso = new Dictionary<string, object>();

            //  Nº de documento destino generado (formato proveedor+numero)
            string lcNumDocDestino = string.Empty;

            // Parámetros fijos, siempre se pasarán
            loDicParamTraspaso.Add("fecha", DateTime.Today);
            loDicParamTraspaso.Add("proveedor", _DocumentoOrigen._Cabecera._Proveedor);

            //Obtengo la configuración de traspaso
            ConfiguradorTraspasoAlbaran configuradorTraspaso = documentoOrigen._Obtener_Config_Traspaso_DocDestino(ConfiguradorTraspasoAlbaran._DestinosTraspaso.albaran);

            if (configuradorTraspaso._Control_Operario)
            {
                string operario = _DocumentoOrigen._Cabecera._Operario;
                if (string.IsNullOrWhiteSpace(operario)) //Sino hay destino, tomo el del documento
                {
                    operario = documentoOrigen._Cabecera._Operario;
                    _DocumentoOrigen._Cabecera._Operario = operario; //Me guardo el valor 
                }

                loDicParamTraspaso.Add("operario", documentoOrigen._Cabecera._Operario);
            }

            if (configuradorTraspaso._Control_Obra && //Gestiona obras
                _traspasarObra && //Se ha de traspasar (logica propia)
                DocumentoConObra(documentoOrigen) && //El documento que estoy procesando tiene obra
                !_obraTraspasada) //No la he asignado previamente
            {
                loDicParamTraspaso.Add("obra", _DocumentoOrigen._Cabecera._Obra = documentoOrigen._Cabecera._Obra);
                _obraTraspasada = true;
            }

            if (configuradorTraspaso._Control_FormaPago)
            {
                //Bug 152404 => Manda la del documento destino (si la hay)
                string formaDePago = _DocumentoOrigen._Cabecera._FormaPago;

                if (string.IsNullOrWhiteSpace(formaDePago)) //Sino hay
                {
                    formaDePago = documentoOrigen._Cabecera._FormaPago;
                    _DocumentoOrigen._Cabecera._FormaPago = formaDePago; //Me guardo el valor 
                }

                loDicParamTraspaso.Add("formapago", formaDePago);
            }

            if (configuradorTraspaso._Control_Almacen)
                loDicParamTraspaso.Add("almacen", _DocumentoOrigen._Cabecera._Almacen); //Prevalece destino

            loDicParamTraspaso.Add("numero", _DocumentoOrigen._Numero);

            if (_UsarDivisa)
            {
                loDicParamTraspaso.Add("divisa", DivisaDocumento());
                loDicParamTraspaso.Add("cambio", _DocumentoOrigen._Cabecera._Cambio); //Nada de mezclar cambios
                loDicParamTraspaso.Add("actualizarcambio", false); //Puede haber N documentos con N cambios
            }

            loDicParamTraspaso.Add("docudestino", _DocumentoOrigen);

            TratamientoExtensiones(documentoOrigen);

            lcNumDocDestino = documentoOrigen._To_Albaran(loDicParamTraspaso);
        }

        private void TratamientoExtensiones(dynamic documentoOrigen)
        {
            foreach (dynamic linea in documentoOrigen._Lineas)
            {
                if (linea._TraspasarLinea)
                {
                    decimal lnMaxUdsTraspaso = linea._Unidades;
                    linea._Traspaso = lnMaxUdsTraspaso;

                    ExtensionesTraspasoAutomatico(linea, ((ewDocCompraALBARAN)_DocumentoOrigen)._Cabecera._Almacen, ((ewDocCompraALBARAN)_DocumentoOrigen)._Fecha, ref lnMaxUdsTraspaso);

                    if (lnMaxUdsTraspaso != linea._Unidades)
                    {
                        ExtensionesCancelar(linea);
                        linea._Traspaso = 0M;
                        linea._TraspasarLinea = false;

                        _MessageBox("Sólo se permite traspasar las líneas informadas en su totalidad.", MessageBoxButtons.OK, MessageBoxIcon.Exclamation, MessageBoxDefaultButton.Button1, DialogResult.None);
                    }

                }
            }
        }

        private void ExtensionesCancelar(IDocCompraLin toLinea)
        {
            if (toLinea._oArticulo._Con_Lotes(toLinea._Fecha) || toLinea._oArticulo._UsaSeries) //Linea con extensión
            {
                if (toLinea is ewDocCompraLinDEPOSITO || toLinea is ewDocCompraLinPEDIDO || toLinea is ewDocCompraLinPROPUESTA)
                {
                    (new TraspasoComprasExtendido(toLinea))._CancelarTraspaso(toLinea);
                }
            }
        }

        private void ExtensionesTraspasoAutomatico(IDocCompraLin toLinea, string tcAlmacen, DateTime tdFecha, ref decimal toValor)
        {
            if (string.IsNullOrWhiteSpace(toLinea._TipoIva)) return;

            toValor = toLinea.__TraspasoAutomatico_Extendido_Compras(new ParametrosTraspasosExtendidos(toValor, tcAlmacen, tdFecha, eTipoDocumento.AlbaranCompra));
        }

        private bool ValidarMismoProveedor(dynamic documentoOrigen, dynamic documentoDestino)
        {
            return documentoOrigen._Cabecera._Proveedor.TrimEnd() == _DocumentoOrigen._Cabecera._Proveedor.TrimEnd();
        }

        private bool ValidarCompatibilidadOrigenDestino(dynamic documentoOrigen, dynamic documentoDestino)
        {
            Dictionary<string, object> loDicResultado = new Dictionary<string, object>();
            bool ejecucionCorrecta = false;
            string mensajeDeError = "";

            // Se llama al método que tendrá la clase de negocio de documento origen en el que estemos (pedido compra, deposito compra, propuetas compra) para que
            // haga las comprobaciones que correspondan para verificar que tanto el documento origen como el destino son compatibles, es decir, identico proveedor, pronto pago, etc.
            loDicResultado = documentoOrigen._Traspaso_DocDestino_Existente_Compatible(documentoDestino);

            ejecucionCorrecta = Convert.ToBoolean(loDicResultado["ok"]);

            if (!ejecucionCorrecta)
            {
                mensajeDeError = Convert.ToString(loDicResultado["mensajeerror"]);
                NotificarAlUsuario(mensajeDeError);
            }
            return ejecucionCorrecta;
        }

        private bool EstablecerDatosDestinoDesdePrimerElemento(LineaDetalleId primerDocumento)
        {
            bool documentoDestinoDeNuevaCreacion = false; //Bug 152577 => Marca de si el documento destino me llega instaciado o no

            if (_DocumentoOrigen == null)
                _DocumentoOrigen = new ewDocCompraALBARAN();

            dynamic documentoOrigenTraspaso = CargarDocumento(primerDocumento);

            if (string.IsNullOrWhiteSpace(_DocumentoOrigen._Numero))
            {
                CrearDocumento(documentoOrigenTraspaso);
                documentoDestinoDeNuevaCreacion = true; //Marco que no disponia de documento orígen
            }


            //Obtengo la configuración de traspaso
            ConfiguradorTraspasoAlbaran configuradorTraspaso = documentoOrigenTraspaso._Obtener_Config_Traspaso_DocDestino(ConfiguradorTraspasoAlbaran._DestinosTraspaso.albaran);

            _DocumentoOrigen._Cabecera._Proveedor = documentoOrigenTraspaso._Cabecera._Proveedor;

            if (configuradorTraspaso._Control_Operario)
            {
                string operarioDestino = documentoDestinoDeNuevaCreacion ? "" : _DocumentoOrigen._Cabecera._Operario; //Bug 152518 => Si tengo documento origen (real) lo asigno sino lo ignoro
                if (string.IsNullOrWhiteSpace(operarioDestino))
                {
                    string operario = documentoOrigenTraspaso._Cabecera._Operario;
                    if (string.IsNullOrWhiteSpace(operario))
                        operario = Convert.ToString(EW_GLOBAL._GetVariable("wc_OperarioTPV")); //Si por lo que sea el documento origen no tiene tomo el por defecto de la empresa
                    _DocumentoOrigen._Cabecera._Operario = operario;
                }
            }

            if (configuradorTraspaso._Control_Obra)
                _DocumentoOrigen._Cabecera._Obra = documentoOrigenTraspaso._Cabecera._Obra;

            if (configuradorTraspaso._Control_FormaPago)
            {
                string formaDePago = documentoOrigenTraspaso._Cabecera._FormaPago;
                if(string.IsNullOrWhiteSpace(formaDePago)) //Bug 152577
                {
                    //No tengo forma de pago del documento origen, trato de obtenerla del proveedor
                    formaDePago = ((ewDocCompraALBARAN)_DocumentoOrigen)._Cabecera._oProv._FormaPago;
                }
                _DocumentoOrigen._Cabecera._FormaPago = formaDePago;
            }

            if (configuradorTraspaso._Control_Almacen)
            {
                string almacenDestino = documentoDestinoDeNuevaCreacion ? "" : _DocumentoOrigen._Cabecera._Almacen; //Bug 152577 => Si tengo documento origen (real) lo asigno sino lo ignoro
                if (string.IsNullOrWhiteSpace(almacenDestino))
                {
                    string almacen = documentoOrigenTraspaso._Cabecera._Almacen;
                    if (string.IsNullOrWhiteSpace(almacen))
                        almacen = Convert.ToString(EW_GLOBAL._GetVariable("wc_almacen")); //Si por lo que sea el documento origen no tiene (pe. propuestas) tomo el por defecto de la empresa
                    _DocumentoOrigen._Cabecera._Almacen = almacen;
                }
            }

            return true;
        }

        private void CrearDocumento(dynamic documentoOrigenTraspaso)
        {
            string empresa = Convert.ToString(EW_GLOBAL._GetVariable("wc_empresa"));
            string proveedor = documentoOrigenTraspaso._Cabecera._Proveedor;
            ((ewDocCompraALBARAN)_DocumentoOrigen)._New(empresa, tcProveedor: proveedor); //Aplantillo para no entrar por dynamic que deja el stackTrace mal (se usa para determinar el usuario)
        }

        private Queue<LineaDetalleId> ObtenerIdsDeDocumentosOrigen()
        {
            //Obtengo los documentos de los que voy a traspasar líneas
            Queue<LineaDetalleId> documentosDistintos = new Queue<LineaDetalleId>();
            LineaDetalleId oldLinea = null;
            foreach (var currentLinea in dicDetallesSeleccionados.Values)
            {
                if (oldLinea == null || currentLinea.GetKeyDocumento() != oldLinea.GetKeyDocumento())
                {
                    documentosDistintos.Enqueue(currentLinea);
                    oldLinea = currentLinea;
                }
            }
            return documentosDistintos;
        }

        private dynamic PrepararDocumentoOrigenTraspasoLineas(LineaDetalleId idDeDocumento)
        {
            //Recupero las líneas seleccionadas del documento.
            var lineas = dicDetallesSeleccionados.Values.Where(l => l.GetDocumento() == idDeDocumento.GetDocumento()).ToList();

            dynamic documentoOrigen = CargarDocumento(idDeDocumento);
            //Obtengo la configuración de traspaso necesaria para el documento destino
            ConfiguradorTraspasoAlbaran configuradorTraspaso = documentoOrigen._Obtener_Config_Traspaso_DocDestino(ConfiguradorTraspasoAlbaran._DestinosTraspaso.albaran);

            if (lineas.Any()) //Configura las líneas
            {
                lineas.ForEach(l => 
                    {
                        int numeroDeLinea = l.GetLinia(); //Obtengo el número de linea
                        var linea = ObtenerLinea(documentoOrigen, numeroDeLinea);
                        linea._Traspasar_Unidades = linea._Unidades;
                        linea._Traspasar_Cajas = linea._Cajas;
                        linea._Traspasar_Peso = linea._Peso;
                        linea._Traspasar_Extensiones = null; //Asigno Null y luego proceso extensiones
                        if (LosDocumentosOrigenSonDepositos()) //Sólo en depósitos gestiono series y lotes origen
                        {
                            ((IDocCompraLin)linea).__TraspasoAutomatico_Extendido_Compras(new ParametrosTraspasosExtendidos(linea._Unidades,
                                                                                                                            linea._Almacen,
                                                                                                                            DateTime.Today,
                                                                                                                            eTipoDocumento.AlbaranCompra,
                                                                                                                            tlFormularioPadreVisible: false));
                        }
                        linea._TraspasarLinea = true;
                    });
            }
            else
            {
                //Ha de encontrar lineas si o sí
                throw new NotImplementedException();
            }

            return documentoOrigen; //Devolvemos el documento origen configurado
        }

        dynamic ObtenerLinea(dynamic documento, int numero)
        {
            foreach (var linea in documento._Lineas)
            {
                if (linea._Linea == numero)
                    return linea;
            }
            return null;
        }

        private string DivisaDocumento()
        {
            if (_DocumentoOrigen != null)
                return _DocumentoOrigen._Cabecera._Divisa;
            else
                return ((Divisa)EW_GLOBAL._Moneda)._Codigo; //La de la empresa
        }

        private bool TrabajarTraspasoConDivisa()
        {
            string nombreOpcFlag = _DocumentoOrigen._TipoDocumentoGeneral != eTipoDocumentoGeneral.Compras ? "wl_divisaventa" : "wl_divisacompra";
            if (Convert.ToBoolean(EW_GLOBAL._GetVariable(nombreOpcFlag, false)) == true)
            {
                return DivisaDocumento() != ((Divisa)EW_GLOBAL._Moneda)._Codigo;
            }
            return false;
        }

        private bool _UsarDivisa = false;

        private dynamic CargarDocumento(LineaDetalleId linea)
        {
            //Obtien una instancia del documento por tipo
            dynamic documento = GetNewInstanciaDocumento();

            documento._Load(linea.GetEmpresa(), linea.GetDocumento(), linea.GetProveedor());
            return documento;
        }

        private dynamic CargarDocumento(LineaCabeceraId linea)
        {
            //Obtien una instancia del documento por tipo
            dynamic documento = GetNewInstanciaDocumento();

            documento._Load(linea.GetEmpresa(), linea.GetDocumento(), linea.GetProveedor());
            return documento;
        }

        private dynamic GetNewInstanciaDocumento()
        {
            dynamic documento;

            switch (TipoDeDocumentoCapturable)
            {
                case eTipoDocumento.PedidoCompra:
                    documento = new ewDocCompraPEDIDO();
                    break;
                case eTipoDocumento.PropuestaCompra:
                    documento = new ewDocCompraPROPUESTA();
                    break;
                case eTipoDocumento.DepositoCompra:
                    documento = new ewDocCompraDEPOSITO();
                    break;
                default:
                    throw new NotSupportedException("Tipo de líneas a capturar no soportadas");
                    //break;
            }
            return documento;
        }

        private void NavegarDocumento(int index)
        {
            if (index < 0)
                return;

            LineaCabeceraId cabecera = new LineaCabeceraId(((DataRowView)ewgridDatos.Rows[index].DataBoundItem).Row);
            CargarDocumento(cabecera)._Show();
        }

        private bool TengoDocumentoDestino()
        {
            return (_DocumentoOrigen != null && !string.IsNullOrWhiteSpace(_DocumentoOrigen._Numero));
        }

        private bool TengoDestinatario()
        {
            return (_DocumentoOrigen != null && !string.IsNullOrWhiteSpace(_DocumentoOrigen._Cabecera._Proveedor));
        }

        private bool LosDocumentosOrigenSonDepositos()
        {
            return (TipoDeDocumentoCapturable == eTipoDocumento.DepositoCompra) || (TipoDeDocumentoCapturable == eTipoDocumento.DepositoVenta);
        }

        #region Gestión de obras

        private bool _traspasarObra = false;
        private bool _obraTraspasada = false;

        private void GestionDeObras(List<dynamic> documentosOrigen)
        {
            //Manda destino
            bool obraEnDestino = DocumentoConObra(_DocumentoOrigen); //Debe conservar destino
            if (obraEnDestino)
            {
                _traspasarObra = false;
                return;
            }

            //Evaluo origen
            int conObras = documentosOrigen.Where(d => DocumentoConObra(d)).ToList().Count;

            //Ningún origen con obra => acabo
            if (conObras == 0)
            {
                _traspasarObra = false;
                return;
            }

            //Hay obras oríen pero no destino => que tome la primera
            _traspasarObra = true;
        }

        private bool DocumentoConObra(dynamic documento)
        {
            return !string.IsNullOrWhiteSpace(documento._Cabecera._Obra);
        }

        #endregion Gestión de obras

        #region Gestión de observaciones

        private bool _traspasarObservaciones = false;
        private string _observacionesConcatenadas = string.Empty;

        private void GestionDeObservaciones(List<dynamic> documentosOrigen)
        {
            //Inicializo para no gestionar
            _traspasarObservaciones = false;
            _observacionesConcatenadas = string.Empty;

            //Manda destino
            bool observacionesEnDestino = DocumentoConObservaciones(_DocumentoOrigen); //Debe conservar destino
            if (observacionesEnDestino)
            {
                _traspasarObservaciones = false;
                return;
            }

            //Evaluo origen
            var conObservaciones = documentosOrigen.Where(d => DocumentoConObservaciones(d)).ToList();

            //Ningún origen con observaciones => acabo
            if (conObservaciones.Any())
            {
                //Hay observaciones oríen pero no destino 
                _traspasarObservaciones = true;

                //Si solo hay una => Asigno tal como viene, sin tratamiento rtf
                if (conObservaciones.Count == 1)
                {
                    _observacionesConcatenadas = GetObservacionesDocumento(conObservaciones.First());
                }
                else
                {
                    conObservaciones.ForEach(d => _observacionesConcatenadas += GetObservacionesDocumentoConTratamientoRTF(d));
                }
            }
            else
            {
                _traspasarObservaciones = false;
            }
        }

        private void AsignarObservaciones()
        {
            if (_traspasarObservaciones) //Si se ha determinado que hay que traspasar las observaciones
            {
                _DocumentoOrigen._Cabecera._Observacio = _observacionesConcatenadas;
            }
        }

        private string GetObservacionesDocumento(dynamic documento)
        {
            return documento._Cabecera._Observacio + Environment.NewLine;
        }

        private string GetObservacionesDocumentoConTratamientoRTF(dynamic documento)
        {
            string observacion = documento._Cabecera._Observacio;

            if (observacion.Contains(@"\rtf"))
            {
                RichTextBox controlRtf = new RichTextBox
                {
                    Rtf = observacion //Recupero el RTF
                };
                observacion = controlRtf.Text; //Lo volco a texto plano
            }

            return (observacion + Environment.NewLine);
        }

        private bool DocumentoConObservaciones(dynamic documento)
        {
            return !string.IsNullOrWhiteSpace(documento._Cabecera._Observacio);
        }

        #endregion Gestión de observaciones
    }
}