frmStockSeriesBase.cs

using System;
using System.Collections.Generic;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Windows.Forms;
using sage.ew.formul.Forms;
using sage.ew.global;
using sage.ew.docventatpv;
using sage.ew.stocks;
using sage.ew.objetos.UserControls;
using sage.ew.interficies;
using sage.ew.botones;
using System.Diagnostics;
using sage.ew.objetos;
using sage.ew.db;
using System.Threading;
using System.Collections.Concurrent;


namespace sage.ew.serie.Forms
{
//    /// <summary>
//    /// Formulario para el inventario de series
//    /// </summary>
//    public partial class frmStockSeriesBase : FormSatelite
//    {
//        #region Variables

//        /// <summary>
//        /// Browser de series
//        /// </summary>
//        protected btBrowser _btBrowSeries = new btBrowser();
//        /// <summary>
//        /// Mantenimiento de series (Información de la serie)
//        /// </summary>
//        protected btMante _btManteFicticio = new btMante();

//        /// <summary>
//        /// Broker de operaciones
//        /// </summary>
//        private OperationBroker _OpereationBroker
//        {
//            get 
//            {
//                if (_lOpereationBroker == null)
//                    _lOpereationBroker = new OperationBroker();
//                return _lOpereationBroker;
//            }
//            set { _lOpereationBroker = value; }
//        }
//        private OperationBroker _lOpereationBroker = null;

//        //Rendimiento
//        /// <summary>
//        /// Objeto LinVenDetSeries en edición
//        /// </summary>
//        private LinVenDetSeries _oLinVenDetSerieEnEdicion;

//        //Rendimiento
//        /// <summary>
//        /// Variable para almacenar el índice de fila que estamos editando.
//        /// Un valor de -1 indica que no se está editando ninguna fila
//        /// </summary>
//        private int _nFilaEnEdicion = -1;

//        //Rendimiento
//        /// <summary>
//        /// Indicamos el Commit Scope. False para nivel de celda
//        /// </summary>
//        private bool _lrowScopeCommit = true;

//        /// <summary>
//        /// Guardará el estado de las series al realizar un _Load para omitir la operación si ya existe
//        /// </summary>
//        private ConcurrentDictionary<string, bool> _dicEstadoOriginal = new ConcurrentDictionary<string, bool>();

//        #endregion Variables

//        #region Propiedades

//        /// <summary>
//        /// Declaro objeto de tipo LinVenDet de series para vincular con la clase.
//        /// </summary>
//        public LinVenDet<LinVenDetSeries> _LinVenDetSeries
//        {
//            get { return _oLinVenDetSeries; }
//            set { _oLinVenDetSeries = value; }
//        }
//        private LinVenDet<LinVenDetSeries> _oLinVenDetSeries;

//        /// <summary>
//        /// Código de artículo
//        /// </summary>
//        public string _Articulo { get; set; } = "";

//        /// <summary>
//        /// Código de almacén
//        /// </summary>
//        public string _Almacen { get; set; } = "";

//        /// <summary>
//        /// Devuelve un valor de garantía por defecto para el artículo. (Lazy)
//        /// </summary>
//        private DateTime _GarantiaDefecto 
//        {
//            get 
//            {
//                if (_dGarantiaDefecto == null)
//                {
//                    using (articulo.Articulo loArt = new articulo.Articulo(_LinVenDetSeries._Lineas._Articulo))
//                    {
//                        _dGarantiaDefecto = ((DateTime)Convert.ToDateTime(_LinVenDetSeries._Lineas._Fecha)).AddDays(loArt._Garantia);
//                    }
//                }
//                return (DateTime)_dGarantiaDefecto; 
//            }
//        }
//        private DateTime? _dGarantiaDefecto = null;

//        #endregion Propiedades

//        #region Constructores

//        /// <summary>
//        /// Contructor por defecto (privado)
//        /// </summary>
//        private frmStockSeriesBase() 
//        {
//            InitializeComponent();
//        }

//        /// <summary>
//        /// Contructor por defecto
//        /// </summary>
//        protected frmStockSeriesBase(string pantalla) : this ()
//        {
//            InitializeComponent();

//            _Pantalla = pantalla;
//        }

//        #endregion Constructores

//        #region Métodos Override

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

//            //Obtener datos
//            ObtenerDatos();

//            //Hay que hacerlo en el último momento
//            ReadOnlyControlesInformativos();

//            //Corrección size
//            _oPanelFoto.Size = _oPictureboxArticulo.Size = new Size(200, 186);

//            //Activo los eventos de la casilla para la lectura de series
//            txtBuscar.Leave += new EventHandler(Evento_txtBuscar_Leave);
//            txtBuscar.MaxLength = EW_GLOBAL._GetLenCampo("wn_serie"); //Máximo de carácteres
//        }

//        /// <summary>
//        /// Método para escribir una traza
//        /// </summary>
//        /// <param name="mensaje"></param>
//        protected void Traza(string mensaje)
//        {
//            Trace.WriteLineIf(Debugger.IsAttached, mensaje, Name);
//        }

//        private void ObtenerDatos()
//        {
//            if (DesignMode) 
//                return;

//            DateTime dFechaDocumento = Convert.ToDateTime(_LinVenDetSeries._Lineas._Fecha);

//            //Datos resumen de serie
//            _oGridResumen.Columns.Clear();
//            _oGridResumen.DataSource = Serie._ResumenSeries(_otxtArticulo._Codigo, _otxtAlmacen._Codigo, dFechaDocumento);

//            _PanelResumen._Titulo = "Resumen a " + dFechaDocumento.ToString(EW_GLOBAL._CustomFormatDate);

//            //Establezco el origen de los datos
//            _oManteGrid._Grid.DataSource = _LinVenDetSeries._lisCodigos;

//            //Bloqueo los códigos que provienen de BBDD
//            _dicEstadoOriginal.Clear();
//            foreach (DataGridViewRow ldrRow in _oManteGrid._Grid.Rows)
//            {
//                LinVenDetSeries loLinea = (LinVenDetSeries)ldrRow.DataBoundItem;
//                ldrRow.Cells["_Codigo"].ReadOnly = ldrRow.Cells["_Garantia"].ReadOnly = loLinea._RegistroAlmacenado;
//                //Me guardo el estado por si finalmente no cambia
//                if(!String.IsNullOrWhiteSpace(loLinea._Codigo) && !_dicEstadoOriginal.ContainsKey(loLinea._Codigo)) //No espero duplicados pero nunca se sabe
//                    _dicEstadoOriginal.AddOrUpdate(loLinea._Codigo, loLinea._Baja, (key, oldval) => loLinea._Baja);
//            }

            

//            _oManteGrid._DataSource_Row_New_Event += new Mantegrid._DataSource_Row_New_Event_Handler(Evento_DataSource_NewRow);
//            _oManteGrid._DataSource_Row_Delete_Event += new Mantegrid._DataSource_Row_Delete_Event_Handler(Evento_DataSource_DeleteRow);

//            //Me suscribo a los eventos de edición
//            _oManteGrid._Grid.CellBeginEdit += new DataGridViewCellCancelEventHandler(Evento_Grid_CellBeginEdit);
//            _oManteGrid._Grid.CellEndEdit += new DataGridViewCellEventHandler(Evento_Grid_CellEndEdit);

//            _oManteGrid._F4_BeforeClick += new Mantegrid._F4_BeforeClick_Handler(Evento_oManteGrid__F4_BeforeClick);
//            _oManteGrid._F5_BeforeClick += new Mantegrid._F5_BeforeClick_Handler(Evento_Grid__F5_KeyPress); //F5 sobre el grid

//            // Configurem el browser
//            _btBrowSeries._Clave = "SERIE";
//            _btBrowSeries._Tabla = "COMPRAS";
//            _btBrowSeries._DataBase = "COMUNES";
//            _btBrowSeries._Titulo = "Series";
//            _btBrowSeries._Titulos_Campos = "Series, Baja, Fecha de compra, Garantía"; 
//            _btBrowSeries._Campo_Predet = "SERIE";
//            _btBrowSeries._Campos = "SERIE, BAJA, FECHA, GARANTIA";
//            _oManteGrid._TeclaF4("_Codigo", _btBrowSeries);
//            _oManteGrid._TeclaF5("_Codigo", _btManteFicticio);
//            _btManteFicticio._Click_Before += new btMante._Click_Before_Handler(Evento_oManteGrid__F5_BeforeClick); //Click sobre el boton
//        }

//        /// <summary>
//        /// Evento F5 sobre el mantegrid
//        /// </summary>
//        /// <param name="sender"></param>
//        /// <param name="toMante"></param>
//        void Evento_Grid__F5_KeyPress(object sender, ref btMante toMante)
//        {
//            //Muestro el formulario de información de la serie
//            MostrarInformacionSerie();
//        }

//        /// <summary>
//        /// Evento F5 sobre el mantegrid
//        /// </summary>
//        /// <param name="tlOk">False para parar la ejecución</param>
//        void Evento_oManteGrid__F5_BeforeClick(ref bool tlOk)
//        {
//            //Paro la ejecución => Ya ha pasado por Evento_oManteGrid__F5_KeyPress y no ha de hacer nada más
//            tlOk = false;
//        }

//        /// <summary>
//        /// Evento F4 Sobre el grid
//        /// </summary>
//        /// <param name="sender"></param>
//        /// <param name="toBrowser"></param>
//        void Evento_oManteGrid__F4_BeforeClick(object sender, ref botones.btBrowser toBrowser)
//        {
//            _btBrowSeries._Titulo = "Series en el almacén " + _otxtAlmacen._Codigo + 
//                " anteriores a " + ((DateTime)Convert.ToDateTime(_LinVenDetSeries._Lineas._Fecha)).ToString(EW_GLOBAL._CustomFormatDate);
//            _btBrowSeries._Condicion = "almacen = " +  DB.SQLString(_otxtAlmacen._Codigo) + 
//                " AND ARTICULO = " + DB.SQLString(_LinVenDetSeries._Lineas._Articulo) +
//                " AND FECHA <= " + DB.SQLString(_LinVenDetSeries._Lineas._Fecha);

//            //Bug 112747 Duplicación de series por F4 => Creo una lista de exclusión de los elementos que ya tengo
//            string lcTempCondicion = string.Empty;
//            foreach (LinVenDetSeries loElemento in _LinVenDetSeries._lisCodigos.Where(loSerie => !string.IsNullOrEmpty(loSerie._Codigo)))
//            {
//                if (!string.IsNullOrEmpty(lcTempCondicion)) lcTempCondicion += ","; //Si no es el primer elemento
//                lcTempCondicion += DB.SQLString(loElemento._Codigo.Trim());
//            }
//            if (!string.IsNullOrEmpty(lcTempCondicion))
//                _btBrowSeries._Condicion += " AND SERIE NOT IN (" + lcTempCondicion + ")";

//            if (!_oManteGrid._Grid.CurrentCell.IsInEditMode)
//            {
//                _oManteGrid._Grid.CellValueChanged -= new DataGridViewCellEventHandler(Evento_CellValueChangedConBtBrowser); //por si han cancelado
//                _oManteGrid._Grid.CellValueChanged += new DataGridViewCellEventHandler(Evento_CellValueChangedConBtBrowser);
//            }
//        }

//        void Evento_CellValueChangedConBtBrowser(object sender, DataGridViewCellEventArgs e)
//        {
//            if (sender != null && e.ColumnIndex == _oManteGrid._Grid.Columns["_Codigo"].Index)
//            {
//                ComprobarExistenciaSerie(_oManteGrid._Grid.Rows[e.RowIndex]);
//                _oManteGrid._Grid.CellValueChanged -= new DataGridViewCellEventHandler(Evento_CellValueChangedConBtBrowser);
//            }
//        }

//        /// <summary>
//        /// Respuesta al evento de inicio de edición
//        /// </summary>
//        /// <param name="sender"></param>
//        /// <param name="e"></param>
//        void Evento_Grid_CellBeginEdit(object sender, DataGridViewCellCancelEventArgs e)
//        {
//            //Si se trata de la columna del código
//            if (e.ColumnIndex == _oManteGrid._Grid.Columns["_Codigo"].Index)
//            {
//                //En este momento he entrado en una celda de _codigo no informado y tengo que añadir el dígito de control
//                ((LinVenDetSeries)_oManteGrid._Grid.Rows[e.RowIndex].DataBoundItem)._Evento_Validacion_Codigo_Before += new LinVenDetSeries._Validacion_Codigo_Handler(Evento_Validacion_Codigo_Before);
//            }
//        }

//        void Evento_Validacion_Codigo_Before(object sender, ValidationEventArgs e)
//        {
//            if (sender == null)
//                return;
//            //Verifico que no este en la lista
//            e._Cancel = _oLinVenDetSeries._lisCodigos.Count(loEle => loEle._Codigo == e._Serie) == 1;
//            if (e._Cancel)
//                e._Mensaje = String.Format("La serie {0} ya se encuentra en la lista.", e._Serie);
//        }

//        /// <summary>
//        /// Respuesta al evento de finalización de edición
//        /// </summary>
//        /// <param name="sender"></param>
//        /// <param name="e"></param>
//        void Evento_Grid_CellEndEdit(object sender, DataGridViewCellEventArgs e)
//        {
//            if (sender == null)
//                return;

//            //Si se trata de la columna del código
//            if (e.ColumnIndex == _oManteGrid._Grid.Columns["_Codigo"].Index)
//            {
//                //Verifico si la serie existe
//                ComprobarExistenciaSerie(((ewgrid)sender).Rows[e.RowIndex]);

//                ((LinVenDetSeries)_oManteGrid._Grid.Rows[e.RowIndex].DataBoundItem)._Evento_Validacion_Codigo_Before -= new LinVenDetSeries._Validacion_Codigo_Handler(Evento_Validacion_Codigo_Before);
//            }  
//        }

//        /// <summary>
//        /// Respuesta al evento de borrado de líneas
//        /// </summary>
//        /// <param name="trRowDelete"></param>
//        void Evento_DataSource_DeleteRow(DataGridViewRow trRowDelete)
//        {
//            //Determino si la línea proviene de BBDD
//            if (trRowDelete.Cells["_RegistroAlmacenado"].Value != null && (bool)trRowDelete.Cells["_RegistroAlmacenado"].Value == true)
//            {
//                Traza("Suprimir del grid serie existente.");

//                //El registro existe en BBDD => hay que añadir la operación de anulación de la operación al broker

//                LinVenDetSeries loLinVenDet = (LinVenDetSeries)trRowDelete.DataBoundItem;
//                SerieDocStockInventario loSerie = new SerieDocStockInventario(loLinVenDet._Codigo, _oLinVenDetSeries._Lineas);

//                if (trRowDelete.Cells["_Baja"].Value != null && (bool)trRowDelete.Cells["_Baja"].Value == true)
//                {
//                    _OpereationBroker._AddOperacion(new CancelarBajaInventarioStockOp(loSerie));
//                    Traza($"Añadida operacion de CANCELAR BAJA al broker para la serie {loLinVenDet._Codigo}");
//                }
//                else
//                {
//                    _OpereationBroker._AddOperacion(new CancelarAltaInventarioStockOp(loSerie));
//                    Traza($"Añadida operacion de CANCELAR ALTA al broker para la serie {loLinVenDet._Codigo}");
//                }
//            }
//            else
//            {
//                Traza("Suprimir inventario serie ficticia (inexistente).");
//            }

//            //Suprimo de la lista
//            _oLinVenDetSeries._lisCodigos.Remove((LinVenDetSeries)trRowDelete.DataBoundItem);
//        }

//        /// <summary>
//        /// Respuesta al evento de añadir líneas
//        /// </summary>
//        /// <param name="tnInsertLinea"></param>
//        void Evento_DataSource_NewRow(int tnInsertLinea)
//        {
//            //No permito añadir mas de una linea en blanco
//            if (_LinVenDetSeries._lisCodigos.Count(ele => string.IsNullOrEmpty(ele._Codigo)) > 0)
//                return;

//            AddLinVenDet("");
//        }

//        /// <summary>
//        /// Respuesta al evento de salida del textbox de insertar series
//        /// </summary>
//        /// <param name="sender"></param>
//        /// <param name="e"></param>
//        void Evento_txtBuscar_Leave(object sender, EventArgs e)
//        {
//            ewtextbox loTxtBox = (ewtextbox)sender;
//            string lcMensaje = string.Empty;

//            // Código de barras tecleado ...
//            string numeroDeSerie = loTxtBox.Text.Trim();
//            if (!String.IsNullOrWhiteSpace(numeroDeSerie))
//            {
//                if (_oLinVenDetSeries._lisCodigos.Count(loEle => loEle._Codigo == numeroDeSerie) == 1)
//                {
//                    DataGridViewRow row = _oManteGrid._Grid.Rows
//                                    .Cast<DataGridViewRow>()
//                                    .Where(loRow => loRow.Cells["_Codigo"].Value != null && loRow.Cells["_Codigo"].Value.ToString().Equals(numeroDeSerie))
//                                    .First();

//                    _oManteGrid._Grid.CurrentCell = _oManteGrid._Grid["_Codigo", row.Index];
//                }
//                else
//                {
//                    using(SerieDocStockInventario loSerie = new SerieDocStockInventario())
//                    {
//                        //Realizo las validaciones para el código
//                        string lcErrorMessage = "";
//                        if (!loSerie._ComprobarValor(numeroDeSerie, false, _oLinVenDetSeries._Lineas, ref lcErrorMessage))
//                        {
//                            _MessageBox(lcErrorMessage, MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1, DialogResult.None);
//                        }
//                        else
//                        {
//                            if (TengoHuecosEnLasLineas())
//                            {
//                                LinVenDetSeries lineaVacia = ObtenerPrimeraLineaVacia();
//                                lineaVacia._Codigo = numeroDeSerie;
//                                EstablecerGarantia(lineaVacia, numeroDeSerie);
//                            }
//                            else
//                            {
//                                LinVenDetSeries loNewItem = new LinVenDetSeries(_oLinVenDetSeries._Lineas as IDocumentLinea, numeroDeSerie, _oLinVenDetSeries.__ObtenerNuevaPosicion())
//                                {
//                                    _Existe = new Serie(numeroDeSerie)._Disponible() != null
//                                };
//                                EstablecerGarantia(loNewItem, numeroDeSerie);
//                                _oLinVenDetSeries._lisCodigos.Add(loNewItem);
//                            }
//                        }
//                    }

//                }
//                loTxtBox.Text = "";
//            }
//        }

//        /// <summary>
//        /// Método privado para establecer la garantía de una serie
//        /// </summary>
//        /// <param name="LineaSeries"></param>
//        /// <param name="NumeroDeSerie"></param>
//        private void EstablecerGarantia(LinVenDetSeries LineaSeries, string NumeroDeSerie)
//        {
//            if (!LineaSeries._Existe) //Bug 112788
//                LineaSeries._Garantia = _GarantiaDefecto;
//            else
//                LineaSeries._Garantia = Serie._ObtenerGarantia(NumeroDeSerie);
//        }

//        private LinVenDetSeries ObtenerPrimeraLineaVacia()
//        {
//            return _oLinVenDetSeries._lisCodigos.Where(linea => String.IsNullOrWhiteSpace(linea._Codigo)).First();
//        }

//        private bool TengoHuecosEnLasLineas()
//        {
//            return _oLinVenDetSeries._lisCodigos.Where(linea => String.IsNullOrWhiteSpace(linea._Codigo)).ToList().Any();
//        }

//        /// <summary>
//        /// Click al botón de Aceptar
//        /// </summary>
//        /// <param name="sender"></param>
//        /// <param name="e"></param>
//        private void Evento_btDocAceptar1_Click(object sender, EventArgs e)
//        {
//            Traza("Click en Aceptar.");

//            FormClosing -= new FormClosingEventHandler(Evento_FormClosing);

//            DialogResult lodialog = new DialogResult();
//            string tcMensaje = "";

//            //Compruebo que tenga todas las series
//            lodialog = DialogResult.Yes;
//            if (Comprobar_FaltanSeries(ref tcMensaje))
//            {
//                lodialog = _MessageBox(tcMensaje + Environment.NewLine + Environment.NewLine +
//                    "¿Desea continuar de todos modos?", MessageBoxButtons.YesNo, MessageBoxIcon.Question, MessageBoxDefaultButton.Button2, DialogResult.Yes);
//            }


//            if (lodialog == DialogResult.Yes)
//            {
//                _GrabarSeries();
//            }
//            else
//            {
//                DialogResult = DialogResult.None;

//                //Restablezco el control de cierre por la X
//                FormClosing += new FormClosingEventHandler(Evento_FormClosing);
//            }
//        }

//        /// <summary>
//        /// Función auxiliar para comprobar la falta de series
//        /// </summary>
//        /// <param name="tcMensaje">Mensaje con el texto del error si corresponde</param>
//        /// <returns>True si faltan series</returns>
//        private bool Comprobar_FaltanSeries(ref string tcMensaje)
//        {
//            Traza("Comprobando si faltan series...");

//            bool llError = false;

//            DataTable ldtSeriesFaltan = new DataTable();
//            int lnCuantasFaltan = ObtenerSeriesRestantes(ref ldtSeriesFaltan);

//            if(lnCuantasFaltan > 0)
//            {
//                tcMensaje = "No ha introducido todas las series correctamente. " + Environment.NewLine +
//                    String.Format("Quedan {0} series a las que definir su estado.",lnCuantasFaltan) + Environment.NewLine + 
//                    "En caso de que no se defina quedarán en estado de alta.";
//                llError = true;
//            }
//            return llError;
//        } 

//        /// <summary>
//        /// Método que ordena y graba las series
//        /// </summary>
//        private void _GrabarSeries()
//        {
//            #region Grabar resultados ordenados

//            //Paso a una lista mis elemntos (descartando los nulos) ordenados por SERIE 
//            List<LinVenDetSeries> loList = _LinVenDetSeries._lisCodigos
//                .Where(loSerie => !string.IsNullOrEmpty(loSerie._Codigo))
//                .OrderBy(loEle => loEle._Codigo).ToList();

//            int lnPos = 1;

//            //Asigno a los elementos de la lista el nuevo orden relativo. 
//            foreach (LinVenDetSeries loElement in loList)
//            {
//                _LinVenDetSeries._lisCodigos[_LinVenDetSeries._lisCodigos.IndexOf(loElement)]._Posicion = lnPos;
//                lnPos++;
//            }

//            #endregion Grabar resultados ordenados

//            Traza($"Lista de series no vacias con {loList.Count} elementos ");

//            //Añado las operaciones al broker
//            loList.ForEach(loEle => LoadAddOperation(loEle));

//            //Ejecutamos => Las operaciones de las líneas y las que pudiera haber de borrado de líneas existentes
//            _OpereationBroker._EjecutarOperaciones();
//        }

//        /// <summary>
//        /// Método auxiliar para determinar y añadir al broker la operación necesaria en base al campo BAJA de la serie 
//        /// </summary>
//        /// <param name="toLinVenDet"></param>
//        private void LoadAddOperation(LinVenDetSeries toLinVenDet)
//        {
//            SerieDocStockInventario loSerie = new SerieDocStockInventario(toLinVenDet._Codigo, _oLinVenDetSeries._Lineas)
//            {
//                _Garantia = toLinVenDet._Garantia
//            };

//            if (_dicEstadoOriginal.ContainsKey(loSerie._Codigo) && _dicEstadoOriginal[loSerie._Codigo] == toLinVenDet._Baja)
//            {
//                Traza($"Thread {Thread.CurrentThread.ManagedThreadId} => La serie {toLinVenDet._Codigo} no ha cambiado. No se añade ninguna operación.");
//                return;
//            }

//            if (toLinVenDet._Baja)
//            {
//                _OpereationBroker._AddOperacion(new BajaInventarioStockOp(loSerie));
//                Traza($"Thread {Thread.CurrentThread.ManagedThreadId} => Añadida operacion de BAJA al broker para la serie {toLinVenDet._Codigo}");
//            }
//            else
//            {
//                _OpereationBroker._AddOperacion(new AltaInventarioStockOp(loSerie));
//                Traza($"Thread {Thread.CurrentThread.ManagedThreadId} => Añadida operacion de ALTA al broker para la serie {toLinVenDet._Codigo}");
//            }
//        }

//        /// <summary>
//        /// Click al botón de Cancelar
//        /// </summary>
//        /// <param name="sender"></param>
//        /// <param name="e"></param>
//        private void Evento_btDocCancelar1_Click(object sender, EventArgs e)
//        {
//            FormClosing -= new FormClosingEventHandler(Evento_FormClosing);

//            DialogResult lodialog = new DialogResult();
//            lodialog = DialogResult.Yes;

//            if (lodialog == DialogResult.Yes)
//            {
//                _LinVenDetSeries._lisCodigos.Clear();
//                _LinVenDetSeries._Load(); //Restablezco lo que teniamos guardado
//            }
//            else
//            {
//                DialogResult = DialogResult.None;

//                //Restablezco el control de cierre por la X
//                FormClosing += new FormClosingEventHandler(Evento_FormClosing);
//            }
//        }


//        /// <summary>
//        /// Respuesta al evento de cierre de formulario
//        /// </summary>
//        /// <param name="sender"></param>
//        /// <param name="e"></param>
//        void Evento_FormClosing(object sender, FormClosingEventArgs e)
//        {
//            //Si esta cerrando el usuario
//            if (e.CloseReason == CloseReason.UserClosing)
//            {
//                Trace.WriteLineIf(Debugger.IsAttached, "frmInventarioSeries => Cerrar formulario.");

//                //Estan saliendo por la X o Alt + F4
//                string lcMensaje = "";

//                if (Comprobar_FaltanSeries(ref lcMensaje))
//                {
//                    DialogResult lodialog = new DialogResult();
//                    lodialog = DialogResult.Yes;

//                    lodialog = _MessageBox(lcMensaje + Environment.NewLine + Environment.NewLine +
//                            "¿Desea continuar de todos modos?", MessageBoxButtons.YesNo, MessageBoxIcon.Question, MessageBoxDefaultButton.Button2, DialogResult.Yes);

//                    //Bloqueo la salida si no ha dicho que quiere continuar
//                    e.Cancel = (lodialog != DialogResult.Yes);
//                }
//            }
//        }

//        /// <summary>
//        /// Método Load
//        /// </summary>
//        /// <param name="e"></param>
//        protected override void OnLoad(EventArgs e)
//        {
//            base.OnLoad(e);
            
//            PrepararFormulario();
//        }

//        #endregion Métodos Override

//        /// <summary>
//        /// Función que prepara el formulario
//        /// </summary>
//        private void PrepararFormulario()
//        {
//#if ewTools //Rendimiento
//            EwTools._WriteTrace(EwTools.eMethodStatus.Inicio);
//#endif

//            //Si no tengo objeto series termino.
//            if (_oLinVenDetSeries == null) return;

//            _otxtArticulo._Codigo = _LinVenDetSeries._Lineas._Articulo;
//            _otxtAlmacen._Codigo = ((StockInventario)_LinVenDetSeries._Lineas._StockINV)._Almacen;

//            Preparar_Grid();

//            //Monto la botonera
//            MontarBotones();

//            //Recupero la imágen
//            RecuperarImagen();

//            //Control de cierre por la X
//            FormClosing += new FormClosingEventHandler(Evento_FormClosing);

//#if ewTools //Rendimiento
//            EwTools._WriteTrace(EwTools.eMethodStatus.Fin);
//#endif
//        }

//        /// <summary>
//        /// Función para preparar el Grid
//        /// Crea las columnas, valida los datos 
//        /// </summary>
//        private void Preparar_Grid()
//        {
//#if ewTools //Rendimiento
//            EwTools._WriteTrace(EwTools.eMethodStatus.Inicio);
//#endif

//            //PE-100009 Miro si tengo códigos... Sino hay códigos prefijaré valores de una forma que no necesite calcular los valores
//            bool llSinSeries = (_LinVenDetSeries._lisCodigos.Where(loSerie => !string.IsNullOrEmpty(loSerie._Codigo)).Count() == 0);

//            //Llamo al método que crea las columnas
//            Preparar_Grid_CrearColumnas(llSinSeries);

//            //Establezco el origen de los datos
//            _oManteGrid._Grid.DataSource = _LinVenDetSeries._lisCodigos;

//#if ewTools //Rendimiento
//            EwTools._WriteTrace(EwTools.eMethodStatus.Fin);
//#endif
//        }

//        /// <summary>
//        /// Método auxiliar para crear las columnas
//        /// </summary>
//        private void Preparar_Grid_CrearColumnas(bool tlSinSeries)
//        {

//            //Configuro el mantegrid para que no me genere las columnas automaticamente. 
//            _oManteGrid._Grid.AutoGenerateColumns = false;
//            _oManteGrid._RecuadroVisible = false;

//            //Definimos las propiedades de las columnas que vamos a utilizar.
//            #region DefinicionColumnasGrid

//            #region Posicion

//            using (Mantegrid.ewDataGridViewTextBoxColumn ldgtbColUnidades = new Mantegrid.ewDataGridViewTextBoxColumn())
//            {
//                ldgtbColUnidades.Name = "_Posicion";
//                ldgtbColUnidades.DataPropertyName = "_Posicion";
//                ldgtbColUnidades.HeaderText = "Número";
//                ldgtbColUnidades.ValueType = typeof(int);
//                ldgtbColUnidades.Visible = true;
//                ldgtbColUnidades._NoParar = true;
//                ldgtbColUnidades.AutoSizeMode = DataGridViewAutoSizeColumnMode.AllCells;
//                ldgtbColUnidades.ToolTipText = "Número de series requeridas.";


//                //PE-78508 Se establece readonly para no dejar de modificar el campo
//                ldgtbColUnidades.ReadOnly = true;
//                this._oManteGrid._Grid.Columns.Add(ldgtbColUnidades);
//            }

//            #endregion Posicion

//            #region Serie

//            using (Mantegrid.ewDataGridViewTextBoxColumn ldgtbColSerie = new Mantegrid.ewDataGridViewTextBoxColumn())
//            {
//                ldgtbColSerie.Name = "_Codigo";
//                ldgtbColSerie.DataPropertyName = "_Codigo";
//                ldgtbColSerie.HeaderText = "Series";
//                ldgtbColSerie.ValueType = typeof(string);
//                ldgtbColSerie.Visible = true;
//                ldgtbColSerie._NoParar = false;
//                ldgtbColSerie.ReadOnly = false; // !tlSinSeries; //PE-100009 Si no hay series ReadOnly a false
//                ldgtbColSerie.MaxInputLength = sage.ew.global.EW_GLOBAL._GetLenCampo("wn_serie");
//                ldgtbColSerie.AutoSizeMode = DataGridViewAutoSizeColumnMode.Fill;
//                ldgtbColSerie.ToolTipText = "Código de la Serie.";
//                this._oManteGrid._Grid.Columns.Add(ldgtbColSerie);
//            }

//            #endregion Serie

//            #region Existe

//            using (Mantegrid.ewDataGridViewCheckBoxColumn ldgtbColExiste = new Mantegrid.ewDataGridViewCheckBoxColumn())
//            {
//                ldgtbColExiste.Name = "_Existe";
//                ldgtbColExiste.HeaderText = "Existe";
//                ldgtbColExiste.DataPropertyName = "_Existe";
//                ldgtbColExiste.ValueType = typeof(bool);
//                ldgtbColExiste.Visible = false;
//                ldgtbColExiste._NoParar = true;
//                ldgtbColExiste.ReadOnly = true;

//                //PE-100009 Prefijo valores para rendimiento
//                ldgtbColExiste.TrueValue = true;
//                ldgtbColExiste.IndeterminateValue = false;
//                ldgtbColExiste.FalseValue = false;

//                ldgtbColExiste.AutoSizeMode = DataGridViewAutoSizeColumnMode.AllCells;
//                ldgtbColExiste.ToolTipText = "Existencia de la Serie.";
//                this._oManteGrid._Grid.Columns.Add(ldgtbColExiste);
//            }

//            #endregion Existe

//            #region Baja

//            using (Mantegrid.ewDataGridViewCheckBoxColumn ldgtbColBaja = new Mantegrid.ewDataGridViewCheckBoxColumn())
//            {
//                ldgtbColBaja.Name = "_Baja";
//                ldgtbColBaja.HeaderText = "Baja";
//                ldgtbColBaja.DataPropertyName = "_Baja";
//                ldgtbColBaja.ValueType = typeof(bool);
//                ldgtbColBaja.Visible = true;
//                ldgtbColBaja._NoParar = true;
//                ldgtbColBaja.ReadOnly = false;

//                //Prefijo valores para rendimiento
//                ldgtbColBaja.TrueValue = true;
//                ldgtbColBaja.IndeterminateValue = false;
//                ldgtbColBaja.FalseValue = false;

//                ldgtbColBaja.AutoSizeMode = DataGridViewAutoSizeColumnMode.AllCells;
//                ldgtbColBaja.ToolTipText = "Estado de la serie.";
//                this._oManteGrid._Grid.Columns.Add(ldgtbColBaja);
//            }

//            #endregion Baja

//            #region RegistroAlmacenado

//            using (Mantegrid.ewDataGridViewCheckBoxColumn ldgtbColRegistroAlmacenado = new Mantegrid.ewDataGridViewCheckBoxColumn())
//            {
//                ldgtbColRegistroAlmacenado.Name = "_RegistroAlmacenado";
//                ldgtbColRegistroAlmacenado.HeaderText = "RegistroAlmacenado";
//                ldgtbColRegistroAlmacenado.DataPropertyName = "_RegistroAlmacenado";
//                ldgtbColRegistroAlmacenado.ValueType = typeof(bool);
//                ldgtbColRegistroAlmacenado.Visible = false;
//                ldgtbColRegistroAlmacenado._NoParar = true;
//                ldgtbColRegistroAlmacenado.ReadOnly = true;

//                //Prefijo valores para rendimiento
//                ldgtbColRegistroAlmacenado.TrueValue = true;
//                ldgtbColRegistroAlmacenado.IndeterminateValue = false;
//                ldgtbColRegistroAlmacenado.FalseValue = false;

//                ldgtbColRegistroAlmacenado.AutoSizeMode = DataGridViewAutoSizeColumnMode.AllCells;
//                ldgtbColRegistroAlmacenado.ToolTipText = "Registro almacenado.";
//                this._oManteGrid._Grid.Columns.Add(ldgtbColRegistroAlmacenado);
//            }

//            #endregion RegistroAlmacenado

//            #region Garantia

//            using (Mantegrid.CalendarColumn ldgtbColGarantia = new Mantegrid.CalendarColumn())
//            {
//                ldgtbColGarantia.Name = "_Garantia";
//                ldgtbColGarantia.HeaderText = "Garantía";
//                ldgtbColGarantia.DataPropertyName = "_Garantia";
//                ldgtbColGarantia.ValueType = typeof(DateTime);
//                ldgtbColGarantia.Visible = true;
//                ldgtbColGarantia._NoParar = true;
//                ldgtbColGarantia.ReadOnly = false;
//                ldgtbColGarantia.MinimumWidth = 80;
//                ldgtbColGarantia.AutoSizeMode = DataGridViewAutoSizeColumnMode.AllCells;
//                ldgtbColGarantia.ToolTipText = "Fecha de finalización de la garantía";

//                this._oManteGrid._Grid.Columns.Add(ldgtbColGarantia);
//            }

//            #endregion Garantia

//            #endregion DefinicionColumnasGrid

//            //Rendimiento
//            #region VirtualMode

//            if (!tlSinSeries)
//            {

//                _oManteGrid._Grid.VirtualMode = true;
//                _oManteGrid._Grid.RowHeadersVisible = false;
//                _oManteGrid._Grid.CellValueNeeded += new DataGridViewCellValueEventHandler(EventoDeGrid_CellValueNeeded);
//                _oManteGrid._Grid.CellValuePushed += new DataGridViewCellValueEventHandler(EventoDeGrid_CellValuePushed);
//                _oManteGrid._Grid.NewRowNeeded += new DataGridViewRowEventHandler(EventoDeGrid_NewRowNeeded);
//                _oManteGrid._Grid.RowValidated += new DataGridViewCellEventHandler(EventoDeGrid_RowValidated);
//                _oManteGrid._Grid.RowDirtyStateNeeded += new QuestionEventHandler(EventoDeGrid_RowDirtyStateNeeded);
//                _oManteGrid._Grid.CancelRowEdit += new QuestionEventHandler(EventoDeGrid_CancelRowEdit);
//                _oManteGrid._Grid.UserDeletingRow += new DataGridViewRowCancelEventHandler(EventoDeGrid_UserDeletingRow);

//                // Set the row count, including the row for new records.
//                _oManteGrid._Grid.RowCount = _LinVenDetSeries._lisCodigos.Count;// +1;
//            }

//            #endregion VirtualMode
//        }


//        #region Eventos VirtualMode para rendimiento

//        //Rendimiento
//        /// <summary>
//        /// Evento de borrado de fila por parte del usuario
//        /// </summary>
//        /// <param name="sender"></param>
//        /// <param name="e"></param>
//        void EventoDeGrid_UserDeletingRow(object sender, DataGridViewRowCancelEventArgs e)
//        {
//            if (e.Row.Index < this._LinVenDetSeries._lisCodigos.Count)
//            {
//                // Si se borra una línea existente borramos el correspondiente objeto LinVenDetSerie de los datos
//                this._LinVenDetSeries._lisCodigos.RemoveAt(e.Row.Index);
//            }

//            if (e.Row.Index == this._nFilaEnEdicion)
//            {
//                // Si el objeto que se borra es nuevo liberamos el objeto LinVenDetSerie
//                this._nFilaEnEdicion = -1;
//                this._oLinVenDetSerieEnEdicion = null;
//            }
//        }

//        //Rendimiento
//        /// <summary>
//        /// Evento de cancelación de edición
//        /// </summary>
//        /// <param name="sender"></param>
//        /// <param name="e"></param>
//        void EventoDeGrid_CancelRowEdit(object sender, QuestionEventArgs e)
//        {
//            if (this._nFilaEnEdicion == _oManteGrid._Grid.Rows.Count - 2 &&
//                this._nFilaEnEdicion == this._LinVenDetSeries._lisCodigos.Count)
//            {
//                // If the user has canceled the edit of a newly created row, 
//                // replace the corresponding Customer object with a new, empty one.
//                this._oLinVenDetSerieEnEdicion = new LinVenDetSeries();
//            }
//            else
//            {
//                // If the user has canceled the edit of an existing row, 
//                // release the corresponding Customer object.
//                this._oLinVenDetSerieEnEdicion = null;
//                this._nFilaEnEdicion = -1;
//            }
//        }

//        //Rendimiento
//        /// <summary>
//        /// Evento de modificación de celda (para confimaciones a nivel de celda)
//        /// </summary>
//        /// <param name="sender"></param>
//        /// <param name="e"></param>
//        void EventoDeGrid_RowDirtyStateNeeded(object sender, QuestionEventArgs e)
//        {
//            if (!_lrowScopeCommit)
//            {
//                // In cell-level commit scope, indicate whether the value
//                // of the current cell has been modified.
//                e.Response = _oManteGrid._Grid.IsCurrentCellDirty;
//            }
//        }

//        //Rendimiento
//        /// <summary>
//        /// Evento de validación de fila
//        /// </summary>
//        /// <param name="sender"></param>
//        /// <param name="e"></param>
//        void EventoDeGrid_RowValidated(object sender, DataGridViewCellEventArgs e)
//        {
//            // Save row changes if any were made and release the edited 
//            // Customer object if there is one.
//            if (e.RowIndex >= this._LinVenDetSeries._lisCodigos.Count &&
//                e.RowIndex != _oManteGrid._Grid.Rows.Count - 1)
//            {
//                // Add the new Customer object to the data store.
//                this._LinVenDetSeries._lisCodigos.Add(this._oLinVenDetSerieEnEdicion);
//                this._oLinVenDetSerieEnEdicion = null;
//                this._nFilaEnEdicion = -1;
//            }
//            else if (this._oLinVenDetSerieEnEdicion != null &&
//                e.RowIndex < this._LinVenDetSeries._lisCodigos.Count)
//            {
//                // Save the modified Customer object in the data store.
//                this._LinVenDetSeries._lisCodigos[e.RowIndex] = this._oLinVenDetSerieEnEdicion;
//                this._oLinVenDetSerieEnEdicion = null;
//                this._nFilaEnEdicion = -1;
//            }
//            else if (_oManteGrid._Grid.ContainsFocus)
//            {
//                this._oLinVenDetSerieEnEdicion = null;
//                this._nFilaEnEdicion = -1;
//            }
//        }

//        //Rendimiento
//        /// <summary>
//        /// Evento solicitud de nueva fila
//        /// </summary>
//        /// <param name="sender"></param>
//        /// <param name="e"></param>
//        void EventoDeGrid_NewRowNeeded(object sender, DataGridViewRowEventArgs e)
//        {
//            // Create a new Customer object when the user edits
//            // the row for new records.
//            this._oLinVenDetSerieEnEdicion = new LinVenDetSeries();
//            this._nFilaEnEdicion = _oManteGrid._Grid.Rows.Count - 1;
//            //Asigno un valor de garantia
//            this._oLinVenDetSerieEnEdicion._Garantia = _GarantiaDefecto;
//        }

//        //Rendimiento
//        /// <summary>
//        /// 
//        /// </summary>
//        /// <param name="sender"></param>
//        /// <param name="e"></param>
//        void EventoDeGrid_CellValuePushed(object sender, DataGridViewCellValueEventArgs e)
//        {
//            LinVenDetSeries loLinVenDetSeriesTmp = null;

//            // Almaceno la referencia al objeto LinVenDetSerie para la fila que estamos editando
//            if (e.RowIndex < _LinVenDetSeries._lisCodigos.Count)
//            {
//                // Si el usuari esta editando una fila nuevo creo un nuevo objeto LinVenDetSerie 
//                if (this._oLinVenDetSerieEnEdicion == null)
//                {
//                    this._oLinVenDetSerieEnEdicion = new LinVenDetSeries(_LinVenDetSeries._Lineas,
//                        ((LinVenDetSeries)this._LinVenDetSeries._lisCodigos[e.RowIndex])._Codigo,
//                        ((LinVenDetSeries)this._LinVenDetSeries._lisCodigos[e.RowIndex])._Posicion);
//                    _oLinVenDetSerieEnEdicion._Baja = ((LinVenDetSeries)this._LinVenDetSeries._lisCodigos[e.RowIndex])._Baja;
//                    _oLinVenDetSerieEnEdicion._RegistroAlmacenado = ((LinVenDetSeries)this._LinVenDetSeries._lisCodigos[e.RowIndex])._RegistroAlmacenado;
//                    _oLinVenDetSerieEnEdicion._Garantia = ((LinVenDetSeries)this._LinVenDetSeries._lisCodigos[e.RowIndex])._Garantia;
//                }
//                loLinVenDetSeriesTmp = this._oLinVenDetSerieEnEdicion;
//                this._nFilaEnEdicion = e.RowIndex;
//            }
//            else
//            {
//                loLinVenDetSeriesTmp = this._oLinVenDetSerieEnEdicion;
//            }

//            // Asignamos el valor de la propiedad desde la celda que hemos informado
//            String newValue = e.Value as String;
//            switch (_oManteGrid._Grid.Columns[e.ColumnIndex].Name)
//            {
//                case "_Codigo":
//                    loLinVenDetSeriesTmp._Codigo = newValue;
//                    break;

//                case "_Posicion":
//                    loLinVenDetSeriesTmp._Posicion = Convert.ToInt32(newValue);
//                    break;
//                case "_Baja":
//                    loLinVenDetSeriesTmp._Baja = Convert.ToBoolean(newValue);
//                    break;
//                case "_Existe":
//                    loLinVenDetSeriesTmp._Existe = Convert.ToBoolean(newValue);
//                    break;
//                case "_RegistroAlmacenado":
//                    loLinVenDetSeriesTmp._RegistroAlmacenado = Convert.ToBoolean(newValue);
//                    break;
//                case "_Garantia":
//                    loLinVenDetSeriesTmp._Garantia = Convert.ToDateTime(newValue);
//                    break;
//            }
//        }

//        //Rendimiento
//        /// <summary>
//        /// Evento de solicitud de valor
//        /// </summary>
//        /// <param name="sender"></param>
//        /// <param name="e"></param>
//        void EventoDeGrid_CellValueNeeded(object sender, DataGridViewCellValueEventArgs e)
//        {
//            // Si la fila es para valores nuevos no necessito valores
//            if (e.RowIndex == _oManteGrid._Grid.RowCount) // - 1) 
//                return;

//            LinVenDetSeries loLinVenDetSerieTmp = null;

//            // Almaceno la referencia al objeto LinVenDetSerie para la fila que estamos pintando
//            if (e.RowIndex == _nFilaEnEdicion)
//            {
//                loLinVenDetSerieTmp = this._oLinVenDetSerieEnEdicion;
//            }
//            else
//            {
//                loLinVenDetSerieTmp = (LinVenDetSeries)_LinVenDetSeries._lisCodigos[e.RowIndex];
//            }

//            // Establezco el valor en la celda a pintar usando el objeto LinVenDet recuperado
//            switch (_oManteGrid._Grid.Columns[e.ColumnIndex].Name)
//            {
//                case "_Codigo":
//                    e.Value = loLinVenDetSerieTmp._Codigo;
//                    break;

//                case "_Posicion":
//                    e.Value = loLinVenDetSerieTmp._Posicion;
//                    break;

//                case "_Existe":
//                    e.Value = loLinVenDetSerieTmp._Existe;
//                    _oManteGrid._Grid["_Garantia", e.RowIndex].ReadOnly = loLinVenDetSerieTmp._Existe; //Establezco el modo ReadOnly de la celda de garantia

//                    break;

//                case "_Baja":
//                    e.Value = loLinVenDetSerieTmp._Baja;
//                    break;

//                case "_RegistroAlmacenado":
//                    e.Value = loLinVenDetSerieTmp._RegistroAlmacenado;
//                    break;

//                case "_Garantia":
//                    if (loLinVenDetSerieTmp._Garantia == null) //Sino hay valor fabrico uno
//                        e.Value = _GarantiaDefecto;
//                    else
//                        e.Value = loLinVenDetSerieTmp._Garantia;
//                    break;
//            }
//        }

//        #endregion Eventos VirtualMode para rendimiento

//        /// <summary>
//        /// Evento click en el botón de añadir resto de series como BAJA
//        /// </summary>
//        /// <param name="sender"></param>
//        /// <param name="e"></param>
//        private void BtRestoBajas_Click(object sender, EventArgs e)
//        {
//            AgregarRestoSeries(tlAgregarComoBaja: true);
//        }

//        /// <summary>
//        /// Evento click en el botón de añadir resto de series como ALTA
//        /// </summary>
//        /// <param name="sender"></param>
//        /// <param name="e"></param>
//        private void BtRestoAltas_Click(object sender, EventArgs e)
//        {
//            AgregarRestoSeries(tlAgregarComoBaja: false);
//        }

//        /// <summary>
//        /// Método auxiliar para abrir la pantalla de información de series
//        /// </summary>
//        private void MostrarInformacionSerie()
//        {
//            frmSeries loForm = new frmSeries();
//            if (_oManteGrid._Grid.CurrentRow != null && _oManteGrid._Grid.CurrentRow.Index >= 0) //Indice -1 son títulos
//            {
//                string lcSerieGrid = ((LinVenDetSeries)_oManteGrid._Grid.CurrentRow.DataBoundItem)._Codigo;
//                if (!String.IsNullOrWhiteSpace(lcSerieGrid))
//                {
//                    Serie loSerie = new Serie(lcSerieGrid);

//                    if (loSerie._Disponible() != null) //Sino existia la serie explotaba
//                        loForm._Serie = new Serie(lcSerieGrid);
//                }
//            }
//            loForm._ShowDialog(); //Bug 114218 Cambiar .ShowDialog() por ._ShowDialog()
//        }

//        /// <summary>
//        /// Método privado para determinar si una serie existe o no 
//        /// </summary>
//        /// <param name="loRow"></param>
//        private void ComprobarExistenciaSerie(DataGridViewRow loRow)
//        {
//            string lcCodigo = ((LinVenDetSeries)loRow.DataBoundItem)._Codigo;
//            //Si la serie al mirar disponibilidad no devuelve null (no exite) => Será EXISTE true
//            if (!string.IsNullOrWhiteSpace(lcCodigo))
//            {
//                bool llExiste = (((Serie)Activator.CreateInstance(typeof(Serie)))._Disponible(lcCodigo) != null) ? true : false;
//                loRow.Cells["_Existe"].Value = llExiste;
//                if (llExiste)
//                    loRow.Cells["_Garantia"].Value = Serie._ObtenerGarantia(lcCodigo);
//                else
//                    loRow.Cells["_Garantia"].Value = _GarantiaDefecto;
//                _oManteGrid._Grid["_Garantia", loRow.Index].ReadOnly = llExiste;
//            }
//            else
//                loRow.Cells["_Existe"].Value = false;
//        }

//        /// <summary>
//        /// Establecemos controles de solo lectura
//        /// </summary>
//        private void ReadOnlyControlesInformativos()
//        {
//            _otxtArticulo._ReadOnly = true;
//            _otxtArticulo._Mostrar_Browser = false;

//            _otxtAlmacen._ReadOnly = true;
//            _otxtAlmacen._Mostrar_Browser = false;

//            _oGridResumen.ReadOnly = true;
//        }

//        /// <summary>
//        /// Método auxiliar para recuperar la imagen
//        /// </summary>
//        private void RecuperarImagen()
//        {
//            //Recuperamos la imagen del artículo
//            #region Imagen Articulo

//            //Recupero las imagenes del artículo
//            articulo.Articulo loArticulo = new articulo.Articulo(_LinVenDetSeries._Lineas._Articulo);

//            DataTable ldtImagenes = new DataTable();
//            ldtImagenes = loArticulo._Recuperar_Imagenes();
//            //Si el DataTable trae imagenes, recupero la primera. 
//            if (ldtImagenes.Rows.Count != 0) _oPictureboxArticulo.ImageLocation = ldtImagenes.Rows[0].ItemArray[0].ToString();
//            else _oPictureboxArticulo.Image = images.Properties.Resources.picture_no_available;
//            _oPictureboxArticulo.SizeMode = PictureBoxSizeMode.StretchImage;

//            #endregion Imagen Articulo
//        }

//        /// <summary>
//        /// Método auxiliar para posicionamiento de los botones dentro del flow de botones
//        /// </summary>
//        private void MontarBotones()
//        {
//            _oFlowBotones.Controls.Add(btSalir1);
//            _oFlowBotones.Controls.Add(btDocCancelar1);
//            _oFlowBotones.Controls.Add(btDocAceptar1);
//        }

//        /// <summary>
//        /// Método auxiliar para añadir líneas al grid
//        /// </summary>
//        /// <param name="tcSerie"></param>
//        /// <param name="lnPosicion"></param>
//        private void AddLinVenDet(string tcSerie = "", int lnPosicion = -1)
//        {
//            if (lnPosicion < 0)
//                lnPosicion = _oLinVenDetSeries.__ObtenerNuevaPosicion();

//            LinVenDetSeries loNewItem = new LinVenDetSeries(_oLinVenDetSeries._Lineas as IDocumentLinea, tcSerie, lnPosicion)
//            {
//                _Garantia = _GarantiaDefecto //Asingo un valor de garantia por defecto
//            };
//            _oLinVenDetSeries._lisCodigos.Add(loNewItem);
            
//        }

//        /// <summary>
//        /// Método auxiliar que añade las series restantes como ALTA o BAJA en función del parámetro
//        /// </summary>
//        /// <param name="tlAgregarComoBaja"></param>
//        private void AgregarRestoSeries(bool tlAgregarComoBaja)
//        {
//            //Recupero todas las series de este articulo y almacén que estan de alta y no estan en la lista
//            DataTable ldtSeries = new DataTable();
//            ObtenerSeriesRestantes(ref ldtSeries);

//            if (ldtSeries.Rows.Count > 0) //Si tengo series
//            {
//                //Aprovecho y limpio de líneas en blanco
//                var lineasVacias = _oLinVenDetSeries._lisCodigos.Where(ele => string.IsNullOrEmpty(ele._Codigo)).ToList();
//                lineasVacias.ForEach(loEle => _oLinVenDetSeries._lisCodigos.Remove(loEle));

//                //Máximo + 1 o directamente 1 =>  
//                int lnPosicion = _oLinVenDetSeries.__ObtenerNuevaPosicion();

//                foreach (DataRow ldr in ldtSeries.Rows)
//                {
//                    LinVenDetSeries loNewItem = new LinVenDetSeries(_oLinVenDetSeries._Lineas as IDocumentLinea, ldr["SERIE"].ToString().TrimEnd(), lnPosicion)
//                    {
//                        _Baja = tlAgregarComoBaja,
//                        _Existe = true
//                    };
//                    loNewItem._Garantia = Serie._ObtenerGarantia(loNewItem._Codigo);
//                    _oLinVenDetSeries._lisCodigos.Add(loNewItem);
//                    lnPosicion++;
//                }
//            }
//        }

//        /// <summary>
//        /// Método que carga en la tabla los datos de series que cumplan los criterios y que no estén ya usadas
//        /// </summary>
//        /// <param name="tdtDatos">Tabla donde cargar los datos</param>
//        /// <returns>Numero de registros de la tabla</returns>
//        private int ObtenerSeriesRestantes(ref DataTable tdtDatos)
//        {
//            //Recupero todas las series de este articulo y almacén que estan de alta y no estan en la lista
//            using (Serie loSerie = new Serie())
//            {
//                //Creo la lista de exclusiones
//                string lcFiltroFechas = " AND FECHA <= " + DB.SQLString(_LinVenDetSeries._Lineas._Fecha);
//                List<string> lisExcluidas = _oLinVenDetSeries._lisCodigos.Select(loEle => loEle._Codigo).ToList();
//                tdtDatos = loSerie._Obtener_Series(_otxtArticulo._Codigo, tlBaja: false, tcAlmacen: _otxtAlmacen._Codigo,
//                                                                toLista: lisExcluidas, tcClausulaWhereAdicional: lcFiltroFechas);
//                return tdtDatos.Rows.Count;
//            }   
                
//        }
//    }
}