/**************************************************************************/
/***																	***/
/***   Autor:  Ignacio Jimenez Navarro									***/
/***   Fecha creacion: 24/09/99											***/
/***   Proyecto: INNOVATEL												***/
/***																	***/
/***   Contenido del fichero biblioteca.js:								***/
/***	 Este fichero contiene varias funciones utilizadas en la 		***/
/***	 validación de la información introducida en formularios HTML   ***/
/***	Conviene usarlas como complemento a las ya predefinidas			***/
/***       por el propio JavaScript				       					 ***/
/**************************************************************************/
/**************************************************************************

		SUMARIO:

		1.-  error(num,campo)
		2.-  quitar_blancos(campo)
		3.-  campo_no_vacio(campo)
		4.-  sustituir_caracter(campo,car_in,car_out)
		5.-  completar_info(campo,longit,car)
		6.-  es_numerico(campo)
		7.-  es_alfabetico(campo)
		8.-  es_alfanumerico(campo)
		9.-  es_real(campo)
		10.-  limites(valor, minimo, maximo)
		11.- email_ok(campo)
		12.- CrearArray()
		13.- MakeArray(n,val)
		14.- soporta_DHTML()
		15.- nueva_ventana(campo,ancho,alto)
		(16.- fechavalida(fecha)--> obsoleta!!!)
		17.- es_bisiesto(campo)
		18.- mayor_de_edad(fechanac)
		19.- gettheDate()
		20.- showtime(timerRunning, timerID)
		21.- stopclock(timerRunning, timerID)
		22.- startclock()
		23.- validarnumreal(Campo, NumDecimales, ValorMin, ValorMax)
		24.- telefono_OK(campo)
		25.- fechavalida2(fecha)
		26.- checkSoloLectura(unCheck)
		27.- compruebaFechas(fecha1,fecha2)
		28.- codigoPostalValido(listaProvincias, codPostal)
		29.- sugiereCodigoPostal(listaProvincias, codPostal)
		30.- tiene_tlf_long9(campo)
		31.- redondear(Campo,decimales)
		32.- comprobarMillares(valor)
		33.- cambiarDecimal(valor)
		34.- checkDecimals(textFied, value, nDecimales)
		35.- equalsIgnoreCase(string1,string2)
Y de una librería externa se añaden las siguinetes funciones para validar fechas:
				   fechavalida2
                   CompruebaFechaOpcional
                   fechaOK
                   separardia
                   separarmes
                   leftPad

**************************************************************************/

/**************************************************************************

		ERRORES

**************************************************************************/
/* 1.- Funcion: error(num,campo)
   Objetivo: Saca un alert por pantalla, mostrando un mensaje de error
   Entrada: Un número que indica el mensaje a mostrarse, y la posición donde se produce el error
	     y en la que se colocará parpadeante el cursor
   Salida:   El alert con el mensaje 						 */

function error(num,campo)
{
switch (num) {

	case 1: alert("Introduzca correctamente el mes");
		campo.focus();campo.select();
		break;
	case 2: alert("Introduzca correctamente el día del mes");
		campo.focus();campo.select();
		break;
	case 3: alert("Febrero no puede tener más de 29 dias");
		campo.focus();campo.select();
		break;
	case 4: alert("Abril, junio, septiembre y noviembre sólo tienen 30 días");
		campo.focus();campo.select();
		break;
	case 5: alert("El campo está vacío o contiene solamente blancos");
		campo.focus();campo.select();
		break;
	case 6: alert("Introduzca sólo números");
		campo.focus();campo.select();
		break;
	case 7: alert("Las fechas deben tener 8 digitos");
		campo.focus();campo.select();
		break;
	case 8: alert("No eres mayor de edad!!");
		campo.focus();campo.select();
		break;
	case 9: alert("Introduzca sólo caracteres alfabéticos");
		campo.focus();campo.select();
		break;
	/*case 10: alert("Introduzca 10 caracteres para el nombre");
		campo.focus();campo.select();
		break;	*/
	case 11: alert("Introduzca sólo caracteres alfanuméricos");
		campo.focus();campo.select();
		break;
	case 12: alert("Ese año no fue bisiesto");
		campo.focus();campo.select();
		break;
	case 13: alert("Dirección de e-mail no válida");
		campo.focus();campo.select();
		break;
	case 14: alert("Formato de Fecha incorrecto. Formato obligatorio dd/mm/aaaa.");
		campo.focus();campo.select();
		break;
	case 15: alert("Fechas incorrectas. Fecha Posterior menor que la Anterior ");
		campo.focus;campo.select();
		break;
	case 16: alert("El número de teléfono debe tener 9 cifras");
		campo.focus;campo.select();
		break;
	case 17: alert("El año debe ser igual o posterior a 1998");
		campo.focus;campo.select();
		break;
	case 18: alert("El número de teléfono debe empezar por 8 o 9");
		campo.focus;campo.select();
		break;
	case 19: alert("El número de teléfono debe tener 9 cifras");
		campo.focus;campo.select();
		break;
	case 20: alert("La fecha introducida es posterior a la fecha actual");
		campo.focus;campo.select();
		break;
	case 21: alert("La fecha introducida no puede ser anterior a la fecha actual");
		campo.focus;campo.select();
		break;
	default: alert("Todo OK");
		break;
	}
}

/**************************************************************************

		VALIDACIONES

**************************************************************************/
/**************************************************************************/
/* 2.- Funcion: quitar_blancos(campo)
   Objetivo: Elimina los blancos iniciales y finales del campo de un formulario,
   			 y en caso de que la cadena tuviera varios blancos separando sus palabras,
			 dejaria un unico blanco de separacion entre ellas
   Entrada: El campo del formulario a testear
   Salida:  La cadena una vez modificada						 */

function quitar_blancos(campo)
{
var textocon=campo.value;
var textosin="";
var longit = textocon.length;
for (var i=0;i<longit;i++)
	{
	var letra = textocon.charAt(i);
	if (letra != " ")
		textosin = textosin + letra;
	else
		if (textocon.charAt(i+1) != " ")
			textosin=textosin + letra;
	}
if (textosin.charAt(0)==" ")
	textosin=textosin.substring(1,(textosin.length) );
if (textosin.charAt(textosin.length-1)==" ")
		textosin=textosin.substring(0,(textosin.length-1));
return (textosin);
}
function quitar_all_blancos(campo)
{
var textocon=campo.value;
var textosin="";
var longit = textocon.length;
for (var i=0;i<longit;i++) {
	if (textocon.charAt(i) != " ") {
		textosin= textosin+textocon.charAt(i);
	}
}
return (textosin);
}

// Método que elimina los ceros por la izquierda
function quitar_ceros_izquierda(campo)
{
    var textocon=campo.value;
    var encontradoPrimerNumero = false;
    var i = 0;
    while((!encontradoPrimerNumero) && (i < textocon.length))
    {
        var letra = textocon.charAt(i);
        if (letra == "0")
            i++;
        else
           encontradoPrimerNumero = true;
    }
    return (textocon.substring(i,(textocon.length)));
}

/**************************************************************************/
/* 3.- Funcion: campo_no_vacio(campo)
   Objetivo: Testea que determinado campo de un formulario no esté vacío
   Entrada: El campo a testear
   Salida:  True o false (además del mensaje correspondiente)		 */

function campo_no_vacio (campo)
{
var r=true;
var aux=quitar_blancos(campo)
if ( aux=="" )
	{
	error(5,campo);
    r=false;
    }
return r;
}

// Es la misma función que antes pero si alert
function campo_no_vacio_sin_alert (campo)
{
var r=true;
var aux=quitar_blancos(campo)
if ( aux=="" )
	{
	//error(5,campo);
    r=false;
    }
return r;
}
/**************************************************************************/
/* 4.- Funcion: sustituir_caracter(campo,car_in,car_out)
   Objetivo:  Sustituye en una cadena de texto un determinado caracter por otro
   Entrada: El campo del formulario a testear (campo),
   			el caracter a sustituir (car_in) y el caracter que lo reemplaza (car_out)
   Salida:  La misma cadena de texto, pero con la sustitucion de caracteres efectuada		 */

function sustituir_caracter(campo,car_in,car_out)
{
var cad=campo.value;
var textosin="";
var longit = cad.length;
for (var i=0;i<longit;i++)
	{
	var letra = cad.charAt(i);
	if (letra != car_in)
		textosin = textosin + letra;
	else
		{
		//textosin=textosin.substring(0,textosin.length - 1);
		textosin = textosin + car_out;
		}
	}
return (textosin);
}
/************************************************************************/
/* 5.- Funcion: completar_info(campo,longit,car)
   Objetivo: Completar, añadiendo a la izda. un determinado caracter, la información
	     introducida en un campo, hasta la longitud correcta
   Entrada: El campo a completar, la longitud que debe tener y el caracter de relleno (entre comillas)
   Salida:   El campo una vez relleno	         	 */

function completar_info(campo,longit,car)
{
var texto=campo.value;
var longinfo = texto.length;
if (longinfo < longit)
	for (var i=longinfo; i<longit;i++)
		texto = car + texto;
return (texto);
}
/************************************************************************/
/* 6.- Funcion: es_numerico(campo)
   Objetivo: Testea que la información introducida en determinados campos de un formulario sea numérica
   			Solo se testea en caso de campos no vacios (redundante si anteriormente esto ya fue testeado)
   Entrada: El valor del campo a testear
   Salida:   True o false (además del mensaje correspondiente)

  IMPORTANTE!: En JavaScript existe predefinida la funcion "isNaN(valorTest)", la cual evalúa un argumento
		   para ver si es un NaN: Not a Number (no está asociada a ningún objeto), la cual devuelve
		   true si valorTest no es numérico, y false en caso de que si lo sea	 */

function es_numerico(campo)
{
var r=true;
var longit = campo.value.length;
if (longit != 0) //redundante si se ha testeado antes que el campo no sea vacio
	{
	for (var i=0;i<longit;i++)
		{
		var letra = campo.value.charAt(i);
 		if (letra > "9" || letra < "0")
  			{
    		error(6,campo);
			r=false;
			break
   			}
		}
	}
else
    {
    error(5,campo);
    r=false;
    }
return r;
}

// Método que devuelve un boolean indicando si un campo es numérico o no
function es_numerico_sin_alert(campo)
{
	var r=true;
	var longit = campo.value.length;
	if (longit != 0) //redundante si se ha testeado antes que el campo no sea vacio
	{
		for (var i=0;i<longit;i++)
		{
			var letra = campo.value.charAt(i);
			if (letra > "9" || letra < "0")
			{
				r=false;
				break;
			}
		}
	}
	else
	{
		r=false;
	}
	return r;
}

// Método que devuelve un boolean indicando si un valor de un campo
function es_numerico_value_sin_alert(valor)
{
	var r=true;
	var longit = valor.length;
	if (longit != 0) //redundante si se ha testeado antes que el campo no sea vacio
	{
		for (var i=0;i<longit;i++)
		{
			var letra = valor.charAt(i);
			if (letra > "9" || letra < "0")
			{
				r=false;
				break;
			}
		}
	}
	else
	{
		r=false;
	}
	return r;
}

/************************************************************************/
/* 7.- Funcion: es_alfabetico(campo)
   Objetivo: Testea que la información introducida en determinados campos de un formulario sea alfabética
   			Solo se testea en caso de campos no vacios (redundante si anteriormente esto ya fue testeado)
   Entrada: El valor del campo a testear
   Salida: True o false (además del mensaje correspondiente)
   			Ademas, se podria obtener la información introducida en mayúsculas, descomentando la linea correspondiente

  IMPORTANTE!: En JavaScript existe predefinida la funcion "isNaN(valorTest)", la cual evalúa un argumento
		   para ver si es un NaN: Not a Number (no está asociada a ningún objeto), la cual devuelve
		   true si valorTest no es numérico, y false en caso de que si lo sea	 */

function es_alfabetico(campo)
{
var r=true;
var longit = campo.value.length;
if (longit != 0) //redundante si se ha testeado antes que el campo no sea vacio
	{
	for (var i=0;i<longit;i++)
		{
		var letra = campo.value.charAt(i);
		if ((letra < "a" || letra > "z") &&  (letra < "A" || letra > "Z") && (letra != ' '))
       		{
        	error(9,campo);
			r=false;
			break;
			}
		}
	}
//campo.value = campo.value.toUpperCase();
else
	{
	error(5, campo);
	r = false;
    }
return r;
}
/************************************************************************/
/* 8.- Funcion: es_alfanumerico(campo)
   Objetivo: Testea que la información introducida en determinados campos de un formulario sea alfanumérica
   Entrada: El valor del campo a testear
   Salida: True o false (además del mensaje correspondiente)
   			Ademas, se podria obtener la información introducida en mayúsculas, descomentando la linea correspondiente*/
