//-------------------------------------------------------------------
// utilClientIE.js
// CARACTERÍSTICAS: Conjunto de funciones de cliente que serán útiles.
// OBSERVACION: Funciones probadas para un correcto funcionamiento
//    en navegadores de IE. ¡No se asegura para otros navegadores!
//--------------------------------------------------------------------

//##------------------------------------------------------------------------------
// #FUNCIÓN: StrMsg
// #CARACTERÍSTICAS: Función que intenta llamar a la función 'StrMsgError'. Si no
//    encuentra la función lanzará un mensaje por defecto.
// #PARÁMETROS: 
//    - IdError: Identificador del mensaje que queremos mostrar.
//##------------------------------------------------------------------------------
function StrMsg(IdError) {
  var msg
  
  try {
    // Intentamos mostrar el error utilizando la función estándar
    msg = StrMsgError(IdError);
  }
  catch (exception) {
    // Si no encontramos la función devolvemos un mensaje por defecto
    msg = "ERROR. [" + IdError + "]";
  }

  return msg;
}
//##------------------------------------------------------------------- 
// #FUNCIÓN: StrGetFront
// #CARACTERÍSTICAS: Devuelve el substring comprendido entre el principio
//                  del string y el separador buscado.
// #PARÁMETROS:	- mainStr: String dentro del cual buscamos.
//					             - searchStr: Separador que deseamos buscar.
// #DEVUELVE: El substring buscado, o null si no encontradmos el separador.
//##------------------------------------------------------------------- 
function StrGetFront(mainStr,searchStr) {
var foundOffset = mainStr.indexOf(searchStr);

  foundOffset = mainStr.indexOf(searchStr);
  if (foundOffset == -1) return null
  
  return mainStr.substring(0, foundOffset)
}
//##------------------------------------------------------------------- 
// #FUNCIÓN: StrGetEnd
// #CARACTERÍSTICAS: Devuelve el substring comprendido entre el separador
//                  buscado y el final de la cadena.
// #PARÁMETROS:	- mainStr: String dentro del cual buscamos.
//								- searchStr: Separador que deseamos buscar.
// #DEVUELVE: El substring buscado, o null si no encontramos el separador.
//##------------------------------------------------------------------- 
function StrGetEnd(mainStr,searchStr) {
var foundOffset;

  foundOffset = mainStr.indexOf(searchStr);
  if (foundOffset == -1) return null
  
  return mainStr.substring(foundOffset+searchStr.length,mainStr.length)
}

//##----------------------------------------------------------------- 
// #FUNCIÓN: TryFocus
// #CARACTERÍSTICAS: Intenta dar el foco al elemento pasado por 
//    parámetro. Si no se puede no se hace nada. Nos previene de
//    posibles errores (objeto oculto, no existe...)
// #PARÁMETROS: 
//    - obj: Objeto al cual vamos a intentar dar el foco.
//##----------------------------------------------------------------- 
function TryFocus(obj) {

  try {
    // Intentamos dar el foco al elemento
    obj.focus();
  }
  catch (exception) {
    // Si hay algún error no hacemos nada
    ;
  }

  return;
}
//##------------------------------------------------------------------- 
// #FUNCIÓN: MaximizaBrowser
// #CARACTERÍSTICAS: Maximiza la ventana del browser 
//  v1.2: y pone el frame desde el que se llamó la función como 
// la URL principal del navegador (frame-busting)
// #VERSIÓN: 1.2
//##------------------------------------------------------------------- 
function MaximizaBrowser(){
	//v1.2--
	if (top.location != self.location) top.location = self.location.href
	// -------
	top.window.moveTo(0,0);
	if (document.all) {
		top.window.resizeTo(screen.availWidth,screen.availHeight);
	}
	else if (document.layers||document.getElementById) {
		if (top.window.outerHeight<screen.availHeight||top.window.outerWidth<screen.availWidth){
			top.window.outerHeight = screen.availHeight;
			top.window.outerWidth = screen.availWidth;
		}
	}
}
//##----------------------------------------------------------------------------
// #FUNCIÓN: StrCalcularDC
// #CARACTERÍSTICAS: Calcula el Dígito de Control de una cuenta bancaria
//    determinada.
// #PARÁMETROS: 
//    - strBanco: Código del banco
//    - strSucursal: Código de la sucursal
//    - strCuenta: Código de la cuenta bancaria
// #DEVUELVE: Dígito de Control correspondiente (2 dígitos)
// #OBSERVACIONES: Adaptación a JavaScript de la función de Visual Basic.
//##----------------------------------------------------------------------------
function StrCalcularDC(strBanco, strSucursal, strCuenta) {
var AcumEnt, AcumSuc, AcumCuenta;
var Total, Total_Res;
var DC;

  AcumEnt = 0;
  AcumEnt += parseInt(strBanco.substr(0,1), 10) * 4;
  AcumEnt += parseInt(strBanco.substr(1,1), 10) * 8;
  AcumEnt += parseInt(strBanco.substr(2,1), 10) * 5;
  AcumEnt += parseInt(strBanco.substr(3,1), 10) * 10;

  AcumSuc = 0;
  AcumSuc += parseInt(strSucursal.substr(0,1), 10) * 9;
  AcumSuc += parseInt(strSucursal.substr(1,1), 10) * 7
  AcumSuc += parseInt(strSucursal.substr(2,1), 10) * 3
  AcumSuc += parseInt(strSucursal.substr(3,1), 10) * 6

  Total = AcumEnt + AcumSuc;
  Total_Res = Total % 11;
  if (Total_Res == 1) DC = "1";
  else if (Total_Res == 0) DC = "0";
  else DC = String(11-Total_Res);

  AcumCuenta = 0;
  AcumCuenta += parseInt(strCuenta.substr(0,1), 10);
  AcumCuenta += parseInt(strCuenta.substr(1,1), 10) * 2;
  AcumCuenta += parseInt(strCuenta.substr(2,1), 10) * 4;
  AcumCuenta += parseInt(strCuenta.substr(3,1), 10) * 8;
  AcumCuenta += parseInt(strCuenta.substr(4,1), 10) * 5;
  AcumCuenta += parseInt(strCuenta.substr(5,1), 10) * 10;
  AcumCuenta += parseInt(strCuenta.substr(6,1), 10) * 9;
  AcumCuenta += parseInt(strCuenta.substr(7,1), 10) * 7;
  AcumCuenta += parseInt(strCuenta.substr(8,1), 10) * 3;
  AcumCuenta += parseInt(strCuenta.substr(9,1), 10) * 6;

  Total = AcumCuenta;
  Total_Res = Total % 11;
  if (Total_Res == 1) DC += "1";
  else if (Total_Res == 0) DC += "0";
  else DC += String(11-Total_Res);

  // Devolvemos el dígito de control calculado
  return DC;
}