function es_alfanumericoConEnie(campo) {
var r=true;
var longit = campo.value.length;
if (longit != 0) //redundante si se ha testeado antes que el campo no sea vacio
	{
	for (var i=0;i<longit;i++)
		{
		var letra = campo.value.charAt(i);
		if (((letra < "a" || letra > "z") &&  (letra < "A" || letra > "Z")) && (letra > "9" || letra < "0") && (letra != ' ') && (letra != 'ñ') && (letra != 'Ñ'))
       		{
         	error(11,campo);
			r=false;
        	break;
			}
		}
	}
//campo.value = campo.value.toUpperCase();
else {
	error(5, campo);
	r = false;
     }
return r;
}
function es_alfanumerico(campo)
{
var r=true;
var longit = campo.value.length;
if (longit != 0) //redundante si se ha testeado antes que el campo no sea vacio
	{
	for (var i=0;i<longit;i++)
		{
		var letra = campo.value.charAt(i);
		if (((letra < "a" || letra > "z") &&  (letra < "A" || letra > "Z")) && (letra > "9" || letra < "0") && (letra != ' '))
       		{
         	error(11,campo);
			r=false;
        	break;
			}
		}
	}
//campo.value = campo.value.toUpperCase();
else {
	error(5, campo);
	r = false;
     }
return r;
}

/************************************************************************/
/* 9.- Funcion: es_real(campo)
   Objetivo: Testea que la información introducida en determinados campos de un formulario sean numeros reales
   Entrada: El valor del campo a testear
   Salida: True o false (además del mensaje correspondiente)
   			Ademas, se podria obtener la información introducida en mayúsculas, descomentando la linea correspondiente*/

function es_real(campo)
{
 var r=true;
 var longit = campo.value.length;
 var punto = false;
 if (longit != 0) { //redundante si se ha testeado antes que el campo no sea vacio
	  for (var i=0;i<longit;i++){
	      var letra = campo.value.charAt(i);
	      if (letra > "9" || letra < "0" ) {
		    	 if (punto == false && letra==".") {
			 		 		punto = true;
					 }
		   		 else {
			 		 		 error(5,campo);
							 alert("Falla con la letra" + letra);
							 r = false;
							 break;
					 }
	  		}
 		}
 }
 return r;
}

function es_real_sin_alert(campo)
{
 var r=true;
 var longit = campo.value.length;
 var punto = false;
 if (longit != 0) { //redundante si se ha testeado antes que el campo no sea vacio
	  for (var i=0;i<longit;i++){
	      var letra = campo.value.charAt(i);
	      if (letra > "9" || letra < "0" ) {
		    	 if (punto == false && letra==".") {
			 		 		punto = true;
					 }
		   		 else {
			 		 		 //error(5,campo);
							 //alert("Falla con la letra" + letra);
							 r = false;
							 break;
					 }
	  		}
 		}
 }
 return r;
}

/************************************************************************/
/* 10.- Funcion: limites(valor, minimo, maximo)
   Objetivo: Testea que la información numérica introducida en un campos de un formulario esté
	     entre un determinado intervalo (min-max)
   Entrada: El valor del campo a testear
   Salida: True o false 		 */

function limites(valor, minimo, maximo)
{
var val =  parseInt (valor);
var r;

r = (val < minimo || val > maximo) ? false : true ;

return r;
}
/**************************************************************************/
/* 11.- Funcion: email_ok(campo)
   Objetivo: Testea si el e-mail introducido es o no válido
   Entrada: El campo del formulario donde se introdujo el e-mail
   Salida: True o false	+ alert correspondiente	                                         */

function email_ok(campo)
{
var r=true;
//var email = campo.value;
var email=quitar_blancos(campo);
campo.value=email;
if ((email == "") 						//mail deber ser no vacio...
	|| (email.indexOf (' ',0) != -1)	//..y no tener blancos...
	|| (email.indexOf ('@',0) == -1)	//..y tener una arroba...
	|| (email.indexOf ('@',0) != email.lastIndexOf ('@')) //..!!!pero solo una arroba!!!..
	|| (email.indexOf ('@',0) == 0)		// ..y no debe comenzar por arroba...
	|| (email.lastIndexOf ('@') == email.length-1)	//..ni acabar por arroba...
	|| (email.indexOf ('.',0) == -1)	// .. y debe tener un punto..
	|| (email.indexOf ('.',0) == 0)		// ..y no debe comenzar por punto...
	|| (email.lastIndexOf ('.') == email.length-1)	//..y no debe acabar en punto...
	|| (email.indexOf ('.',0) == email.indexOf ('@',0) + 1)	//.. la arroba y el punto no pueden ir seguidos
	|| (email.indexOf ('@') > email.lastIndexOf ('.'))	// .. tras la arroba debe haber, al menos, un punto
	)
	{
	error(13,campo);
	r=false;
	}
return r;
}

function email_ok_sin_alert(campo)
{
var r=true;
//var email = campo.value;
var email=quitar_blancos(campo);
campo.value=email;
if ((email == "") 						//mail deber ser no vacio...
	|| (email.indexOf (' ',0) != -1)	//..y no tener blancos...
	|| (email.indexOf ('@',0) == -1)	//..y tener una arroba...
	|| (email.indexOf ('@',0) != email.lastIndexOf ('@')) //..!!!pero solo una arroba!!!..
	|| (email.indexOf ('@',0) == 0)		// ..y no debe comenzar por arroba...
	|| (email.lastIndexOf ('@') == email.length-1)	//..ni acabar por arroba...
	|| (email.indexOf ('.',0) == -1)	// .. y debe tener un punto..
	|| (email.indexOf ('.',0) == 0)		// ..y no debe comenzar por punto...
	|| (email.lastIndexOf ('.') == email.length-1)	//..y no debe acabar en punto...
	|| (email.indexOf ('.',0) == email.indexOf ('@',0) + 1)	//.. la arroba y el punto no pueden ir seguidos
	|| (email.indexOf ('@') > email.lastIndexOf ('.'))	// .. tras la arroba debe haber, al menos, un punto
	)
	{
	r=false;
	}
return r;
}

function email_ok_sin_alert_CampoTexto(email)
{
var r=true;
if ((email == "") 						//mail deber ser no vacio...
	|| (email.indexOf (' ',0) != -1)	//..y no tener blancos...
	|| (email.indexOf ('@',0) == -1)	//..y tener una arroba...
	|| (email.indexOf ('@',0) != email.lastIndexOf ('@')) //..!!!pero solo una arroba!!!..
	|| (email.indexOf ('@',0) == 0)		// ..y no debe comenzar por arroba...
	|| (email.lastIndexOf ('@') == email.length-1)	//..ni acabar por arroba...
	|| (email.indexOf ('.',0) == -1)	// .. y debe tener un punto..
	|| (email.indexOf ('.',0) == 0)		// ..y no debe comenzar por punto...
	|| (email.lastIndexOf ('.') == email.length-1)	//..y no debe acabar en punto...
	|| (email.indexOf ('.',0) == email.indexOf ('@',0) + 1)	//.. la arroba y el punto no pueden ir seguidos
	|| (email.indexOf ('@') > email.lastIndexOf ('.'))	// .. tras la arroba debe haber, al menos, un punto
	)
	{
	r=false;
	}
return r;
}

// En este caso la validación de teléfonos móviles tiene que tener en cuenta los prefijos
// 1.- Si tiene un + debe comprobarse que hay un espacio en blanco entre medias
// 2.- Si introduce un prefijo, debe ser uno de los adminitidos
// 3.- El número restante debe ser numérico
function sms_ok_sin_alert_CampoTexto(sms)
{
  // Se eliminan los blancos desde el principio de la cadena hasta que nos encontramos un elemento
  // que no sea blanco
  var encontrado = false;
  var posicionInicial = 0;
  while ((!encontrado) && (posicionInicial < sms.length))
  {
    if(sms.charAt(posicionInicial) == " ")
      posicionInicial = posicionInicial + 1;
    else
      encontrado = true;
  }

  // Si no se ha encontrado algo distinto del blanco, se devuelve error
  if(!encontrado)
    return false;

  // Se eliminan los blancos desde el final de la cadena hasta que nos encontramos
  // un elemento que no sea un blanco
  encontrado = false;
  var posicionFinal = sms.length - 1;
  while ((!encontrado) && (posicionFinal >= 0))
  {
    if(sms.charAt(posicionFinal) == " ")
      posicionFinal = posicionFinal - 1;
    else
      encontrado = true;
  }

  // Si no se ha encontrado algo distinto del blanco, se devuelve error
  if(!encontrado)
    return false;

  var smsSinBlancos = sms.substring(posicionInicial, posicionFinal + 1);
  // Una vez eliminados los blancos, volvemos a fijar el principio y el fin
  posicionInicial = 0;
  posicionFinal = smsSinBlancos.length;

  var posicionMas = smsSinBlancos.indexOf("+");
  // Si tiene el mas, hay que verificar que el prefijo es correcto
  if(posicionMas != -1)
  {
    // Si tiene + y se han quitado los blancos, el más debe encontrarse en la posición 0.
    // En otro caso hay un error
    if(posicionMas != 0)
      return false;

    // Se verifica que solo hay 1 espacio en blanco y me quedo con su posición
    var posComprobacion = posicionInicial + 1;
    var numBlancos = 0;
    var posicionBlanco = -1;
    while((posComprobacion <= posicionFinal) && (numBlancos < 2))
    {
      if(smsSinBlancos.charAt(posComprobacion) == " ")
      {
	numBlancos++;
	posicionBlanco = posComprobacion;
      }
      posComprobacion++;
    }
    // Se verifica que solo hay 1 blanco
    if(numBlancos != 1)
      return false;
    // Se verifica que el prefijo y número son correctos
    else
    {
      var prefijo = smsSinBlancos.substring(posicionInicial + 1, posicionBlanco);
      var telefono = smsSinBlancos.substring(posicionBlanco + 1, posicionFinal + 1);
      if(!es_numerico_value_sin_alert(prefijo) ||
	 !es_numerico_value_sin_alert(telefono) ||
	 (telefono.length < 9) ||
	 !esPrefijoCorrecto(prefijo) ||
         ((prefijo == 34) && (telefono.charAt(0) != 6)) ||
         ((prefijo == 34) && (telefono.length != 9)))
	return false;
    }
  }
  // Si no tiene el +, hay que verificar que es numérico, de 9 cifras y que empiece por 6
  else
  {
    // Se quitan los blancos
    if ((smsSinBlancos == "") ||
        (smsSinBlancos.indexOf (' ',0) != -1) ||
	(smsSinBlancos.length != 9) ||
	(smsSinBlancos.charAt(0) != 6) ||
        (!es_numerico_value_sin_alert(smsSinBlancos)))
    return false
  }

  // Llegados a este puntos, todo es correcto
  return true;
}


// Método que comprueba si el prefijo pasado está en la lista de prefijos válidos
function esPrefijoCorrecto(prefijo)
{
  for(var i = 0; i < listaPrefijos.length - 1; i++)
  {
    if(listaPrefijos[i] == parseInt(prefijo))
      return true;
  }
  return false;
}

/**************************************************************************

		GENERALES

**************************************************************************/
/**************************************************************************/

/* 12.- Funciones CrearArray()
   Objetivo: Crea un array y lo inicializa  con los valores pasados por parámetro o,
   			 en caso de que éstos no existan, a nada.
   Entrada: Parámetros de inicialización
   Salida:  El array una vez inicializado 		*/

function CrearArray()
{
this.length = CrearArray.arguments.length;
for (var i=0; i<this.length; i++){
        this[i+1] = CrearArray.arguments[i]
        }
return this;
}
 /**************************************************************************/
/* 13.- Funcion: MakeArray(n,val)
   Objetivo: Crea un array de "n" posiciones, inicializando sus valores al valor "val", al que accederemos
	     con un índice que comienza en el elemento 1 (no desde 0 como en JAVA o C)
   Entrada: El nº de elementos (n) que queremos que tenga nuestro array, y el valor de inicialización (val)
   Salida: El array sin nombre. El nombre se le asigna al invocar a esta función.
	   Ej.:            miarray = new MakeArray(15, 0) ;
	   Esto crea un array llamado "miarray" de 15 elementos, e inicializados a cero
	   Para dar valores a los elementos del array bastará hacer uso de una simple asignación
	   Ej.:    miarray[1] = "Iñaki";  miarray[2] = "Jiménez";  miarray[3] = "Navarro";                  */

function MakeArray(n,val)
{
this.length = n;

for (var i=1; i<n; i++)
	{
	this[i] = val;
	}
return this;
}
/************************************************************************/
/* 14.- Funcion: soporta_DHTML()
   Objetivo: Testea que el navegador que emplea el usuario soporte HTML dinamico
   (Communicator o IE4.0)
   Entrada: Nada
   Salida: true o false		 */

function soporta_DHTML()
{
var netscape4=false;
var iexpolrer4=false;
var dinamic=true;
if( document.layers )
	{
	alert("Navegador NN4");
    netscape4 = true;
    //acceder a los elementos mediante el DOM del N4
	}
else
	{
	if (document.all )
		{
        alert("Navegador IE4");
        iexplorer4 = true;
        //acceder a los elementos mediante el DOM del E4
        }
	else
		{
		dinamic = false;
	    alert("Su Navegador no soporta HTML Dinámico");
		}
	}
return dinamic;
}
/************************************************************************/
/* 15.- Funcion: nueva_ventana(campo,ancho,alto)
   Objetivo: Abre una nueva ventana, con la información introducida en un formulario
   			 y con el tamanio indicado
   	     Para dicha nueva ventana es configurable tambien su aspecto (parámetros del
	     método 'window.open(....)'
   Entrada: El contenido del formulario a mostrarse, el ancho y el alto de la nueva ventana
   Salida: La nueva ventana, del tamaño indicado y con el contenido introducido	 */

function nueva_ventana(campo,ancho,alto)
{
var info = campo.value;
temp = "toolbar=yes,directories=no,menubar=no,width=" + ancho + ",height=" + alto + "\""
var msg = open("","DisplayWindow",temp);
    msg.document.write("<HTML><HEAD><TITLE>Hola!</TITLE></HEAD>");
    msg.document.write("<BODY><CENTER>Has introducido " + info + "</CENTER></BODY></HTML>");
}

function abrirventana(texto,url,alto,ancho,top,left,toolbars,scrollbars,directories,menubars,location,noresize) {

	winprops = 'height=' + alto + ' ,width='+ ancho +' ,top='+top+' ,left='+left+' ,scrollbars='+scrollbars+' ,directories=' + directories + ' ,menubars='+menubars+', toolbars=' + toolbars+' ,location='+location+' ';
	if ( noresize == "noresize" ){
	winprops += ',noresize'
	}


	win=window.open('',"ventana",winprops);
	win.document.open();
	win.document.write(texto);
	win.document.close();
	if(url!='') win.document.location=url;
	if (parseInt(navigator.appVersion) >= 4) { win.window.focus(); }
}



/**************************************************************************

		FECHAS Y HORAS

**************************************************************************/
/**************************************************************************/
/* 16.- Funcion: fechavalida(fecha)
   Objetivo: Testea si la fecha introducida es una fecha válida
   Entrada: fecha en formato numérico DDMMAAAA
   Salida:   True o false	(además del mensaje correspondiente)	*/

function fechavalida(fecha)
{
var r=true;
fecha.value=completar_info(fecha,8,"0");
var text_in=fecha.value;
var dia = text_in.substring(0,2);
var mes = text_in.substring(2,4);
//var anio = 1900 + fecha.value.substring(4,8);
if (campo_no_vacio(fecha) && es_numerico(fecha))
	{
	if (dia > "31" || dia == "00")
		{
		error(2,fecha);
		r=false;
		}
	if ((mes == "00" || mes > "12") && r==true)
		{
		error(1,fecha);
		r=false;
		}
	if (mes == "02" && dia > "29" && r==true)
		{
		error(3,fecha);
		r=false;
		}
	if ((mes == "04" || mes == "06" || mes == "09" || mes == "11") && dia > "30" && r==true)
		{
		error(4,fecha);
		r=false;
		}
	//if ((limites (anio, 1950, 2000) != true) && (r == true))
		//{
		//error(12,fecha);
		//r=false;
		//}
	}
else r=false;
return r;
}

// Método que hace lo mismo que la anterior, sin sacar alert
function fechavalida_sin_alert(fecha)
{
var r=true;
fecha.value=completar_info(fecha,8,"0");
var text_in=fecha.value;
var dia = text_in.substring(0,2);
var mes = text_in.substring(2,4);
//var anio = 1900 + fecha.value.substring(4,8);
if (campo_no_vacio(fecha) && es_numerico(fecha))
	{
	if (dia > "31" || dia == "00")
		{
		//error(2,fecha);
		r=false;
		}
	if ((mes == "00" || mes > "12") && r==true)
		{
		//error(1,fecha);
		r=false;
		}
	if (mes == "02" && dia > "29" && r==true)
		{
		//error(3,fecha);
		r=false;
		}
	if ((mes == "04" || mes == "06" || mes == "09" || mes == "11") && dia > "30" && r==true)
		{
		//error(4,fecha);
		r=false;
		}
	//if ((limites (anio, 1950, 2000) != true) && (r == true))
		//{
		//error(12,fecha);
		//r=false;
		//}
	}
else r=false;
return r;
}

/**************************************************************************/
/* 17.- Funcion: es_bisiesto(anio)
   Objetivo: Testea si un string-año es o no bisiesto
   			Regla: Un año es bisiesto si cumple estas tres reglas
			1.- Si un año es divisible por 4 Si es bisiesto
			2.- Si un año es divisible por 100 NO es bisiesto
			3.- Si un año es divisible por 400 SI es bisiesto
   Entrada: El campo-año a testear
   Salida:  true o false                                     */

function es_bisiesto(anio)
{
// De otra manera: bisiesto = (( ((año % 4) == 0) && ((año %100) != 0) ) || ((año %400) == 0) );
var r=false;
if (anio % 4 == 0)
	{
	r = true;
	//alert("Es bisisesto");
	if ((anio % 100 == 0) && (anio % 400 != 0))
		{
		//alert("Es no bisisesto");
		r = false;
		}
	}
return r;
}
/**************************************************************************/
/* 18.- Funcion: mayor_de_edad(fechanac)
   Objetivo: Testea si una persona es o no mayor de edad (18 años)
   Entrada: La fecha de nacimiento en formato DDMMAAAA
   Salida:   True o false(además del mensaje correspondiente)		*/

function mayor_de_edad(fechanac)
{
var r=true;
var anionac = fechanac.value.substring(4,8);
var Todays = new Date();
//var dia=Todays.getDate();
//var mes=Todays.getMonth()+1;
var anio= 1900 + Todays.getYear();
if ((anio - anionac) < 18)
      {
	error(8,fechanac);
	r=false;
      }
return r;
}
/**************************************************************************/
/* 19.- Funcion: gettheDate()
   Objetivo: Obtener la fecha actual del ordenador en formato AAAAMMDD
   Entrada:  No tiene
   Salida:    aaaammdd (válido para fechas anteriores al año 2000)	*/

function gettheDate()
{
	var Todays = new Date();
	var dia=Todays.getDate();
	var mes=Todays.getMonth()+1;
	var anio=1900+Todays.getYear();
	var TheDate ="" + ((dia<10)? "0" : "") + dia + "/"+ ((mes<10)? "0" : "")  + mes + "/"+ anio;

	/* Y si queremos visualizar la fecha obtenida en un campo determinado de un formulario....*/
	//document.clock.date.value = TheDate;	// por ejemplo

	return TheDate;
}
/**************************************************************************/
/* 20.- Funcion: showtime(timerRunning, timerID)
   Objetivo: Obtener la hora actual del ordenador en formato HHMMSS
   Entrada:  No tiene
   Salida:    hhmmss 		*/

function showtime (timerRunning, timerID)
{
        var now = new Date();
        var hours = now.getHours();
        var minutes = now.getMinutes();
        var seconds = now.getSeconds();
        var timeValue =((hours<10) ? "0" : "")+hours;
        timeValue += ((minutes < 10) ? ":0" : ":") + minutes;
        timeValue += ((seconds < 10) ? ":0" : ":") + seconds;

	/* Y si queremos visualizar la fecha obtenida en un campo determinado de un formulario....*/
    //    document.clock.face.value = timeValue;
	timerID = setTimeout ("showtime()", 1000);
	timerRunning = true;

return timeValue;
}
/**************************************************************************/
/* 21.- Funcion: stopclock(timerRunning, timerID)
   Objetivo: Para el reloj del ordenador
   Entrada:  No tiene
   Salida:
						 */
function stopclock (timerRunning, timerID)
{
    if (timerRunning)
		clearTimeout(timerID);
	timerRunning = false;
}
/**************************************************************************/
/* 22.- Funcion: startclock()
   Objetivo: Obtener un reloj (llama a las funciones stopclock, gettheDate y showtime)
   Entrada: no tiene
   Salida:
						 */
function startclock ()
{
var timerID = null;
var timerRunning = false;

    stopclock(timerRunning, timerID);
	gettheDate();
	showtime(timerRunning, timerID);
}

/**************************************************************************/
/*	23.- Funcion: validarnumreal (Campo, NumDecimales, ValorMin, ValorMax)
	Objetivo: validar un numero para que se encuentre entre dos valores (maximo,minimo)
	y controlar el numero de decimales que tiene
*/
function validarnumreal(Campo, NumDecimales, ValorMin, ValorMax)
{
 if (isNaN(Campo))
    {
     alert ("El campo solo admite valores numéricos"); return false;
    }
 else
   {
    if (eval(parseFloat(Campo) <= parseFloat(ValorMin)))
       {
        alert ("El campo deber ser mayor que " + String (ValorMin));
        return false;
       }
    else
       {
        if (eval(parseFloat(Campo) >= ValorMax))
           {
            alert ("El campo deber ser menor que " + String (ValorMax));
            return false;
           }
        else
          {
           if (Campo.indexOf ('.') != -1)
              {
               if (Campo.length > (NumDecimales + Campo.indexOf('.') + 1))
                  {
                   alert ("El campo admite " + String(NumDecimales) + " decimales como máximo");
                   return false;
                  }
              }
          }
       }
   }
 return true;
}
/************************************************************************/
/* 24.- Funcion: telefono_OK(campo,caso)
   Objetivo: Testea que la información introducida en determinados campos de un formulario sea numérica
   			o que tenga el comodin (%) para consultas ORACLE
   			Solo se testea en caso de campos no vacios (redundante si anteriormente esto ya fue testeado)
   Entrada: El valor del campo a testear
   Salida:   True o false (además del mensaje correspondiente)
 */

function telefono_OK(campo,caso)
{
var r=true;
var longit = campo.value.length;
if (longit != 0){
		if (((caso == "modif") || (caso == "alta")) && (longit !=9))
			{
    		error(19,campo);
			r=false;
   		}
		for (var i=0;(i<longit && r);i++)
		{
		var letra = campo.value.charAt(i);
		if (((caso == "modif") || (caso == "alta")) && ((letra > "9" || letra < "0")))
  			{
    		error(6,campo);
			r=false;
			break
   			}
		if ((caso == "consul") && ((letra > "9" || letra < "0") && (letra != "%")))
  			{
    		error(6,campo);
			r=false;
			break
   			}
		}
}
return r;
}

/************************************************************************/
/* 25.- Funcion: fechaValida2(campo,caso)
   Objetivo: Verifica que la fecha de entrada en el Formulario tiene un formato especifico
             Este formato tiene que ser dd/mm/aaaa
   Entrada: El valor del campo a testear
   Salida:   True o false (además del mensaje correspondiente)

FUNCION OBSOLETA!!!!!
Se ha mejorado con unas nuevas funciones de librería, que se añaden al final....

function fechavalida2(fecha){
	var r=true;
	var text_in=fecha.value;
	text_in=completar_info(fecha,10,"0");
	var dia = text_in.substring(0,2);
	var barra1 = text_in.substring(2,3);
	var mes = text_in.substring(3,5);
	var barra2 = text_in.substring(5,6);
	var anyo = text_in.substring(6,10);

	if ((barra1 != "/") || (barra2 != "/")){
			error(14,fecha);
			r=false;
	}
	if ((r) && (dia > "31" || dia == "00")){
		error(2,fecha);
		r=false;
	}
	if ((r) && (mes == "00" || mes > "12"))	{
		error(1,fecha);
		r=false;
	}
	if ((r) && (mes == "02" && dia > "29")){
		error(3,fecha);
		r=false;
	}
	if ((r) && (mes == "04" || mes == "06" || mes == "09" || mes == "11") && dia > "30"){
		error(4,fecha);
		r=false;
	}

	if ((r) && (mes == "02" && dia == "29") && (!es_bisiesto(anyo))){
		error(12,fecha);
		r=false;
	}
	if ((r) && (anyo <= "1997")){
		error(17,fecha);
		r=false;
	}
	//alert(r);
	return r;

}
*/
/************************************************************************/
/* 26.- Funcion: checkSoloLectura(unCheckBox)
   Objetivo: Simula un checkbox de solo lectura
   Entrada: Una referencia al check que no queremos que cambie de estado
   Salida:  No procede
 */