//##------------------------------------------------------------------- 
// #FUNCIÓN: BValidaNumeroOnPress
// #CARACTERÍSTICAS: Comprueba que el valor introducido sea un número 
//    con las características indicadas.
// #PARÁMETROS: 
//    - obj: Input que contiene el valor a comprobar.
//    - bNegativo: Valor booleano que con true permite el símbolo '-' 
//        como primer caracter.
//    - nDec: Número de decimales que vamos a permitir (< 0 para indicar 
//        que pueden ser infinitos).
// #DEVUELVE: Valor booleano que indica si la tecla pulsada es correcta.
//    (Sirve para evitar que se escriba la letra -> Evento onKeyDown).
// #OBSERVACIONES (!!!IMPORTANTE!!!): 
//    La llamada se debe realizar en los eventos onKeyDown, onClick y onFocus. 
//    Esto es debido a que necesitamos saber la posición del cursor en cada 
//    instante dentro del INPUT. Por desgracia JScript no permite saber este 
//    valor por lo que hay que hacerlo a 'pelo'. Por lo tanto necesitamos saber
//    cuando se entra en el INPUT para realizar la inicialización de la variable 
//    que almacena la posición del cursor.
//    ESTO SERÍA MÁS SENCILLO SI PODEMOS OBTENER LA POSICIÓN DEL CURSOR A LA 
//    HORA DE APRETAR LA TECLA.
//##------------------------------------------------------------------- 
function BValidaNumeroOnPress(obj, bNegativo, nDec){
var posComa;

  // Controlamos el evento que provocó la llamada...
  if ( (event.type == "click") || (event.type == "focus") ) {
    // Seleccionamos el texto e inicializamos la posición del cursor
    obj.select();
    posCursor = -1;
    return true;
  }
  
  // Hemos pulsado una tecla...
  
  // PULSAMOS '<-'...
  if (event.keyCode == 37) {
    if (posCursor == -1) posCursor = 0;
    if (posCursor > 0) posCursor--;
    return true;
  }
  // PULSAMOS '->'...
  if (event.keyCode == 39) {
    if (posCursor == -1) posCursor = obj.value.length;
    if (posCursor < obj.value.length) posCursor++;
    return true;
  }
  // PULSAMOS 'Inicio'...
  if (event.keyCode == 36 ) {
    posCursor = 0;
    return true;
  } 
  // PULSAMOS 'Fin'...
  if (event.keyCode == 35) {
    posCursor = obj.value.length;
    return true;
  }
  // PULSAMOS 'Supr'...
  if (event.keyCode == 46) {
    if (posCursor == -1) posCursor = 0;
    return true;
  }
  // PULSAMOS 'Del'...
  if (event.keyCode == 8) {
    if (posCursor == -1) posCursor = 0;
    if (posCursor > 0) posCursor--;
    return true;
  }
  // PULSAMOS 'Tab'...
  if (event.keyCode == 9) return true;
  // PULSAMOS 'Enter'...
  if (event.keyCode == 13) return true;
  
  // PULSAMOS '-'...
  if ( (event.keyCode == 189) || (event.keyCode == 109)) {
    if (posCursor == -1) {
      if (bNegativo) {
        posCursor = 1;
        return true;
      }
    }
    else {
      // Permitimos el '-' si estamos con números negativos y estamos con el cursor en la posición 0 (y no haya ya un '-')
      if ( (bNegativo) && (posCursor == 0) && (obj.value.indexOf("-") == -1) ) {
        posCursor++;
        return true;
      }
    }
  }
  // PULSAMOS ',' o '.'...
  else if ( (event.keyCode  == 188) || (event.keyCode  == 190) || (event.keyCode == 110 ) ) {
    if (posCursor == -1) {
      if (nDec != 0) {
        posCursor = 1;
        return true;
      }
    }
    else {
      // Permitimos la coma si estamos con números decimales y no tenemos coma
      posComa = obj.value.indexOf(".");
      if (posComa == -1) posComa = obj.value.indexOf(",");
      if ( (posComa == -1) && ( (nDec < 0) || ( (nDec > 0) && (obj.value.length - posCursor -1 < nDec) ) ) ) {
        posCursor++;
        return true;
      }
    }
  }
  // PULSAMOS UN DÍGITO...
  else if ( ( (event.keyCode >= 48) && (event.keyCode <= 57) ) || ( (event.keyCode >= 96) && (event.keyCode <= 105) ) ) {
    if (posCursor == -1) {
      posCursor = 1;
      return true;
    }
    else {
      // Si estamos en la primera posición y hay un signo '-', no permitimos el dígito...
      if ( (posCursor == 0) && (obj.value.indexOf("-") != -1)) return false;

      // Permitimos el dígito si...      
      // estamos en la parte entera o si estamos en la decimal y aún no tenemos el número de decimales adecuadosla coma si estamos con números decimales y no tenemos el número de decimales adecuado 
      posComa = obj.value.indexOf(".");
      if (posComa == -1) posComa = obj.value.indexOf(",");
      if (posComa == -1) posComa = obj.value.length;
      if ( (nDec <= 0) || ( (nDec > 0) && ( (posCursor <= posComa) || (obj.value.length - posComa -1 < nDec) ) ) ) {
        posCursor++;
        return true;
      }
    }
  }

  // Si llegamos aquí, significa que el carcater no es válido
  return false;  
}
//##------------------------------------------------------------------- 
// #FUNCIÓN: StrFormatoNumerico
// #CARACTERÍSTICAS: Pasa un número al formato especificado.
// #PARÁMETROS: 
//    - strNumber: Cadena que contiene el número al cual queremos dar formato.
//    - strFormato: Cadena que indica el formato a dar a un número.
// #DEVUELVE: La cadena formateada.
// #OBSERVACIONES: 
//    * Se supone que strNumber ya tiene un formato de número
//      (no se realiza ninguna comprobación).
//    * Si el número de enteros del número es mayor al especificado
//      en el formato, se dejan los que tenga el número.
//    * Si el número de decimales del número es mayor al especificado
//      en el formato, se redondea al valor especificado en el formato.
//    MEJORAS: Permitir dar formato a números negativos.
// #EJEMPLOS:
//    Ej: '000,00' --> Tres números enteros y dos decimales.
//		    '00'     --> Dos número enteros (si el número tiene decimales, los deja igual).
//        '00,'     --> Dos número enteros (si el número tiene tiene decimales, los redondea).
//        ',000' --> Tres números decimales (la parte entera se queda igual).
//##------------------------------------------------------------------- 
function StrFormatoNumerico(strNumber, strFormato){
var strNumber_limpio, ch;
var factor, buf;
var EnterosN, DecimalesN, nEnterosF, nDecimalesF;

  // Quitamos todos los caracteres que no sean comas, puntos o dígitos
  strNumber_Limpio = "";
  for (var i=0; i<strNumber.length; i++) {
    ch = strNumber.charAt(i);
    if ( (ch == ",") || (ch == ".") || ( (ch >= "0") && (ch <= "9") ) ) 
      strNumber_Limpio += ch;
  }
  strNumber = strNumber_Limpio;

  // Si no hay nada, salimos sin dar formato
  if (strNumber == "") return "";

  // Cambiamos los puntos por comas
  while (strNumber.indexOf(".") != -1) strNumber = strNumber.replace(".", ",");
  // Quitamos todos las comas que están después de la primera (si la hay)...
  if (strNumber.indexOf(",") != -1) {
    buf = StrGetEnd(strNumber, ",");
    while (buf.indexOf(",") != -1) buf = buf.replace(",", "");
    strNumber = StrGetFront(strNumber, ",") + "," + buf;
  }

  // Buscamos el número de enteros y decimales especificado en el número
  if (StrGetFront(strNumber, ",") == null) {
    // No se ha especificado el número de decimales
    DecimalesN = "";
    EnterosN = String(parseInt(strNumber, 10));
  } else {
    // Se ha especificado el separador decimal
    if (StrGetFront(strNumber, ",") == "") strNumber = "0" + strNumber;
    EnterosN = String(parseInt(StrGetFront(strNumber, ","), 10));
    DecimalesN = StrGetEnd(strNumber, ",");
  }

  // Buscamos el número de enteros y decimales especificado en el formato
  if (StrGetFront(strFormato, ",") == null) {
    // No se ha especificado números decimales
    nDecimalesF = 0
    nEnterosF = Math.max(strFormato.length, EnterosN.length);
  }
  else {
    // Se ha especificado el separador decimal
    nDecimalesF = StrGetEnd(strFormato, ",").length;    
    nEnterosF = Math.max(StrGetFront(strFormato, ",").length, EnterosN.length);
  }

  // Damos el formato adecuado a la parte entera...
  // Si el número de valores a poner es mayor al actual...
  if (nEnterosF > EnterosN.length) {
    // Insertamos el resto del tamaño con ceros
    buf = "";
    for (var i=0; i<(nEnterosF-EnterosN.length); i++) buf += "0";
    EnterosN = buf + EnterosN;
  }

  // Damos el formato adecuado a la parte decimal...
  if (StrGetEnd(strFormato, ",") != null) {
    // Si el número de decimales es mayor al indicado en el formato...
    if (DecimalesN.length > nDecimalesF) {
      // Redondeamos al número de decimales indicado
      factor = Math.pow(10, DecimalesN.length - nDecimalesF);
      DecimalesN = String(Math.round(eval(DecimalesN) / factor));
      // Por si acaso no queremos poner decimales (sumar a la parte entera el redondeo)...
      if (nDecimalesF == 0) {
        EnterosN = String(parseInt(EnterosN, 10) + parseInt(DecimalesN, 10));
        DecimalesN = 0;
      }
    } else {
      // El número de decimales actual es menor o igual al indicado (rellenamos el resto con ceros)
      buf = "";
      for (var i=0; i<(nDecimalesF-DecimalesN.length); i++) buf += "0";
      DecimalesN += buf;
    }
    
  }
  
  // Devolvemos la composición del número
  if (DecimalesN.length > 0) buf = EnterosN + "," + DecimalesN;
  else buf = EnterosN;
  
  return buf;
}
//##------------------------------------------------------------------------------
// #FUNCIÓN: IsLeapYear
// #CARACTERÍSTICAS: Comprueba si el año pasado es bisiesto.
// #PARÁMETROS: - anyo: Año que deseamos comprobar.
// #DEVUELVE: Valor booleano que indica si el año es bisiesto.
//##------------------------------------------------------------------------------
function IsLeapYear(anyo) {

  fin = anyo % 100;
  if (fin != 0) {
    if (fin % 4 != 0) return false;
  }
  else {
    var inicial = anyo / 100;
    if (inicial % 4 != 0)     // calendario gregoriano
	  return false;
    else
	  return true;
  }
  
  return true;
}
//##------------------------------------------------------------------------------
// #FUNCIÓN: BValidaFecha
// #CARACTERÍSTICAS: Comprueba que el formato de la fecha sea correcto. Y dentro 
//    del intervalo permitido por SQLServer
// #PARÁMETROS: 
//    - obj: Objeto que contiene los datos a comprobar.
// #OBSERVACIONES: Errores: E0024, E0106, E0907, E0908 
// #REVISIÓN: 15/06/2004
//##------------------------------------------------------------------------------
function BValidaFecha(obj) {
var len = obj.value.length;
var msg1 = StrMsg("E0106");
var msg2 = StrMsg("E0024");
var Nslash = 0;
var txtfecha = obj.value

  // El campo puede ser vacio  
  if (len == 0) return true;
  // Si no tiene barras, las introducimos
  if (txtfecha.indexOf('/') == -1) {
    obj.value = txtfecha.substr(0,2) + '/' + txtfecha.substr(2,2) + '/' + txtfecha.substr(4,len)
    txtfecha = obj.value
  }	
  // Comprobamos que la longitud sea correcta
  if ((len < 8) || (len > 10)) {
    obj.value = "";
    alert (msg1);
    obj.focus ();
    return false;
  }
  // Comprobamos que los caracteres sean dígitos y barras
  for (var i=0; i<len; i++) {
    var ch = obj.value.substring (i, i+1);
    if (ch == "/") Nslash++;
    if ( (ch < "0" || ch > "9") && (ch != "/") ) {
  	  obj.value = "";
      alert (msg1);
      obj.focus ();
      return false;
	}
  }
  // Comprobamos que sólo existan dos barras
  if (Nslash != 2) {
    obj.value = "";
    alert (msg1);
    obj.focus ();
    return false;
  }
  // Vamos a comprobar el día, comprobamos que la barra esté bien
  if ( (obj.value.indexOf ("/") > 2) || (obj.value.indexOf ("/") == 0) ) {
    obj.value = "";
    alert (msg1);
    obj.focus ();
    return false;
  } 
  var dia = 0;
  dia = StrGetFront (obj.value, "/");
  // Vamos a comprobar el mes, comprobamos que la barra esté bien
  var buf = StrGetEnd (obj.value, "/");
  if ( (buf.indexOf ("/") > 2) || (buf.indexOf ("/") == 0) ) {
    obj.value = "";
    alert (msg1);
    obj.focus ();
    return false;
  } 
  var mes = StrGetFront (buf, "/");
  var anyo = StrGetEnd (buf, "/");
  // Comprobamos que el año tenga 4 dígitos
  if (anyo.length != 4) {
    obj.value = "";
    alert(msg1);
    obj.focus ();
    return false;
  }
  // Comprobamos que los valores de dia y mes sean correctos
  if ((parseFloat (mes) > 12) || (parseFloat (dia) > 31)) {
    obj.value = "";
    alert(msg2);
    obj.focus ();
    return false;
  }  
  // Comprobamos los meses especiales
  if (parseFloat (mes) == 2) {
    if (IsLeapYear(parseFloat(anyo))) {
	  if (parseFloat(dia) > 29) {
	    obj.value = "";
	    alert (msg2);
	    obj.focus ();
	    return false;
	  }
	}else { 
      if (parseFloat(dia) > 28) {
	    obj.value = "";
	    alert (msg2);
	    obj.focus ();
	    return false;
	  }
	}
  }else 
    if ( ((mes == 4) || (mes == 6) || (mes == 9) || (mes == 11)) && (dia == 31) ) {
	  obj.value = "";
      alert (msg2);
	  obj.focus ();
	  return false;
    }
  
  // Insertamos los ceros adecuados al día y al mes    
  if ((parseFloat (dia) < 10) && (dia.length==1)) dia = "0" + dia;
  if ((parseFloat (mes) < 10) && (mes.length==1)) mes = "0" + mes;
  
  // Mostramos la fecha en el formato correcto
  obj.value = dia + "/" + mes + "/" + anyo;

	//Añadimos comprobación de error por salida de rango en SQL
  if (obj.value.substr(6, 4) + obj.value.substr(3, 2) + obj.value.substr(0, 2) > '20790606'){alert(StrMsg("E0908").replace( /#Fintro#/gi, obj.value)); obj.value= ''; obj.focus(); return false}
  if (obj.value.substr(6, 4) + obj.value.substr(3, 2) + obj.value.substr(0, 2) < '19000101'){alert(StrMsg("E0907").replace( /#Fintro#/gi, obj.value)); obj.value= ''; obj.focus(); return false}
  
  return true;
}
//##------------------------------------------------------------------------------
// #FUNCIÓN: BValidaFechaEfecto
// #CARACTERÍSTICAS: Comprueba que el formato de la fecha de efecto sea correcto.
// #PARÁMETROS: - obj: Objeto que contiene los datos a comprobar.
// #OBSERVACIONES: Errores: E0024, E0118
//##------------------------------------------------------------------------------
function BValidaFechaEfecto(obj) {
var len = obj.value.length;
var msg1 = StrMsg("E0118");
var msg2 = StrMsg("E0024");
var Nslash = 0;
var txtfecha = obj.value

  // El campo puede ser vacio  
  if (len == 0) return true;
  // Si no tiene barras, las introducimos
  if (txtfecha.indexOf('/') == -1) {
    obj.value = txtfecha.substr(0,2) + '/' + txtfecha.substr(2,len)
    txtfecha = obj.value
  }	

  // Comprobamos que la longitud sea correcta
  if ((len < 6) || (len > 7)) {
    alert (msg1);
    obj.value = "";
    obj.focus ();
    return false;
  }
  // Comprobamos que los caracteres sean dígitos y barras
  for (var i=0; i<len; i++) {
    var ch = obj.value.substring (i, i+1);
    if (ch == "/") Nslash++;
    if ( (ch < "0" || ch > "9") && (ch != "/") ) {
      alert (msg1);
	    obj.value = "";
      obj.focus ();
      return false;
    }
  }
  // Comprobamos que sólo exista una barra
  if (Nslash != 1) {
    alert (msg1);
    obj.value = "";
    obj.focus ();
    return false;
  }
  // Vamos a comprobar el mes, comprobamos que la barra esté bien
  var buf = obj.value;
  if ( (buf.indexOf ("/") > 2) || (buf.indexOf ("/") == 0) ) {
    alert (msg1);
    obj.value = "";
    obj.focus ();
    return false;
  } 
  var mes = StrGetFront (buf, "/");
  var anyo = StrGetEnd (buf, "/");
  // Comprobamos que el año tenga 4 dígitos
  if (anyo.length != 4) {
    alert(msg1);
    obj.value = "";
    obj.focus ();
    return false;
  }
  // Comprobamos que el valor del mes sea correcto
  if (parseFloat(mes, 10) > 12) {
    alert(msg2);
    obj.value = "";
    obj.focus ();
    return false;
  }  
  
  // Insertamos los ceros adecuados al mes    
  if ((parseFloat(mes, 10) < 10) && (mes.length==1)) mes = "0" + mes;
  
  // Mostramos la fecha de efecto en el formato correcto
  obj.value = mes + "/" + anyo;
  
  return true;
}
//##------------------------------------------------------------------------------
// #FUNCIÓN: BComprobarFechas
// #CARACTERÍSTICAS: Comprueba que la primera fecha no sea mayor que la segunda.
// #PARÁMETROS:	- Fecha1: Primera fecha.
//								- Fecha2: Segunda fecha
// #OBSERVACIONES: 
//					-Se supone que las fechas ya tienen el formato correcto.
//					Errores: E0604
//					
// #VERSIÓN: 1.0
// #REVISIÓN: 01/12/2005
//##------------------------------------------------------------------------------
function BComprobarFechas(Fecha1, Fecha2, optRequired) { 
	var msg = StrMsg("E0604");
	if (Fecha1.value.length > 0 && Fecha2.value.length > 0){
		// Obtenemos los datos de la primera fecha
		var txtFecha = Fecha1.value
		var diaIni = txtFecha.substr(0,2);
		var mesIni = txtFecha.substr(3,2);
		var anyoIni = txtFecha.substr(6,txtFecha.length);
		// Obtenemos los datos de la segunda fecha
		var txtFecha = Fecha2.value
		var diaFin = txtFecha.substr(0,2);
		var mesFin = txtFecha.substr(3,2);
		var anyoFin = txtFecha.substr(6,txtFecha.length);
		// Comprobamos si la segunda fecha es mayor
		if (anyoIni > anyoFin){
			alert(msg);
			Fecha1.focus ();
			Fecha1.select ();
			return false;
		}else{
			if (mesIni > mesFin){
				alert(msg);
				Fecha1.focus ();
				Fecha1.select ();
				return false;
			}else{
				if (diaIni > diaFin){
					alert(msg);
					Fecha1.focus ();
					Fecha1.select ();
					return false;
				}
			}
		}
	  
		return true;
	}else{
		if (optRequired != null && optRequired != false){
			if (Fecha1.value.length == 0 && Fecha2.value.length == 0){
				alert(StrMsg("E0244"));
				Fecha1.focus ();
				Fecha1.select ();
			}else{
				if (Fecha1.value.length == 0){
					alert(StrMsg("E0210"));
					Fecha1.focus ();
					Fecha1.select ();
				}else{
					alert(StrMsg("E0211"));
					Fecha2.focus ();
					Fecha2.select ();
				}
			}
			return false;
		}
		return true;
	}
}
//##------------------------------------------------------------------------------
// #FUNCIÓN: LimitaTextBox
// #CARACTERÍSTICAS: Limita un textarea a una longitud determinada
// #PARÁMETROS: - element:El campo a evaluar
//        - maxvalue:el valor máximo
// #OBSERVACIONES: Esta función se utiliza para controlar el tamaño máximo de
//       un textarea asociado a un campo de tipo Char[x] o VarChar[x]
//       muy grande. Debería utilizarse como campo contenedor un
//       input type TEXT, pero si se exige un TEXTAREA, esta función
//       lo limitará al tamaño deseado
//       *El mensaje no es estándar.
// #DEVUELVE: Un mensaje indicando el nº de caracteres a borrar
//##------------------------------------------------------------------------------
function LimitaTextBox(element, maxvalue) {
	var q = element.value.length;
	var r = q - maxvalue;
	var msg = "Error: campo muy largo.\nEste campo solo admite " + maxvalue + " caracteres.\nPor favor, elimine " + "por lo menos "+r+" caracteres";
	if (q > maxvalue) {
		alert(msg);
		return false;
	}
}

//*******************************************************************
// FUNCIONES PARA LA IDENTIFICACIÓN DE USUARIOS: NIF/TR/CIF
// - BEsNumero(...)
// - BEsLetra(...)
// - StrLetraIdentificacion(...)
// - BComprobarNIFNIE(...)
// - BFormatoNIFNIE(...)
// - BCompruebaLetraCIF(...)
// - BComprobarCIF(...)
// - BFormatoCIF(...)
// - BEsNIFNIE(...)
// - BEsCIF(...)
// - BEsIdentificacion(...)
//*******************************************************************


//##--------------------------------------------------------------------
// #FUNCIÓN: BEsNumero
// #CARACTERÍSTICAS: Comprueba si el texto pasado se corresponde a un número.
// #PARÁMETROS: 
//    - str: cadena que queremos comprobar si es un número.
//##--------------------------------------------------------------------
function BEsNumero(str) {
var b;

  // Comprobamos si cada caracter es un dígito...
  b = true;
  for (var i=0; i<str.length; i++) {
    if ( (str.charAt(i) < "0") || (str.charAt(i) > "9") ) {
      b = false;
      i = str.length;
    }
  }
  
  return (b);  
}
//##--------------------------------------------------------------------
// #FUNCIÓN: BEsLetra
// #CARACTERÍSTICAS: Comprueba si el texto pasado se corresponde a una letra.
// #PARÁMETROS: 
//    - str: caracter que queremos comprobar si es una letra.
//##--------------------------------------------------------------------
function BEsLetra(str) {

  if ( (str >= "A") && (str <= "Z") ) return true;
  else return false;
  
}
//##--------------------------------------------------------------------
// #FUNCIÓN: StrLetraIdentificacion
// #CARACTERÍSTICAS: Calcula la letra de un NIF o TR.
// #PARÁMETROS: 
//    - strNumber: Numero para el cual vamos a obtener la letra.
// #DEVUELVE: La letra adecuada o false si hubo error.
//##--------------------------------------------------------------------
function StrLetraIdentificacion(strNumber) {
var a, N;

  if (BEsNumero(strNumber)) {
    N = Number(strNumber);
    a = "TRWAGMYFPDXBNJZSQVHLCKE".substr((N%23), 1);
  }
  else
    a = false;
    
  return a; 
}
//##--------------------------------------------------------------------
// #FUNCIÓN: BComprobarNIFNIE
// #CARACTERÍSTICAS: Comprueba si el parámetro pasado es un NIF/TR.
// #PARÁMETROS: 
//    - strNIF: Texto que debemos comprobar si es NIF/TR.
//    - bIdentificacion: Variable booleana que indica que si 
//        estamos comprobando un NIF/TR o se trata de una
//        identificación. Es importante para dar el mensaje
//        adecuado.
// #DEVUELVE: Valor booleano que indica si el número es correcto.
// #OBSERVACIONES: Errores: E0025 --> si bIdentificacion = true
//                          E0017 --> si bIdentificacion = false
//##--------------------------------------------------------------------
function BComprobarNIFNIE(strNIF, bIdentificacion) {
var msgIdent = StrMsg("E0025");
var msgNIFNIE = StrMsg("E0017");
var LetraReal, letraInicio, letraFin, cadena;

  // Obtenemos la letra inicial y final del NIF/NIE
  letraInicio = strNIF.substr(0, 1);
  letraFin = strNIF.substr(8, 1);
  // Comprobamos si se trata de un NIF o de NIE
  cadena = "";
  if ( (letraInicio == "X") && (BEsLetra(letraFin)) ) {
    // es una tarjeta de residencia, examinamos la cadena sin la 'X'
    cadena = strNIF.substr(1, 8);
  }
  else if ( (BEsNumero(letraInicio)) && (BEsLetra(letraFin)) ) {
    // es un NIF, examinamos la cadena completa
    cadena = strNIF
  }
  
  // Si es un NIF o una TR...
  if (cadena != "") {
    // Cogemos la letra de identificación actual y la que debería ser
    LetraReal = StrLetraIdentificacion(cadena.substring(0, cadena.length-1));
    // Si son distintas, la letra del NIF/TR no es correcta
    if (letraFin != LetraReal) {
      if (bIdentificacion) alert(msgIdent);
      else alert(msgNIFNIE);
      return false;
    }
    else return true;
  }

  return false;
}  
//##--------------------------------------------------------------------
// #FUNCIÓN: BFormatoNIFNIE
// #CARACTERÍSTICAS: Comprueba si el texto tiene el formato de un NIF/TR.
// #PARÁMETROS: 
//    - strNIFNIE: Cadena que tiene el texto a comprobar.
//    - bMostrar: Indica si se debe dar el mensaje de error
//        de formato del NIF/TR. Es util para poder utilizar
//        esta función desde bEsIdentificación(...)
// #DEVUELVE: Valor booleano que indica si el formato es correcto.
// #OBSERVACIONES: Errores: E0101 --> si bMostrar = true
//##--------------------------------------------------------------------
function BFormatoNIFNIE(strNIFNIE, bMostrar) {
var msg = StrMsg("E0101");
var letra, letraI, bNIFNIE;

  // Debe tener 9 caracteres...
  if (strNIFNIE.length == 9) {
    // Obtenemos el primer y último caracter...
    letraI = strNIFNIE.substr(0, 1).toUpperCase();
    letra = strNIFNIE.substr(8, 1).toUpperCase();

    if (!BEsLetra(letra)) // Siempre una letra al final
      bNIFNIE = false;
    else if ( (letraI == "X") && (BEsNumero(strNIFNIE.substr(1, 7))) ) // NIE
      bNIFNIE = true;
    else if (BEsNumero(strNIFNIE.substr(0, 8)))  // NIF 
      bNIFNIE = true;
    else
      bNIFNIE = false;
  }
  else
    bNIFNIE = false;
  
  // Si no tiene el formato adecuado y debemos mostrar el mensaje...
  if ( (!bNIFNIE) && (bMostrar) ) alert(msg);
  
  return bNIFNIE;
}
//##--------------------------------------------------------------------
// #FUNCIÓN: BCompruebaLetraCIF
// #CARACTERÍSTICAS: Comprueba si la letra del CIF es correcta.
// #PARÁMETROS: 
//    - strCIF: String que contiene el CIF a comprobar.
// #DEVUELVE: Variable booleana que indica si el CIF es correcto.
//##--------------------------------------------------------------------
function BCompruebaLetraCIF(strCIF) {
var sumaP, i, sumaI, producto, control;

  sumaP = parseInt(strCIF.charAt(2), 10) + parseInt(strCIF.charAt(4), 10) + parseInt(strCIF.charAt(6), 10);
  sumaI = 0;
  for (var i=1; i<=8; i=i+2) {
    producto = parseInt(strCIF.charAt(i), 10) * 2;
    if (producto < 10)
      sumaI += producto;
    else 
      sumaI += parseInt(String(producto).charAt(0), 10) + parseInt(String(producto).charAt(1), 10);
  }
 
  control = 10 - ((sumaP + sumaI) % 10);
  
  if (BEsNumero(strCIF.substr(8, 1))) {
    if (control == parseInt(strCIF.substr(8, 1), 10)) return true;
    else return false;
  }
  else { // Es una letra
    if ("JABCDEFGHI".charAt(control) == strCIF.substr(8, 1)) return true;
    else return false;
  }
   
  return;  
}
//##--------------------------------------------------------------------
// #FUNCIÓN: BComprobarCIF
// #CARACTERÍSTICAS: Comprueba si el texto tiene formato CIF correcto.
// #PARÁMETROS: 
//    - strCIF: String que contiene el CIF a comprobar.
//    - bIdentificacion: Variable booleana que indica que si 
//        estamos comprobando un CIF o se trata de una
//        identificación. Es importante para dar el mensaje
//        adecuado.
// #DEVUELVE: Valor booleano que indica si el CIF es correcto.
// #OBSERVACIONES: Errores: E0025 --> si bIdentificacion = true
//                         E0023 --> si bIdentificacion = false
//	Los campos versión y revisión se añaden para proponer esta función
//		como prototipo de comentarios correctos para utilParser
// #VERSIÓN: 1.2.088.0
// #REVISIÓN: 07/04/2003
// #EJEMPLOS: onclick="BComprobarCIF(a.Value, true)"
//##--------------------------------------------------------------------
function BComprobarCIF(strCIF, bIdentificacion) {
var msgIdent = StrMsg("E0025");
var msgCIF = StrMsg("E0023");
var letraInicio, letraFin, bCCIF;

  // Obtenemos la letra de inicio, fin y el valor de la letra de inicio
  letraInicio = strCIF.substr(0, 1);
  letraFin = strCIF.substr(7, 1);

  // Si la letra de inicio es correcta ...
  if ( ((letraInicio >= "A") && (letraInicio <= "H")) || (letraInicio == "P") || (letraInicio == "Q") || (letraInicio == "S") ) {
    // Si el interior es un número...
    if (BEsNumero(strCIF.substr(1, 7))) {
      // Comprobamos que la letra sea la correcta
      bCCIF = BCompruebaLetraCIF(strCIF);
    }
    else bCCIF = false;
  }
  else  //El primer caracter no corresponde con las letras admitidas
    bCCIF = false;

  // Mostramos el mensaje adecuado, si se lo hemos indicado
  if (!bCCIF) {
    if (bIdentificacion) alert(msgIdent);
    else alert(msgCIF);
  }

  return bCCIF;
}
//##--------------------------------------------------------------------
// #FUNCIÓN: BFormatoCIF
// #CARACTERÍSTICAS: Comprueba si el texto tiene formato CIF.
// #PARÁMETROS: 
//    - strCIF: Objeto que tiene el texto a comprobar.
//    - bMostrar: Indica si se debe dar el mensaje de error
//        de formato del CIF. Es util para poder utilizar
//        esta función desde bEsIdentificación(...)
// #DEVUELVE: Valor booleano que indica si el formato es correcto.
// #OBSERVACIONES: Errores: E0102 --> si bMostrar = true
//##--------------------------------------------------------------------
function BFormatoCIF(strCIF, bMostrar) {
var msg = StrMsg("E0102");
var letra, letraF, bFCIF;

  bFCIF = false;
  // Comprobamos que tenga nueve caracteres...
  if (strCIF.length == 9) {
    // Obtenemos el primer y último caracter
    letra = strCIF.substr(0, 1).toUpperCase(); 
    letraF = strCIF.substr(8, 1).toUpperCase();
    // Comprobamos que el primer carácter es una letra (siempre)
    if (BEsLetra(letra)) {
      // El resto debe ser...
      // 7 dígitos + 1 letra
      if ( (BEsNumero(strCIF.substr(1, 7))) && (BEsLetra(letraF)) )
        bFCIF = true;
      // o 8 dígitos
      else if (BEsNumero(strCIF.substr(1, 8)))
        bFCIF = true;
      // Sino, el formato es incorrecto
    }
  }

  // Mostramos el mensaje adecuado en caso de error (si queremos que se muestre)  
  if ( (!bFCIF) && (bMostrar) ) alert(msg);
  
  return bFCIF;  
}
//##--------------------------------------------------------------------
// #FUNCIÓN: BEsNIFNIE
// #CARACTERÍSTICAS: Comprueba si el objeto tiene el formato NIF/TR y si
//    este es correcto.
// #PARÁMETROS: 
//    - obj: Objeto que tiene el texto a comprobar.
//    - bMostrar: Variable booleana que indica que se quiere que se
//        muestren los mensajes asociados.
// #DEVUELVE: Valor booleana que indica si el NIF/TR es correcto.
// #OBSERVACIONES: ERRORES (heredados): 'E0101', 'E0017'.
//##--------------------------------------------------------------------
function BEsNIFNIE(obj) {
var OK;
  
  OK = true;
  obj.value = obj.value.toUpperCase();
  if (obj.value.length > 0) {
    // Si el formato es correcto...
    if (BFormatoNIFNIE(obj.value, true)) {
      // Si realmente es un NIF/TR válido...
      if (!BComprobarNIFNIE(obj.value, false)) OK = false;
    }
    else OK = false;
  }
  
  // Si el valor no es válido...
  if (!OK) {
    // Limpiamos el campo
    obj.value = "";
    obj.focus();
  }
  
  return OK;
}
//##--------------------------------------------------------------------
// #FUNCIÓN: BEsCIF
// #CARACTERÍSTICAS: Comprueba si el texto tiene formato CIF y si es CIF.
// #PARÁMETROS: 
//    - obj: Objeto que tiene el texto a comprobar.
// #DEVUELVE: Variable booleana que indica si el CIF es totalmente correcto.
// #OBSERVACIONES: ERRORES (heredados): 'E0102', 'E0023'.
///##--------------------------------------------------------------------
function BEsCIF(obj) {
var OK;

  OK = true;
  obj.value = obj.value.toUpperCase();
  // Si hemos introducido algún valor...
  if (obj.value.length > 0) {
    // Si tenemos el formato correcto...
    if (BFormatoCIF(obj.value, true)) {
      // Si el CIF es correcto...
      if (!BComprobarCIF(obj.value, false)) OK = false;
    }
    else OK = false;
  }

  // Si el valor no es correcto...
  if (!OK) {
    obj.value = "";
    obj.focus();
  }
  
  return OK;
}
//##--------------------------------------------------------------------
// #FUNCIÓN: BEsIdentificacion
// #CARACTERÍSTICAS: Comprueba que el string contenido en el objeto tiene
//                  una identificación adecuada: CIF, NIF o TR.
// #PARÁMETROS: 
//    - obj: Objeto que tiene el texto a comprobar.
// #DEVUELVE: Variable booleana que indica si es una identificación.
// #OBSERVACIONES: ERRORES : 'E0103'
//              (heredados): 'E0025'.
//##--------------------------------------------------------------------
function BEsIdentificacion(obj) {
var msg = StrMsg("E0103");
var OK;

  OK = true;
  obj.value = obj.value.toUpperCase();
  // Si hemos introducido algún valor...
  if (obj.value.length > 0) {  
    // Si tenemos formato de CIF (no mostramos sus mensajes)...
    if (BFormatoCIF(obj.value, false)) {
      // Comprobamos si el CIF es correcto...
      if (!BComprobarCIF(obj.value, true)) OK = false;
    }
    // Si tenemos formato de NIF/TR (no mostramos sus mensajes)...
    else if (BFormatoNIFNIE(obj.value, false)) {
      // Comprobamos si el NIF/TR es correcto...
      if (!BComprobarNIFNIE(obj.value, true)) OK = false;
    }
    // El valor introducido no concuerda con ninguno...
    else {
      alert(msg);
      OK = false;
    }
  }
  
  // Si hay algún error...
  if (!OK) {
    obj.value = "";
    obj.focus();
  }      

  return OK;
}
//##--------------------------------------------------------------------
// #FUNCIÓN: LTrim
// #CARACTERÍSTICAS: Elimina los espacios iniciales de una cadena
// #PARÁMETROS: 
//    - value: texto a procesar.
//##--------------------------------------------------------------------
function LTrim( value ) {
	
	var re = /\s*((\S+\s*)*)/;
	return value.replace(re, "$1");
	
}
//##--------------------------------------------------------------------
// #FUNCIÓN: RTrim
// #CARACTERÍSTICAS: Elimina los espacios finales de una cadena
// #PARÁMETROS: 
//    - value: texto a procesar.
//##--------------------------------------------------------------------
function RTrim( value ) {
	
	var re = /((\s*\S+)*)\s*/;
	return value.replace(re, "$1");
	
}
//##--------------------------------------------------------------------
// #FUNCIÓN: trim
// #CARACTERÍSTICAS: Elimina los espacios iniciales y finales de una cadena
// #PARÁMETROS: 
//    - value: texto a procesar.
//##--------------------------------------------------------------------
function Trim( value ) {
	
	return LTrim(RTrim(value));
	
}