function checkSoloLectura(unCheck) {
	unCheck.checked = !unCheck.checked;
}
/************************************************************************/
/* 27 .- Funcion : compruebaFechas(fechaIni,fechaFin)
	Objetivo : Comprueba que las fechas sean de formato DD/MM/AAAA y que
				ls inicial sea menor que la final
	Entrada : La fecha inicial y la fecha final
	Salida : True o FALSE
*/
 function compruebaFechas(fechaIni,fechaFin){

   var r = true;

    if(!fechavalida2(fechaIni)){
	  error(14,fechaIni)
	  return false;
	}
	  if(!fechavalida2(fechaFin)){
	     error(14,fechaFin);
	     return false;
	  }

	 var anyoIni = parseInt(fechaIni.value.substring(6,10),10);
	 var mesIni = parseInt(fechaIni.value.substring(3,5),10);
	 var diaIni = parseInt(fechaIni.value.substring(0,2),10);

	 var anyoFin = parseInt(fechaFin.value.substring(6,10),10);
	 var mesFin = parseInt(fechaFin.value.substring(3,5),10);
     var diaFin = parseInt(fechaFin.value.substring(0,2),10);

     if (anyoIni>anyoFin) {
	   r = false;
     } else {
	   if (anyoIni==anyoFin) {
         if (mesIni>mesFin) {
	        r = false;
       	 } else {
		    if (mesIni==mesFin) {
               if (diaIni>diaFin) {
                  r = false;
			   }
		    }
	     }
       }
	 }
     if (!r) error(15,fechaIni);

     return r;
 }

 // Método que hace lo mismo que el anterior pero sin sacar un alert
 function compruebaFechas_sin_alert(fechaIni,fechaFin){

   var r = true;

    if(!fechavalida2_sin_alert(fechaIni)){
	  //error(14,fechaIni)
	  return false;
	}
	  if(!fechavalida2_sin_alert(fechaFin)){
	     //error(14,fechaFin);
	     return false;
	  }

	 var anyoIni = parseInt(fechaIni.value.substring(6,10),10);
	 var mesIni = parseInt(fechaIni.value.substring(3,5),10);
	 var diaIni = parseInt(fechaIni.value.substring(0,2),10);

	 var anyoFin = parseInt(fechaFin.value.substring(6,10),10);
	 var mesFin = parseInt(fechaFin.value.substring(3,5),10);
     var diaFin = parseInt(fechaFin.value.substring(0,2),10);

     if (anyoIni>anyoFin) {
	   r = false;
     }
     else
     {
	 if (anyoIni==anyoFin)
         {
           if (mesIni>mesFin) {
                  r = false;
           }
           else
           {
                if (mesIni==mesFin)
                {
                  if (diaIni>diaFin)
                  {
                   r = false;
                   }
                }
            }
         }
      }
     //if (!r) error(15,fechaIni);

     return r;
 }

 // Método que hace lo mismo que el anterior pero devuelve false también si las fechas son Iguales
 function compruebaFechas2_sin_alert(fechaIni,fechaFin){

   var r = true;

    if(!fechavalida2_sin_alert(fechaIni)){
	  //error(14,fechaIni)
	  return false;
	}
	  if(!fechavalida2_sin_alert(fechaFin)){
	     //error(14,fechaFin);
	     return false;
	  }

	 var anyoIni = parseInt(fechaIni.value.substring(6,10),10);
	 var mesIni = parseInt(fechaIni.value.substring(3,5),10);
	 var diaIni = parseInt(fechaIni.value.substring(0,2),10);

	 var anyoFin = parseInt(fechaFin.value.substring(6,10),10);
	 var mesFin = parseInt(fechaFin.value.substring(3,5),10);
     var diaFin = parseInt(fechaFin.value.substring(0,2),10);

     if (anyoIni>anyoFin) {
	   r = false;
     }
     else
     {
	 if (anyoIni==anyoFin)
         {
           if (mesIni>mesFin) {
                  r = false;
           }
           else
           {
                if (mesIni==mesFin)
                {
                  if (diaIni>=diaFin)
                  {
                   r = false;
                   }
                }
            }
         }
      }
     //if (!r) error(15,fechaIni);

     return r;
 }

 // Método que hace lo mismo que el anterior pero sin sacar un alert y comprobando la Hora
 function compruebaFechas_sin_alert_con_Hora(fechaIni,fechaFin){

   var r = true;

   var anyoIni = parseInt(fechaIni.substring(6,10),10);
   var mesIni = parseInt(fechaIni.substring(3,5),10);
   var diaIni = parseInt(fechaIni.substring(0,2),10);
   var horaIni = parseInt(fechaIni.substring(11,13),10);
   var minIni = parseInt(fechaIni.substring(14,16),10);

   var anyoFin = parseInt(fechaFin.substring(6,10),10);
   var mesFin = parseInt(fechaFin.substring(3,5),10);
   var diaFin = parseInt(fechaFin.substring(0,2),10);
   var horaFin = parseInt(fechaFin.substring(11,13),10);
   var minFin = parseInt(fechaFin.substring(14,16),10);

   if (anyoIni>anyoFin)
   {
    r = false;
   }
   else
   {
     if (anyoIni==anyoFin)
     {
        if (mesIni>mesFin)
        {
           r = false;
        }
        else
        {
          if (mesIni==mesFin)
          {
             if (diaIni>diaFin)
             {
                r = false;
             }
             else
             {
               if(diaIni == diaFin)
               {
                 if(horaIni > horaFin)
                 {
                   r = false;
                 }
                 else
                 {
                   if (horaIni == horaFin)
                   {
                     if(minIni > minFin)
                     {
                       r = false;
                     }
                   }
                 }
               }
             }
          }
        }
     }
   }

   return r;
 }

 // Método que hace lo mismo que el anterior pero devolviendo false también cuando son iguales
 function compruebaFechas2_sin_alert_con_Hora(fechaIni,fechaFin){

   var r = true;

   var anyoIni = parseInt(fechaIni.substring(6,10),10);
   var mesIni = parseInt(fechaIni.substring(3,5),10);
   var diaIni = parseInt(fechaIni.substring(0,2),10);
   var horaIni = parseInt(fechaIni.substring(11,13),10);
   var minIni = parseInt(fechaIni.substring(14,16),10);

   var anyoFin = parseInt(fechaFin.substring(6,10),10);
   var mesFin = parseInt(fechaFin.substring(3,5),10);
   var diaFin = parseInt(fechaFin.substring(0,2),10);
   var horaFin = parseInt(fechaFin.substring(11,13),10);
   var minFin = parseInt(fechaFin.substring(14,16),10);

   if (anyoIni>anyoFin)
   {
    r = false;
   }
   else
   {
     if (anyoIni==anyoFin)
     {
        if (mesIni>mesFin)
        {
           r = false;
        }
        else
        {
          if (mesIni==mesFin)
          {
             if (diaIni>diaFin)
             {
                r = false;
             }
             else
             {
               if(diaIni == diaFin)
               {
                 if(horaIni > horaFin)
                 {
                   r = false;
                 }
                 else
                 {
                   if (horaIni == horaFin)
                   {
                     if(minIni >= minFin)
                     {
                       r = false;
                     }
                   }
                 }
               }
             }
          }
        }
     }
   }

   return r;
 }

 // Método que hace lo mismo que el anterior pero comprobando solo la Hora
 function compruebaHoras_sin_alert(horaInicio , horaFinal){

   var r = true;

   var horaIni = parseInt(horaInicio.substring(0,2),10);
   var minIni = parseInt(horaInicio.substring(3,5),10);

   var horaFin = parseInt(horaFinal.substring(0,2),10);
   var minFin = parseInt(horaFinal.substring(3,5),10);


   if(horaIni > horaFin)
   {
     r = false;
   }
   else
   {
       if (horaIni == horaFin)
       {
           if(minIni > minFin)
           {
           r = false;
           }
       }
   }

   return r;
 }


 // Método que hace lo mismo que el anterior pero comprobando dia de la semana y Hora
 function compruebaFechasSemana_sin_alert(horaInicio , horaFinal){

   var r = true;
   var posHoraInicio = horaInicio.indexOf(' ');
   var posHoraFinal = horaFinal.indexOf(' ');
   var semanaIni = horaInicio.substring(0, posHoraInicio);
   var semanaFin = horaFinal.substring(0, posHoraFinal);

   var horaIni = parseInt(horaInicio.substring(posHoraInicio+1,posHoraInicio+3),10);
   var minIni = parseInt(horaInicio.substring(posHoraInicio+4,posHoraInicio+6),10);

   var horaFin = parseInt(horaFinal.substring(posHoraFinal+1,posHoraFinal+3),10);
   var minFin = parseInt(horaFinal.substring(posHoraFinal+4,posHoraFinal+6),10);

   var numSemanaIni = getNumDiaSemana(semanaIni);
   var numSemanaFin = getNumDiaSemana(semanaFin);

   if (numSemanaIni > numSemanaFin)
   {
      r = false;
   }
   else if (numSemanaIni == numSemanaFin)
   {
       if(horaIni > horaFin)
       {
         r = false;
       }
       else
       {
           if (horaIni == horaFin)
           {
               if(minIni > minFin)
               {
               r = false;
               }
           }
       }
   }
   return r;
 }

 // Método que hace lo mismo que el anterior pero comprobando dia de la semana y Hora
 function sortSemanal(horaInicio , horaFinal){

   var r = -1;
   var posHoraInicio = horaInicio.indexOf(' ');
   var posHoraFinal = horaFinal.indexOf(' ');
   var semanaIni = horaInicio.substring(0, posHoraInicio);
   var semanaFin = horaFinal.substring(0, posHoraFinal);

   var horaIni = parseInt(horaInicio.substring(posHoraInicio+1,posHoraInicio+3),10);
   var minIni = parseInt(horaInicio.substring(posHoraInicio+4,posHoraInicio+6),10);

   var horaFin = parseInt(horaFinal.substring(posHoraFinal+1,posHoraFinal+3),10);
   var minFin = parseInt(horaFinal.substring(posHoraFinal+4,posHoraFinal+6),10);

   var numSemanaIni = getNumDiaSemana(semanaIni);
   var numSemanaFin = getNumDiaSemana(semanaFin);

   if (numSemanaIni > numSemanaFin)
   {
      r = 1;
   }
   else if (numSemanaIni == numSemanaFin)
   {
       if(horaIni > horaFin)
       {
         r = 1;
       }
       else
       {
           if (horaIni == horaFin)
           {
               if(minIni > minFin)
               {
               r = 1;
               }
           }
       }
   }
   return r;
 }


 // Método que hace lo mismo que el anterior pero comprobando dia del mes y Hora
 function compruebaFechasMes_sin_alert(horaInicio , horaFinal){

   var r = true;
   var posHoraInicio = horaInicio.indexOf(',');
   var posHoraFinal = horaFinal.indexOf(',');
   var posDiaMesInicio = horaInicio.indexOf(' ')
   var posDiaMesFinal = horaFinal.indexOf(' ');
   var diaMesIni = parseInt(horaInicio.substring(posDiaMesInicio+1, posHoraInicio));
   var diaMesFin = parseInt(horaFinal.substring(posDiaMesFinal+1, posHoraFinal));

   var horaIni = parseInt(horaInicio.substring(posHoraInicio+2,posHoraInicio+5),10);
   var minIni = parseInt(horaInicio.substring(posHoraInicio+5,posHoraInicio+8),10);

   var horaFin = parseInt(horaFinal.substring(posHoraFinal+2,posHoraFinal+5),10);
   var minFin = parseInt(horaFinal.substring(posHoraFinal+5,posHoraFinal+8),10);

   if (diaMesIni > diaMesFin)
   {
      r = false;
   }
   else if (diaMesIni == diaMesFin)
   {
       if(horaIni > horaFin)
       {
         r = false;
       }
       else
       {
           if (horaIni == horaFin)
           {
               if(minIni > minFin)
               {
               r = false;
               }
           }
       }
   }
   return r;
 }


 // Método que hace lo mismo que el anterior pero comprobando dia del mes, el mes y Hora
 function compruebaFechasAnyo_sin_alert(horaInicio , horaFinal){

   var r = true;
   var posHoraInicio = horaInicio.indexOf(',');
   var posHoraFinal = horaFinal.indexOf(',');
   var posDiaMesIni = horaInicio.indexOf(' de')
   var posDiaMesFin = horaFinal.indexOf(' de');

   var diaMesIni = parseInt(horaInicio.substring(4, posDiaMesIni));
   var diaMesFin = parseInt(horaFinal.substring(4, posDiaMesFin));

   var mesInicio = horaInicio.substring(posDiaMesIni+4, posHoraInicio);
   var mesFin = horaFinal.substring(posDiaMesFin+4, posHoraFinal);

   var numMesInicio = getNumMesAnyo(mesInicio);
   var numMesFinal = getNumMesAnyo(mesFin);

   var horaIni = parseInt(horaInicio.substring(posHoraInicio+2,posHoraInicio+5),10);
   var minIni = parseInt(horaInicio.substring(posHoraInicio+5,posHoraInicio+8),10);

   var horaFin = parseInt(horaFinal.substring(posHoraFinal+2,posHoraFinal+5),10);
   var minFin = parseInt(horaFinal.substring(posHoraFinal+5,posHoraFinal+8),10);

   if (numMesInicio > numMesFinal)
   {
      r = false;
   }
   else if (numMesInicio == numMesFinal)
   {
       if (diaMesIni > diaMesFin)
       {
          r = false;
       }
       else if (diaMesIni == diaMesFin)
       {
           if(horaIni > horaFin)
           {
             r = false;
           }
           else
           {
               if (horaIni == horaFin)
               {
                   if(minIni > minFin)
                   {
                   r = false;
                   }
               }
           }
       }
   }
   return r;
 }

 function sortAnual(horaInicio , horaFinal){

   var r = -1;
   var posHoraInicio = horaInicio.indexOf(',');
   var posHoraFinal = horaFinal.indexOf(',');
   var posDiaMesIni = horaInicio.indexOf(' de')
   var posDiaMesFin = horaFinal.indexOf(' de');

   var diaMesIni = parseInt(horaInicio.substring(4, posDiaMesIni));
   var diaMesFin = parseInt(horaFinal.substring(4, posDiaMesFin));

   var mesInicio = horaInicio.substring(posDiaMesIni+4, posHoraInicio);
   var mesFin = horaFinal.substring(posDiaMesFin+4, posHoraFinal);

   var numMesInicio = getNumMesAnyo(mesInicio);
   var numMesFinal = getNumMesAnyo(mesFin);

   var horaIni = parseInt(horaInicio.substring(posHoraInicio+2,posHoraInicio+5),10);
   var minIni = parseInt(horaInicio.substring(posHoraInicio+5,posHoraInicio+8),10);

   var horaFin = parseInt(horaFinal.substring(posHoraFinal+2,posHoraFinal+5),10);
   var minFin = parseInt(horaFinal.substring(posHoraFinal+5,posHoraFinal+8),10);

   if (numMesInicio > numMesFinal)
   {
      r = 1;
   }
   else if (numMesInicio == numMesFinal)
   {
       if (diaMesIni > diaMesFin)
       {
          r = 1;
       }
       else if (diaMesIni == diaMesFin)
       {
           if(horaIni > horaFin)
           {
             r = 1;
           }
           else
           {
               if (horaIni == horaFin)
               {
                   if(minIni > minFin)
                   {
                   r = 1;
                   }
               }
           }
       }
   }
   return r;
 }

function sortFechas(a, b)
{
    if (a.length == b.length)
    {
        if (a < b)
          return -1;
        else if (a > b)
          return 1;
        else return 0;
    }
    else
    {
        return (a.length - b.length);
    }
}

 // Método que dado un valor, devuelve el dia de la semana equivalente
 function getDiaSemana(numDiaSemana)
 {
    var retorno = "";
    switch(numDiaSemana)
    {
      case 0: retorno = "Lunes"; break
      case 1: retorno = "Martes"; break
      case 2: retorno = "Miércoles"; break
      case 3: retorno = "Jueves"; break
      case 4: retorno = "Viernes"; break
      case 5: retorno = "Sábado"; break
      case 6: retorno = "Domingo"; break
      default: retorno = "";
    }
    return retorno;
  }

  // Método que dado un dia de la semana, devuelve el valor equivalente
  function getNumDiaSemana(diaSemana)
  {
    if (diaSemana == "Lunes")
       return 0;
    else if (diaSemana == "Martes")
         return 1;
    else if (diaSemana == "Miércoles")
         return 2;
    else if (diaSemana == "Jueves")
         return 3;
    else if (diaSemana == "Viernes")
         return 4;
    else if (diaSemana == "Sábado")
         return 5;
    else if (diaSemana == "Domingo")
         return 6;
    else return -1;
  }

 // Método que dado un valor, devuelve el mes del año equivalente
 function getMesAnyo(numMesAnyo)
 {
    var retorno = "";
    switch(numMesAnyo)
    {
      case 0: retorno = "Enero"; break
      case 1: retorno = "Febrero"; break
      case 2: retorno = "Marzo"; break
      case 3: retorno = "Abril"; break
      case 4: retorno = "Mayo"; break
      case 5: retorno = "Junio"; break
      case 6: retorno = "Julio"; break
      case 7: retorno = "Agosto"; break
      case 8: retorno = "Septiembre"; break
      case 9: retorno = "Octubre"; break
      case 10: retorno = "Noviembre"; break
      case 11: retorno = "Diciembre"; break
      default: retorno = "";
    }
    return retorno;
  }

  // Método que dado un mes del año, devuelve el valor equivalente
  function getNumMesAnyo(mesAnyo)
  {
    if (mesAnyo == "Enero")
       return 0;
    else if (mesAnyo == "Febrero")
         return 1;
    else if (mesAnyo == "Marzo")
         return 2;
    else if (mesAnyo == "Abril")
         return 3;
    else if (mesAnyo == "Mayo")
         return 4;
    else if (mesAnyo == "Junio")
         return 5;
    else if (mesAnyo == "Julio")
         return 6;
    else if (mesAnyo == "Agosto")
         return 7;
    else if (mesAnyo == "Septiembre")
         return 8;
    else if (mesAnyo == "Octubre")
         return 9;
    else if (mesAnyo == "Noviembre")
         return 10;
    else if (mesAnyo == "Diciembre")
         return 11;
    else return -1;
  }

  function diasMesPermitidos(mesAnyo, diaMes)
  {
    var retorno = true;
    var valor = 0;
    switch(mesAnyo)
    {
      case 0: valor = 31; break
      case 1: valor = 28; break
      case 2: valor = 31; break
      case 3: valor = 30; break
      case 4: valor = 31; break
      case 5: valor = 30; break
      case 6: valor = 31; break
      case 7: valor = 30; break
      case 8: valor = 31; break
      case 9: valor = 31; break
      case 10: valor = 30; break
      case 11: valor = 31; break
      default: valor = 0;
    }

    if (diaMes > valor)
    {
      retorno = false;
    }
    return retorno;
  }

/************************************************************************/
/* 28.- Funcion: codigoPostalValido(listaProvincias, codPostal)
   Objetivo: Valida el valor del elemento de formulario 'codPostal' a partir de un desplegable
   			'listaProvincias' cuyos valores son los códigos de provincia.
   Entrada: Una referencia al desplegable de provincias; una referencia al campo del código postal.
   Salida:  boolean
 */
function codigoPostalValido(listaProvincias, codPostal) {
	if (!es_numerico(codPostal)) {
		return false;
	}

	if (codPostal.value.length != 5) {
		alert('El código postal debe tener cinco cifras.');
		codPostal.focus();
		return false;
	}

	codProv = listaProvincias.options[listaProvincias.selectedIndex].value;
	if (codProv.length == 1) {
		codProv = '0' + codProv;
	}
	if (codPostal.value.indexOf(codProv) != 0) {
		alert('El código postal no pertenece a la provincia elegida.');
		codPostal.focus();
		return false;
	}
	return true;
}
/************************************************************************/
/* 29.- Funcion: sugiereCodigoPostal(listaProvincias, codPostal)
   Objetivo: A partir de la provincia escogida en la lista 'listaProvincias', rellena las dos primeras
   			cifras del código postal del campo 'codPostal'.
   Entrada: Una referencia al desplegable de provincias; una referencia al campo del código postal.
   Salida:  No procede.
 */
function sugiereCodigoPostal(listaProvincias, codPostal) {
	codProv = listaProvincias.options[listaProvincias.selectedIndex].value;
	if (isNaN(codProv)) {
		codPostal.value = '';
		return;
	}

	if (codProv.length == 1) {
		codProv = '0' + codProv;
	}
	codPostal.value = codProv;
}
/************************************************************************/
/* 30.- Funcion : tiene_tlf_long9(campo)
	Objetivo : Comprueba que el teléfono introducido sea numérico y que
				tenga una longitud de 9 caracteres
	Entrada : El campo teléfono
	Salida : True o FALSE

	Modificado para que acepte teléfonos que empiecen con 8
*/
 function tiene_tlf_long9(campo){
	var r = true;
	var longtel = campo.value.length;
	if (longtel < 9){
			error(16,campo);
			r = false;
	}

	for (var i=0;i<longtel;i++)
		{
		var letra = campo.value.charAt(i);
		if ((i==0) && (letra != "9") && (letra != "8"))
		  	{
    		error(18,campo);
			r=false;
   			}

 		if (r && (letra > "9" || letra < "0"))
  			{
    		error(6,campo);
			r=false;
   			}
		}
	return r ;
 }
 /**************************************************************************
31.- Funcion: redondear(campo,decimales)
Objetivo: redondear el valor del campo al numero de decimales que se indique en decimales
          esta función redondea al alta, es decir > .5 se suma una unidad.

Entradas: Campo: Es el campo a redondear
          decimales: Es el numero de decimales que se quiere

Salida:	  El campo redondeado
*/
function redondear(campo,decimales)
{
	cadena = new Array();
	valor = campo.value;
	punto = valor.indexOf(".");
	if (punto!=-1)
	{
		parada = punto + decimales;
		contador=valor.length;
		cadena.length=contador;
		for (i=0;i<contador;i++)
		{
			cadena[i] = valor.charAt(i);
		}

		a="";
		contador--;



		while (a!="." && contador > parada)
		{

			a=valor.charAt(contador);
			b = Number(a);

			if (a!="."){
			   if (b > 4 && contador > parada )
			   {
					cadena[contador] = 0;
					if (cadena[contador-1]==".")
					{
						if (cadena[contador - 2] < 9)
						{
							cadena[contador-2] = Number(cadena[contador-2]) + 1;
						}


					}
					else
					{
						if (cadena[contador - 1] < 9)
						{
							cadena[contador-1] = Number(cadena[contador-1]) + 1;
						}
					}

				}

			}
			contador--;

		}
		valor="";
		for (i=0;i<cadena.length;i++)
		{
			valor +=String(cadena[i]);
		}
		var temp=String(Number(valor)).substr(0,punto + decimales + 1);
		if (temp.indexOf('.')==0)
			temp="0"+temp;
		campo.value=temp;

	}
}

/**************************************************************************
32.- Funcion: comprobarMillares(valor)
Objetivo: Quita el caracter separador de millar '.'
Entradas: Campo: Es el campo a transformar
Salida:	  El campo transformado ej: 1.000.000 pasa a 1000000
*/


function comprobarMillares(valor)
{
	   cambiarDecimal(valor);


	   ultimo = String(valor.value).lastIndexOf(".");

	   aux="";
	   valorValue=String(valor.value);
	   for (i=0;i<valorValue.length;i++)
	   {
	   		if (i==ultimo)
			{
				aux += ".";
			}
			else
			{
				if (valorValue.charAt(i)!=".")
				{
					aux +=valorValue.charAt(i);
				}
			}
	   }
	   valor.value=aux;

	  return valor;
}

/**************************************************************************
32.- Funcion: equalsIgnoreCase(string1,string2)
Objetivo: Comparar dos cadenas ignorando que sean mayúsculas o minúsculas
Entradas: string1: Primera cadena
					string2: Segunda cadena
Salida:	  true si son iguales y false en caso contrario
*/

function equalsIgnoreCase(string1,string2) {
				 var mays1 = string1.toUpperCase();
				 var mays2 = string2.toUpperCase();
				 if (mays1 == mays2)
				    return true;
				 else
				 		 return false;
}
/**************************************************************************
33.- Funcion: cambiarDecimal(valor)
Objetivo: Cambia el separador decimal ',' por '.'
Entradas: Campo: Es el campo a transformar
Salida:	  El campo transformado ej: 1000,23 -> 1000.23
Nota: esta funcion es utilizada por la funcion comprobarMillares
*/

function cambiarDecimal(valor)
{

       valorAux="";
       for (indiceDecimal=0;indiceDecimal < String(valor.value).length;indiceDecimal++)
        {
                if (String(valor.value).charAt(indiceDecimal) == ',')
                {
                        valorAux += ".";
                }
                else
                {
                        valorAux += String(valor.value).charAt(indiceDecimal);
                }
        }
		valor.value=valorAux;
        return valor;
}
 //*************************************************************************
//
//  Nobre Fichero:   CompruebaFecha.js
//  Proyecto:        INNOVATEL (Fase - II)
//
//  Lenguaje:        JavaScript 1.0
//
//  Autor:           Oriol Pinyana (POLAR)
//
//  Descripcion:     Funcion de chequeo del valor de la fecha, a su vez,
//                   esta se ajusta al patron deseado
//
//  Dependencias:    (ninguna)
//
//  Funciones:       CompruebaFecha
//                   CompruebaFechaOpcional
//                   fechaOK
//                   separardia
//                   separarmes
//                   leftPad
//
//  Ver:  Fecha:    Autor:        Motivo:
//
//  1.0  07-08-98  O. Pinyana    - Creacion
//  1.1  09-09-98  O. Pinyana    - Inclusión de comentarios y reformateo
//
//*************************************************************************

//*************************************************************************
//  form.input ObjFecha           : Objeto Fecha
//  boolean fechaOKServidor       : chequea si ObjFecha es correcta; caso
//                                  contrario, la rectifica y si no es
//                                  posible devuelve un mensaje
//                                  La fecha es OBLIGATORIA
//
function fechavalida2(ObjFecha)
{
 if (ObjFecha.value == "") {
    alert(" Debe introducir una fecha.");
    ObjFecha.focus();
    return false;
 }
 if (fechaOK(ObjFecha) == false) {
    //alert("La fecha no tiene el formato correcto: dd/mm/aaaa");
    ObjFecha.focus();
    return false;
 }

 return true;
} //fechavalida2

//*************************************************************************
//  form.input ObjFecha           : Objeto Fecha
//  boolean fechaOKServidor       : chequea si ObjFecha es correcta; caso
//                                  contrario, la rectifica y si no es
//                                  posible devuelve un mensaje
//                                  La fecha no es obligatoria
//
function CompruebaFechaOpcional(ObjFecha)
{
 if (ObjFecha.value != "") {
    if (fechaOK(ObjFecha) == false) {
       alert("La fecha no tiene el formato correcto: dd/mm/aaaa");
       ObjFecha.focus();
       return false;
    }
 }

 return true;
} //CompruebaFechaOpcional

//*************************************************************************
//  form.input ObjFecha           : fecha
//  boolean fechaOKServidor       : chequea si ObjFecha es correcta; caso
//                                  contrario, la rectifica y si no es
//                                  posible retorna false
//
function fechaOK(ObjFecha)
{
 var tmp = ObjFecha.value ;
 var tipoDia, inicioYear, diames ;
 var dd, mm, a1, a2, a3, a4, aa, aap, aa2 ;
 var x1, x2;
 var bisiesto;

 if (tmp.substring(0,1) == "") {
    return false;
 }

 // día : Recoge el dia segun este acotado, por defecto coge dos digitos
 // tipoDia contiene de que tipo es el dia que se lee

 // Para fechas de la forma: 1/1/1990 || 1/12/1990 || 1/121990
 if (tmp.substring(1,2) == "/" || tmp.substring(1,2) == "-") {
    dd = tmp.substring(0,1) ;
    tipoDia = 1 ;
 }
      // Para fechas de la forma: 12/1/1990 || 12/12/1990 || 12/121990
 else if (tmp.substring(2,3) == "/" || tmp.substring(2,3) == "-") {
         dd = tmp.substring(0,2) ;
         tipoDia = 2 ;
      }
 // Para fechas de la forma: 12121990 || 1212/1990 || 1121990 || 111990
 else {
    dd = tmp.substring(0,2) ;
    tipoDia = 3 ;
 }

 // mes : Recoge el mes segun este acotado, por defecto coge dos digitos
 // En 'inicioYear' colocamos la posicion donde empieza el anyo
 // diames contiene de el tipo de combinacion entre mes y dia
 // diames vale:
 // - 0 : cuando no hay ningun separador
 //       Por tanto no se distinge entre dia, mes y anyo
 // - 1 : cuando hay un solo separador con un solo numero delante
 //       Por tanto no se distinge entre mes y anyo, el primero es
 //       el dia
 // - 2 : cuando hay un solo separador con dos numeros delante
 //       Por tanto no se distinge entre dia, mes y anyo. el mes podria
 //       el segundo numero de delante o el primero de detras
 // - 3 : cuando hay un solo separador con tres numeros delante
 //       Por tanto no se distinge entre dia, mes y anyo
 // - 4 : cuando hay un solo separador con cuatro numeros delante
 // - 5 : cuando hay dos separadores y por tanto la fecha no es ambigua

 // Para fechas de la forma: 1/1/1990 || 121/1990
 if (tmp.substring(3,4) == "/" || tmp.substring(3,4) == "-") {
    mm = tmp.substring(2,3) ;
    inicioYear = 4 ;
    if (tipoDia==3) {  // 121/1990
       diames = 3;
    }
    if (tipoDia==1) {  // 1/1/1990
       diames = 5;
    }
 }
      // Para fechas de la forma: 12/12/1990
 else if ((tmp.substring(5,6) == "/" || tmp.substring(5,6) == "-") &
          (tipoDia == 2)) {
         mm = tmp.substring(3,5) ;
         inicioYear = 6 ;
         diames = 5;
      }
      // Para fechas de la forma: 1/12/1990 || 12/1/1990 || 1212/1990
 else if (tmp.substring(4,5) == "/" || tmp.substring(4,5) == "-") {
         if (tipoDia == 1 || tipoDia == 3) { // 1/12/1990 || 1212/1990
            mm = tmp.substring(2,4) ;
            if (tipoDia == 3) {  // 1212/1990
               diames = 4;
            }
            if (tipoDia == 1) {  // 1/12/1990
               diames = 5;
            }
         }
         else {                // 12/1/1990
            diames = 5;
            mm = tmp.substring(3,4) ;
         }
         inicioYear = 5 ;
      }
      // Para fechas de la forma: 12121990
 else if (tipoDia == 3) {
         mm = tmp.substring(2,4) ;
         inicioYear = 4 ;
         diames = 0;
      }
      // Para fechas de la forma: 12/121990
 else if (tipoDia == 2) {
         mm = tmp.substring(3,5) ;
         inicioYear = 5 ;
         diames = 2;
      }
      // Para fechas de la forma: 1/121990
 else if (tipoDia == 1) {
         mm = tmp.substring(2,4) ;
         inicioYear = 4 ;
         diames = 1;
      }
// En caso contrario es falso
 else {
    return false ;
 }

 // year : Recoge el anyo por digitos

 a1= tmp.substring(inicioYear, inicioYear+1);
 a2= tmp.substring(inicioYear+1, inicioYear+2);
 a3= tmp.substring(inicioYear+2, inicioYear+3);
 a4= tmp.substring(inicioYear+3, inicioYear+4);

 // si alguno de los componentes de la fecha no es un numero devuelve error
 if (isNaN(dd) || isNaN(mm) || isNaN(a1) || isNaN(a2) || isNaN(a3) ||
     isNaN(a4)) {
    return false ;
 }

 // se divide el anyo en dos partes
 aap = a1 + a2;
 aa = a3 + a4;

 // diames == 5 => cuando el anyo esta separado del dia y el mes, por lo tanto
 // ya los tengo ordenados

 if (diames == 5) {
    ;
 }
 // Si no es 5, se tiene que asegurar que se han recogido bien los valores.
 // Para cada caso se comprueba que la combinacion es posible y se asignan
 // los valores correspondientes al dia, al mes y al anyo
 // Si la combinacion no es posible se devuelve un error

      // Cuando ya no existia ningun digito mas, cuatro digitos en total
      // Por tanto: dd = n1, mm = n2 y aap = n3n4
 else if (a1 == "") {
         if (diames == 0 || diames == 2) {
            aap = mm;
            x1 = dd.substring(0, 1);
            x2 = dd.substring(1, 2);
            mm = x2;
            dd = x1;
         }
         else {
            return false ;
         }
      }
      // Caso en el que existia un digito mas
 else if (a2 == "") {
         if (diames == 0 || diames == 1 || diames == 2) {
            x1 = mm.substring(0, 1);
            x2 = mm.substring(1, 2);
            aap = x2 + a1;
            mm = x1;
            if (diames == 0) {
               x1 = dd;
               x2 = mm;
               dd = separardia (x1, x2);
               mm = separarmes (x1, x2);
            }
         }
         else {
            return false ;
         }
      }
      // Caso en el que existian dos digitos mas
 else if (a3 == "") {
         aap = a1 + a2;
         if (diames == 3) {
            x1 = dd;
            x2 = mm;
            dd = separardia (x1, x2);
            mm = separarmes (x1, x2);
         }
         if (diames == 0 || diames == 2) {
            if (mm > 18 & mm < 21) {
               aa = aap;
               aap= mm;
               x1 = dd.substring(0, 1);
               x2 = dd.substring(1, 2);
               mm = x2;
               dd = x1;
            }
         }
      }
      // Caso en el que existian tres digitos mas
 else if (a4 == "") {
         if (diames == 3 || diames == 4) {
            return false ;
         }
         x1 = mm.substring(0, 1);
         x2 = mm.substring(1, 2);
         mm = x1;
         aap = x2 + a1;
         aa = a2 + a3;
         if (diames == 0) {
            x1 = dd;
            x2 = mm;
            dd = separardia (x1, x2);
            mm = separarmes (x1, x2);
         }
      }
      // Caso en el que existian los cuatros digitos posibles
 else {
    aap = a1 + a2;
    aa = a3 + a4;
    if (diames==3) {
       x1 = dd;
       x2 = mm;
       dd = separardia (x1, x2);
       mm = separarmes (x1, x2);
    }
 }

 // Una vez asignados los valores se pasa a la construccion del anyo
 if (aa == "") {
    if (aap == "") {
       aap="0";
    }
    if (aap>80) {
       aa2="19";
    }
    else {
       aa2="20";
    }
    aa = aap;
    aap = aa2;
 }
 aa2 = aap + leftPad(aa, 2, "0");

 // asignamos a la fecha el valor deducido:
 ObjFecha.value = leftPad(dd, 2, "0") + "/" + leftPad(mm, 2, "0") + "/" + aa2 ;

 // Y finalmente comprobamos que se ha obtenido un valor correcto
 if (dd < 1 || dd > 31) {
		error(2,ObjFecha);
		return false;
 }
  if (mm < 1 || mm > 12) {
		error(1,ObjFecha);
		return false;
 }

 bisiesto = (( ((aa2 % 4) == 0) && ((aa2 %100) != 0) ) || ((aa2 %400) == 0) );
 if (mm == 2) {
    if (bisiesto) {
       if (dd > 29) {
	   	  error(12,ObjFecha);
          return false ;
       }
    }
    else {
       if (dd > 28) {
		error(3,ObjFecha);
		return false;
	}
    }
 }
 else {
    if (mm == 4 || mm == 6 || mm == 9 || mm == 11) {
       if (dd > 30) {
	   	  error(4,ObjFecha);
          return false ;
       }
    }
 }

 ObjFecha.value = leftPad(dd, 2, "0") + "/" + leftPad(mm, 2, "0") + "/" + aa2 ;
 return true ;

} //fechaOK

// Método que hace lo mismo qe el método anterior sin sacar alert
function fechaOK_sin_alert(ObjFecha)
{
 var tmp = ObjFecha.value ;
 var tipoDia, inicioYear, diames ;
 var dd, mm, a1, a2, a3, a4, aa, aap, aa2 ;
 var x1, x2;
 var bisiesto;

 if (tmp.substring(0,1) == "") {
    return false;
 }

 // día : Recoge el dia segun este acotado, por defecto coge dos digitos
 // tipoDia contiene de que tipo es el dia que se lee

 // Para fechas de la forma: 1/1/1990 || 1/12/1990 || 1/121990
 if (tmp.substring(1,2) == "/" || tmp.substring(1,2) == "-") {
    dd = tmp.substring(0,1) ;
    tipoDia = 1 ;
 }
      // Para fechas de la forma: 12/1/1990 || 12/12/1990 || 12/121990
 else if (tmp.substring(2,3) == "/" || tmp.substring(2,3) == "-") {
         dd = tmp.substring(0,2) ;
         tipoDia = 2 ;
      }
 // Para fechas de la forma: 12121990 || 1212/1990 || 1121990 || 111990
 else {
    dd = tmp.substring(0,2) ;
    tipoDia = 3 ;
 }

 // mes : Recoge el mes segun este acotado, por defecto coge dos digitos
 // En 'inicioYear' colocamos la posicion donde empieza el anyo
 // diames contiene de el tipo de combinacion entre mes y dia
 // diames vale:
 // - 0 : cuando no hay ningun separador
 //       Por tanto no se distinge entre dia, mes y anyo
 // - 1 : cuando hay un solo separador con un solo numero delante
 //       Por tanto no se distinge entre mes y anyo, el primero es
 //       el dia
 // - 2 : cuando hay un solo separador con dos numeros delante
 //       Por tanto no se distinge entre dia, mes y anyo. el mes podria
 //       el segundo numero de delante o el primero de detras
 // - 3 : cuando hay un solo separador con tres numeros delante
 //       Por tanto no se distinge entre dia, mes y anyo
 // - 4 : cuando hay un solo separador con cuatro numeros delante
 // - 5 : cuando hay dos separadores y por tanto la fecha no es ambigua

 // Para fechas de la forma: 1/1/1990 || 121/1990
 if (tmp.substring(3,4) == "/" || tmp.substring(3,4) == "-") {
    mm = tmp.substring(2,3) ;
    inicioYear = 4 ;
    if (tipoDia==3) {  // 121/1990
       diames = 3;
    }
    if (tipoDia==1) {  // 1/1/1990
       diames = 5;
    }
 }
      // Para fechas de la forma: 12/12/1990
 else if ((tmp.substring(5,6) == "/" || tmp.substring(5,6) == "-") &
          (tipoDia == 2)) {
         mm = tmp.substring(3,5) ;
         inicioYear = 6 ;
         diames = 5;
      }
      // Para fechas de la forma: 1/12/1990 || 12/1/1990 || 1212/1990
 else if (tmp.substring(4,5) == "/" || tmp.substring(4,5) == "-") {
         if (tipoDia == 1 || tipoDia == 3) { // 1/12/1990 || 1212/1990
            mm = tmp.substring(2,4) ;
            if (tipoDia == 3) {  // 1212/1990
               diames = 4;
            }
            if (tipoDia == 1) {  // 1/12/1990
               diames = 5;
            }
         }
         else {                // 12/1/1990
            diames = 5;
            mm = tmp.substring(3,4) ;
         }
         inicioYear = 5 ;
      }
      // Para fechas de la forma: 12121990
 else if (tipoDia == 3) {
         mm = tmp.substring(2,4) ;
         inicioYear = 4 ;
         diames = 0;
      }
      // Para fechas de la forma: 12/121990
 else if (tipoDia == 2) {
         mm = tmp.substring(3,5) ;
         inicioYear = 5 ;
         diames = 2;
      }
      // Para fechas de la forma: 1/121990
 else if (tipoDia == 1) {
         mm = tmp.substring(2,4) ;
         inicioYear = 4 ;
         diames = 1;
      }
// En caso contrario es falso
 else {
    return false ;
 }

 // year : Recoge el anyo por digitos

 a1= tmp.substring(inicioYear, inicioYear+1);
 a2= tmp.substring(inicioYear+1, inicioYear+2);
 a3= tmp.substring(inicioYear+2, inicioYear+3);
 a4= tmp.substring(inicioYear+3, inicioYear+4);

 // si alguno de los componentes de la fecha no es un numero devuelve error
 if (isNaN(dd) || isNaN(mm) || isNaN(a1) || isNaN(a2) || isNaN(a3) ||
     isNaN(a4)) {
    return false ;
 }

 // se divide el anyo en dos partes
 aap = a1 + a2;
 aa = a3 + a4;

 // diames == 5 => cuando el anyo esta separado del dia y el mes, por lo tanto
 // ya los tengo ordenados

 if (diames == 5) {
    ;
 }
 // Si no es 5, se tiene que asegurar que se han recogido bien los valores.
 // Para cada caso se comprueba que la combinacion es posible y se asignan
 // los valores correspondientes al dia, al mes y al anyo
 // Si la combinacion no es posible se devuelve un error

      // Cuando ya no existia ningun digito mas, cuatro digitos en total
      // Por tanto: dd = n1, mm = n2 y aap = n3n4
 else if (a1 == "") {
         if (diames == 0 || diames == 2) {
            aap = mm;
            x1 = dd.substring(0, 1);
            x2 = dd.substring(1, 2);
            mm = x2;
            dd = x1;
         }
         else {
            return false ;
         }
      }
      // Caso en el que existia un digito mas
 else if (a2 == "") {
         if (diames == 0 || diames == 1 || diames == 2) {
            x1 = mm.substring(0, 1);
            x2 = mm.substring(1, 2);
            aap = x2 + a1;
            mm = x1;
            if (diames == 0) {
               x1 = dd;
               x2 = mm;
               dd = separardia (x1, x2);
               mm = separarmes (x1, x2);
            }
         }
         else {
            return false ;
         }
      }
      // Caso en el que existian dos digitos mas
 else if (a3 == "") {
         aap = a1 + a2;
         if (diames == 3) {
            x1 = dd;
            x2 = mm;
            dd = separardia (x1, x2);
            mm = separarmes (x1, x2);
         }
         if (diames == 0 || diames == 2) {
            if (mm > 18 & mm < 21) {
               aa = aap;
               aap= mm;
               x1 = dd.substring(0, 1);
               x2 = dd.substring(1, 2);
               mm = x2;
               dd = x1;
            }
         }
      }
      // Caso en el que existian tres digitos mas
 else if (a4 == "") {
         if (diames == 3 || diames == 4) {
            return false ;
         }
         x1 = mm.substring(0, 1);
         x2 = mm.substring(1, 2);
         mm = x1;
         aap = x2 + a1;
         aa = a2 + a3;
         if (diames == 0) {
            x1 = dd;
            x2 = mm;
            dd = separardia (x1, x2);
            mm = separarmes (x1, x2);
         }
      }
      // Caso en el que existian los cuatros digitos posibles
 else {
    aap = a1 + a2;
    aa = a3 + a4;
    if (diames==3) {
       x1 = dd;
       x2 = mm;
       dd = separardia (x1, x2);
       mm = separarmes (x1, x2);
    }
 }

 // Una vez asignados los valores se pasa a la construccion del anyo
 if (aa == "") {
    if (aap == "") {
       aap="0";
    }
    if (aap>80) {
       aa2="19";
    }
    else {
       aa2="20";
    }
    aa = aap;
    aap = aa2;
 }
 aa2 = aap + leftPad(aa, 2, "0");

 // asignamos a la fecha el valor deducido:
 ObjFecha.value = leftPad(dd, 2, "0") + "/" + leftPad(mm, 2, "0") + "/" + aa2 ;

 // Y finalmente comprobamos que se ha obtenido un valor correcto
 if (dd < 1 || dd > 31) {
		//error(2,ObjFecha);
		return false;
 }
  if (mm < 1 || mm > 12) {
		//error(1,ObjFecha);
		return false;
 }

 bisiesto = (( ((aa2 % 4) == 0) && ((aa2 %100) != 0) ) || ((aa2 %400) == 0) );
 if (mm == 2) {
    if (bisiesto) {
       if (dd > 29) {
	   	  //error(12,ObjFecha);
          return false ;
       }
    }
    else {
       if (dd > 28) {
		//error(3,ObjFecha);
		return false;
	}
    }
 }
 else {
    if (mm == 4 || mm == 6 || mm == 9 || mm == 11) {
       if (dd > 30) {
	   	  //error(4,ObjFecha);
          return false ;
       }
    }
 }

 ObjFecha.value = leftPad(dd, 2, "0") + "/" + leftPad(mm, 2, "0") + "/" + aa2 ;
 return true ;

} //fechaOK_sin_alert


// Método que hace lo mismo qe el método anterior sin sacar alert
function fechaOK_devolviendo_error(ObjFecha)
{
 var resultado = "";
 var tmp = ObjFecha.value ;
 var tipoDia, inicioYear, diames ;
 var dd, mm, a1, a2, a3, a4, aa, aap, aa2 ;
 var x1, x2;
 var bisiesto;

 if (tmp.substring(0,1) == "") {
    resultado = "El día de la fecha está vacío.";
    return resultado;
 }

 // día : Recoge el dia segun este acotado, por defecto coge dos digitos
 // tipoDia contiene de que tipo es el dia que se lee

 // Para fechas de la forma: 1/1/1990 || 1/12/1990 || 1/121990
 if (tmp.substring(1,2) == "/" || tmp.substring(1,2) == "-") {
    dd = tmp.substring(0,1) ;
    tipoDia = 1 ;
 }
      // Para fechas de la forma: 12/1/1990 || 12/12/1990 || 12/121990
 else if (tmp.substring(2,3) == "/" || tmp.substring(2,3) == "-") {
         dd = tmp.substring(0,2) ;
         tipoDia = 2 ;
      }
 // Para fechas de la forma: 12121990 || 1212/1990 || 1121990 || 111990
 else {
    dd = tmp.substring(0,2) ;
    tipoDia = 3 ;
 }

 // mes : Recoge el mes segun este acotado, por defecto coge dos digitos
 // En 'inicioYear' colocamos la posicion donde empieza el anyo
 // diames contiene de el tipo de combinacion entre mes y dia
 // diames vale:
 // - 0 : cuando no hay ningun separador
 //       Por tanto no se distinge entre dia, mes y anyo
 // - 1 : cuando hay un solo separador con un solo numero delante
 //       Por tanto no se distinge entre mes y anyo, el primero es
 //       el dia
 // - 2 : cuando hay un solo separador con dos numeros delante
 //       Por tanto no se distinge entre dia, mes y anyo. el mes podria
 //       el segundo numero de delante o el primero de detras
 // - 3 : cuando hay un solo separador con tres numeros delante
 //       Por tanto no se distinge entre dia, mes y anyo
 // - 4 : cuando hay un solo separador con cuatro numeros delante
 // - 5 : cuando hay dos separadores y por tanto la fecha no es ambigua

 // Para fechas de la forma: 1/1/1990 || 121/1990
 if (tmp.substring(3,4) == "/" || tmp.substring(3,4) == "-") {
    mm = tmp.substring(2,3) ;
    inicioYear = 4 ;
    if (tipoDia==3) {  // 121/1990
       diames = 3;
    }
    if (tipoDia==1) {  // 1/1/1990
       diames = 5;
    }
 }
      // Para fechas de la forma: 12/12/1990
 else if ((tmp.substring(5,6) == "/" || tmp.substring(5,6) == "-") &
          (tipoDia == 2)) {
         mm = tmp.substring(3,5) ;
         inicioYear = 6 ;
         diames = 5;
      }
      // Para fechas de la forma: 1/12/1990 || 12/1/1990 || 1212/1990
 else if (tmp.substring(4,5) == "/" || tmp.substring(4,5) == "-") {
         if (tipoDia == 1 || tipoDia == 3) { // 1/12/1990 || 1212/1990
            mm = tmp.substring(2,4) ;
            if (tipoDia == 3) {  // 1212/1990
               diames = 4;
            }
            if (tipoDia == 1) {  // 1/12/1990
               diames = 5;
            }
         }
         else {                // 12/1/1990
            diames = 5;
            mm = tmp.substring(3,4) ;
         }
         inicioYear = 5 ;
      }
      // Para fechas de la forma: 12121990
 else if (tipoDia == 3) {
         mm = tmp.substring(2,4) ;
         inicioYear = 4 ;
         diames = 0;
      }
      // Para fechas de la forma: 12/121990
 else if (tipoDia == 2) {
         mm = tmp.substring(3,5) ;
         inicioYear = 5 ;
         diames = 2;
      }
      // Para fechas de la forma: 1/121990
 else if (tipoDia == 1) {
         mm = tmp.substring(2,4) ;
         inicioYear = 4 ;
         diames = 1;
      }
// En caso contrario es falso
 else {
    resultado = "Fecha incorrecta.";
    return resultado;
 }

 // year : Recoge el anyo por digitos

 a1= tmp.substring(inicioYear, inicioYear+1);
 a2= tmp.substring(inicioYear+1, inicioYear+2);
 a3= tmp.substring(inicioYear+2, inicioYear+3);
 a4= tmp.substring(inicioYear+3, inicioYear+4);

 // si alguno de los componentes de la fecha no es un numero devuelve error
 if (isNaN(dd) || isNaN(mm) || isNaN(a1) || isNaN(a2) || isNaN(a3) ||
     isNaN(a4)) {
    resultado = "Alguno de los campos no es un número.";
    return resultado;
 }

 // se divide el anyo en dos partes
 aap = a1 + a2;
 aa = a3 + a4;

 // diames == 5 => cuando el anyo esta separado del dia y el mes, por lo tanto
 // ya los tengo ordenados

 if (diames == 5) {
    ;
 }
 // Si no es 5, se tiene que asegurar que se han recogido bien los valores.
 // Para cada caso se comprueba que la combinacion es posible y se asignan
 // los valores correspondientes al dia, al mes y al anyo
 // Si la combinacion no es posible se devuelve un error

      // Cuando ya no existia ningun digito mas, cuatro digitos en total
      // Por tanto: dd = n1, mm = n2 y aap = n3n4
 else if (a1 == "") {
         if (diames == 0 || diames == 2) {
            aap = mm;
            x1 = dd.substring(0, 1);
            x2 = dd.substring(1, 2);
            mm = x2;
            dd = x1;
         }
         else {
            resultado = "Fecha incorrecta.";
    		return resultado;
         }
      }
      // Caso en el que existia un digito mas
 else if (a2 == "") {
         if (diames == 0 || diames == 1 || diames == 2) {
            x1 = mm.substring(0, 1);
            x2 = mm.substring(1, 2);
            aap = x2 + a1;
            mm = x1;
            if (diames == 0) {
               x1 = dd;
               x2 = mm;
               dd = separardia (x1, x2);
               mm = separarmes (x1, x2);
            }
         }
         else {
            resultado = "Fecha incorrecta.";
    		return resultado;
         }
      }
      // Caso en el que existian dos digitos mas
 else if (a3 == "") {
         aap = a1 + a2;
         if (diames == 3) {
            x1 = dd;
            x2 = mm;
            dd = separardia (x1, x2);
            mm = separarmes (x1, x2);
         }
         if (diames == 0 || diames == 2) {
            if (mm > 18 & mm < 21) {
               aa = aap;
               aap= mm;
               x1 = dd.substring(0, 1);
               x2 = dd.substring(1, 2);
               mm = x2;
               dd = x1;
            }
         }
      }
      // Caso en el que existian tres digitos mas
 else if (a4 == "") {
         if (diames == 3 || diames == 4) {
            resultado = "Fecha incorrecta.";
    		return resultado;
         }
         x1 = mm.substring(0, 1);
         x2 = mm.substring(1, 2);
         mm = x1;
         aap = x2 + a1;
         aa = a2 + a3;
         if (diames == 0) {
            x1 = dd;
            x2 = mm;
            dd = separardia (x1, x2);
            mm = separarmes (x1, x2);
         }
      }
      // Caso en el que existian los cuatros digitos posibles
 else {
    aap = a1 + a2;
    aa = a3 + a4;
    if (diames==3) {
       x1 = dd;
       x2 = mm;
       dd = separardia (x1, x2);
       mm = separarmes (x1, x2);
    }
 }

 // Una vez asignados los valores se pasa a la construccion del anyo
 if (aa == "") {
    if (aap == "") {
       aap="0";
    }
    if (aap>80) {
       aa2="19";
    }
    else {
       aa2="20";
    }
    aa = aap;
    aap = aa2;
 }
 aa2 = aap + leftPad(aa, 2, "0");

 // asignamos a la fecha el valor deducido:
 ObjFecha.value = leftPad(dd, 2, "0") + "/" + leftPad(mm, 2, "0") + "/" + aa2 ;

 // Y finalmente comprobamos que se ha obtenido un valor correcto
 if (dd < 1 || dd > 31) {
		resultado = "El día de la fecha no es correcto.";
		return resultado;
 }
  if (mm < 1 || mm > 12) {
		resultado = "El mes de la fecha no es correcto.";
		return resultado;
 }

 bisiesto = (( ((aa2 % 4) == 0) && ((aa2 %100) != 0) ) || ((aa2 %400) == 0) );
 if (mm == 2) {
    if (bisiesto) {
       if (dd > 29) {
	   	  resultado = "El año "+ aa2 +" es bisiesto pero como mucho tiene 28 días.";
		  return resultado;
       }
    }
    else {
       if (dd > 28) {
		resultado = "El año "+ aa2 +" no es bisiesto y como mucho tiene 28 días.";
		return resultado;
	}
    }
 }
 else {
    if (mm == 4 || mm == 6 || mm == 9 || mm == 11) {
       if (dd > 30) {
	   	  resultado = "Abril, Junio, Septiembre y Noviembre solo tienen 30 días.";
		  return resultado;
       }
    }
 }

 if (aa2 <= 1900) {
 	resultado = "La año de la fecha no puede menor a 1900";
	return resultado;
 }

 ObjFecha.value = leftPad(dd, 2, "0") + "/" + leftPad(mm, 2, "0") + "/" + aa2 ;
 return resultado ;

} //fechaOK


//*************************************************************************
//  Estas dos funciones: 'separardia' y 'separarmes'se usan conjuntamente
//  para el caso en que entre el dia y el mes tienen tres digitos y se
//  debe distinguir cual de los dos tienen dos digitos y cual uno.
//  Existen muy pocos casos con ambiguedad:
//  Por ejemplo: '111' = 1/11 o 11/1 . Y '112', '211', '212' y '312'

//*************************************************************************
//  dd                            : cadena
//  mm                            : cadena
//  string separardia             : coloca en 'dd' el valor correctodel dia
//                                  teniendo en cuenta los posibles valores
//                                  de los dias y de los meses
//
function separardia(dd, mm)
{
 var diap;

 diap = dd.substring(0, 1);

 if ((diap>3) || (diap == 3 & mm == 2) || (mm==0)) {
    return diap;
 }
 else {
    return dd;
 }

} //separardia

//*************************************************************************
//  dd                            : cadena
//  mm                            : cadena
//  string separarmes             : coloca en 'mm' el valor correcto del mes
//                                  teniendo en cuenta los posibles valores
//                                  de los dias y de los meses
//
function separarmes(dd, mm)
{
 var diap;
 var diaomes;
 var mes;

 diap = dd.substring(0, 1);
 diaomes = dd.substring(1, 2);

 if ((diap>3) || (diap==3 & mm==2) || (mm==0)) {
    mes = diaomes + mm;
    return mes;
 }
 else {
    return mm;
 }

} //separarmes

//*************************************************************************
//  s                             : cadena
//  iCharsToPad                   : entero
//  sNewChar                      : caracter
//  string leftPad                : anyade el caracter 'sNewChar' delante
//                                  de la cadena 's' hasta que esta tiene
//                                  la longitud 'iCharsToPad'
//
function leftPad(s, iCharsToPad, sNewChar)
{
 var iLenOfS = s.length ;
 var i ;
 var sNewS = "" ;

 iCharsToPad -= iLenOfS;
 while (iCharsToPad--) {
    sNewS += sNewChar ;
 }
 sNewS += s ;

 return sNewS ;

} //leftPad

/**
* Funcion por Fernando Palomar
* Comprueba que un textField tenga un numero con nDecimales
* @param fieldName, campo de Texto
* @param fieldValue, el valor del campo de texto
* @param nDecimales, es el numero de decimales permitidos
*/
function checkDecimals(fieldName, fieldValue, nDecimales) {
	decimals = nDecimales;  // how many decimals are allowed?

	if (isNaN(fieldValue)) {
		alert(fieldValue+" no es un Número");
		fieldName.select();
		fieldName.focus();
	} else {
		timeshundred = parseFloat(fieldValue * Math.pow(10, decimals));
		integervalue = parseInt(parseFloat(fieldValue) * Math.pow(10, decimals));
		if (timeshundred != integervalue) {
			alert (" Debe introducir un número con " + decimals + " decimales como máximo.");
			fieldName.select();
			fieldName.focus();
      	}
   	}
}

function fechavalida2_sin_alert(ObjFecha)
{
	if (ObjFecha.value == "")
	{
		ObjFecha.focus();
		return false;
	}
 	if (fechaOK_sin_alert(ObjFecha) == false)
	{
		ObjFecha.focus();
		return false;
 	}
 	return true;
}

function fechavalida2_devolviendo_error(ObjFecha)
{
	var resultado = ""
	if (ObjFecha.value == "")
	{
		resultado = "La fecha está vacía";
		return resultado;
	}
	resultado = fechaOK_devolviendo_error(ObjFecha);
 	return resultado;
}


function fechaPosteriorActual(campoFecha) {
		var r = true;

		var anyoDesde = parseInt(campoFecha.value.substring(6,10),10);
		var mesDesde = parseInt(campoFecha.value.substring(3,5),10);
		var diaDesde = parseInt(campoFecha.value.substring(0,2),10);

		var actual=new Date();
		var anyoActual = actual.getYear();
		var mesActual = actual.getMonth() + 1;
		var diaActual = actual.getDate();

		// Se comprueba el Año
		if (anyoActual < anyoDesde)
			r = false;
		else if (anyoActual == anyoDesde){
			// Se comprueba el Mes
			if (mesActual < mesDesde)
				r = false;
			else if (mesActual == mesDesde){
				// Se comprueba el Dia
				if ( eval(diaActual < diaDesde) )
					r = false;
			}
		}
	    if (!r) error(20,campoFecha);
		return r;
}
function fechaAnteriorActual(campoFecha) {
	var r = true;
	var anyoDesde = parseInt(campoFecha.value.substring(6,10),10);
	var mesDesde = parseInt(campoFecha.value.substring(3,5),10);
	var diaDesde = parseInt(campoFecha.value.substring(0,2),10);

	var actual=new Date();
	var anyoActual = actual.getYear();
	var mesActual = actual.getMonth() + 1;
	var diaActual = actual.getDate();

	// Se comprueba el Año
	if (anyoActual > anyoDesde)
		r = false;
	if (anyoActual == anyoDesde){
		// Se comprueba el Mes
		if ( eval(mesActual > mesDesde) )
			r = false;
		if ( eval(mesActual == mesDesde) ){
			// Se comprueba el Dia
			if ( eval(diaActual > diaDesde) )
				r = false;
		}
	}
    if (!r) error(21,campoFecha);
	return r;
}

function pausa(){
	try {
		capaEspera.style.width=document.body.scrollWidth;
		capaEspera.style.height=document.body.scrollHeight;
		capaEspera.style.top=document.body.scrollTop;
		capaEspera.style.visibility='visible';
	}catch (exception) {

	}
	return true;
}


//*************************************************************************
// Esta función lo que hace es convertir los caracteres especiales a un
// conjunto de caracteres unicode para que el explorador lo interprete
// correctamente. Por ejemplo si un jsp llama a otro jsp con un parámetro
// cuyo valor es precisamente el caracter '&', el explorador deja de
// interpretar correctamente lo que se recibe. Esta función sustituye esos
// caracteres especiales por la cadena unicode correspondiente
//*************************************************************************
function URLEncode(textoPlano)
{

        var SAFECHARS = "0123456789" +                          // Numeric
                        "ABCDEFGHIJKLMNOPQRSTUVWXYZ" +  	// Alphabetic
                        "abcdefghijklmnopqrstuvwxyz" +
                        "-_.!~*'()";                            // RFC2396 Mark characters
        var HEX = "0123456789ABCDEF";

        var resultado = "";
        for (var i = 0; i < textoPlano.length; i++ )
        {
        	var ch = textoPlano.charAt(i);
            	if (ch == " ")
            	{
                	resultado += "+";                             // x-www-urlencoded, rather than %20
                }
                else if (SAFECHARS.indexOf(ch) != -1)
                {
                    resultado += ch;
                }
                else
                {
                    var charCode = ch.charCodeAt(0);
                    if (charCode > 255)
                    {
                    	//Si el caracter es desconocido, se sustituye por un blanco.
                    	resultado += "+";
                    }
                     else
                     {
                     	resultado += "%";
                       	resultado += HEX.charAt((charCode >> 4) & 0xF);
                        resultado += HEX.charAt(charCode & 0xF);
                      }
                }
        } // for

        return resultado;
}

//*************************************************************************
// Función que quita blancos, retornos de carro y tabulaciones
//*************************************************************************
function quitar_blancos_retornoCarro(campo)
{
var textocon=campo.value;
var textosin="";
var longit = textocon.length;
for (var i=0;i<longit;i++)
	{
	var letra = textocon.charAt(i);
	if ((letra!=' ')&&(letra!="\t")&&(letra!="\n")&&(letra!="\r"))
	{
		textosin = textosin + letra;
	}
	else
		if ((textocon.charAt(i+1) != " ")&&(letra!="\t")&&(letra!="\n")&&(letra!="\r"))
		{
			textosin=textosin + letra;
		}
	}
if (textosin.charAt(0)==" ")
	textosin=textosin.substring(1,(textosin.length) );
if (textosin.charAt(textosin.length-1)==" ")
		textosin=textosin.substring(0,(textosin.length-1));
return (textosin);
}

// Función que quita retornos de carro y tabulaciones (no blancos)
function quitar_retornoCarro(campo)
{
var textocon=campo.value;
var textosin="";
var longit = textocon.length;
for (var i=0;i<longit;i++)
	{
	var letra = textocon.charAt(i);
	if ((letra!="\t")&&(letra!="\n")&&(letra!="\r"))
	{
		textosin = textosin + letra;
	}
	else
		if ((letra!="\t")&&(letra!="\n")&&(letra!="\r"))
		{
			textosin=textosin + letra;
		}
	}
return (textosin);
}

// Método que comprueba que no se han sobrepasado una cantidad de caracteres
function comprobarLongitud(campo,maxLong)
{
	var lon = campo.value.length;
    if (lon>maxLong) {
    	campo.value = campo.value.substring(0,maxLong);
        campo.blur();
    }
}

function contiene_caracter(campo,car)
{
    var cad=campo.value;
    var longit = cad.length;
    for (var i=0;i<longit;i++)
        {
        var letra = cad.charAt(i);
        if (letra == car)
            return true;
        }
    return false;
}

function tieneCaracteresNoPermitidos(campo)
{
    var cad=campo.value;
    var longit = cad.length;
    for (var i=0;i<longit;i++)
    {
        var letra = cad.charAt(i);
        if ((letra == "'") || (letra == "\""))
            return true;
    }
    return false;
}

/**
 * Comprobación de la validez de las fechas en filtros y detalle.
 * Además, se utiliza la capa de error para mostrar los mensajes generados.
 */
function checkFecha ( objFecha, bShowAlert )
{
    objFecha.value = quitar_blancos ( objFecha );
    if ( objFecha.value == "" )
        return;

    var strResult = fechaOK_devolviendo_error ( objFecha );
    if (( strResult != "" ) && ( bShowAlert == true ))
    {
        mostrarCapaError ( strResult ,false);
    }
}

// ******************************************
// Devuelve elementos con un id determinado *
// ******************************************
function getElementsById (id) {
    if (document.all) {
        var els = document.all[id];
        if (typeof els == 'undefined')
          return [];
        else if (!els.length)
          return [els];
        else
          return els;
    } else if (document.getElementsByTagName) {
        var all = document.getElementsByTagName('*');
        var els = [];
        for (var i = 0; i < all.length; i++)
          if (all[i].id == id)
            els[els.length] = all[i];
        return els;
    }
}