/*-----------------------------------------------------------------------------------------------------
	'Descripción : Funcion Trim de Vb que elimina espacios de una cadena.
	'Entradas : Cadena que se quiere tratar
	'Salidas: Devuelve la cadena sin ningun espacio.
	'Observaciones: Con una cadena en blanco la funcion devuelve True. 
	'------------------------------------------------------------------------------------------------------*/  	
	function Trim(strValor) 	{	   
	var strAux = new String();	

		for (var i = 0; i < strValor.length; i++)  {			
			if(strValor.charAt(i) != ' ') strAux += strValor.charAt(i);			
		}

		return strAux;
	}
	
	/*-----------------------------------------------------------------------------------------------------
	'Descripción : Comprueba si una cadena no contiene caracteres.
	'Entradas : Cadena que se quiere tratar
	'Salidas: True / False
	'Observaciones: 
	'------------------------------------------------------------------------------------------------------*/  	
	function ValidarCadenaVacia(strValor) 	{	   	
			return (Trim(strValor) == "")
	}
	
	
	/*-----------------------------------------------------------------------------------------------------
	'Descripción : Indica si un valor es numérico
	'Entradas :Valor que se quiere tratar
	'Salidas: True/False
	'Observaciones: Con una cadena en blanco la funcion devuelve True. 
	'------------------------------------------------------------------------------------------------------*/
   function EsNumero(strValor)   {
   var blnResult = true;
   
      strValor = Trim(strValor)       
 
      for (var i=0; i < strValor.length && blnResult ; i++) {
          if (strValor.charAt(i) < '0' || strValor.charAt(i) > '9')
             blnResult = false;
      }
      
      return blnResult; 
	}   
	/*-----------------------------------------------------------------------------------------------------
	'Descripción : Indica si un valor es numérico (Admite decimales)
	'Entradas :Valor que se quiere tratar
	'Salidas: True/False
	'Observaciones: Con una cadena en blanco la funcion devuelve True. 
	'------------------------------------------------------------------------------------------------------*/
	function ValidarNumero(strValor)	{
	var blnResult = true;
	
		//strValor = Trim(strValor)
		//for (var i=0; i < strValor.length && blnResult; i++)	{
		//	if (strValor.charAt(i) < '0' || strValor.charAt(i) > '9')
		//		blnResult = false;
		//}
		
		if (isNaN(strValor)) blnResult = false;
		
		return blnResult;
	}
	/*-----------------------------------------------------------------------------------------------------
	'Descripción : Indica si un valor es numérico (Admite coma y punto)
	'Entradas :Valor que se quiere tratar
	'Salidas: True/False
	'Observaciones: Con una cadena en blanco la funcion devuelve True. 
	'------------------------------------------------------------------------------------------------------*/
	function ValidarNumeroConDecimales(strValor)	{
	var blnResult = true;
	var numeropuntosycomas
	
		strValor = Trim(strValor)
		numeropuntosycomas = 0
		for (var i=0; i < strValor.length && blnResult; i++)	
		{
			if (strValor.charAt(i) < '0' || strValor.charAt(i) > '9')
				{
				if (strValor.charAt(i) != '.' && strValor.charAt(i) != ',')
					blnResult = false
				else 	
					numeropuntosycomas = numeropuntosycomas + 1;
				}
		}
		if (numeropuntosycomas > 1)
		{
			blnResult = false
		}	
		return blnResult;
	}
	
	//////////////////////////////////////////////////////////////////////////////////////////////
	// NOMBRE: es_bisiesto
	// FUNCION: Comprueba que un año es bisiesto.
	// PARAMETROS: Un número con el año a comprobar.
	// RETORNO: True si es bisiesto, false en caso contrario.
	// COMENTARIO: 
	function es_bisiesto (anno)
	{
		var resultado;
		
		resultado=false;
		// Para que sea bisiesto debe ser divisible entre cuatro
		if ((anno % 4)==0)
			{
			 resultado=true;
			 // ¿ Es un fin de siglo ?
			 if ((anno % 100)==0)
				{


					// Si es un fin de siglo es bisiesto tan solo si es múltiplo
					// de 400
					if ((anno % 400)==0)
						resultado=true;
					else
						resultado=false;
				}
			}
		return (resultado);
	}




	//////////////////////////////////////////////////////////////////////////////////////////////
	// NOMBRE: ValidarFecha
	// FUNCION: Comprueba que una cadena contiene una fecha válida.
	// PARAMETROS: Una cadena que debe tener una fecha. 
	// RETORNO: True si la fecha esté correcta o bien false en caso contrario.
	// COMENTARIO: Asume que la fecha tiene uno de estos dos formatos:
	// dd/mm/aaaa (El formato dd-mm-aaaa no se acepta).
	function ValidarFecha (cad_fecha)
	{
		var matriz;		
		var resultado;		// valor de retorno
		var i_numero_dias;	// Array con el número de días.
		var i_annos;
		var i_meses;
		var i_dias;	
		resultado=true;
		
		i_numero_dias=new Array ();
		matriz		 =new Array ();
		
		// Asignación de los número de días que tienen los meses.
		i_numero_dias[0]=31;
		i_numero_dias[1]=28;			
		i_numero_dias[2]=31;
		i_numero_dias[3]=30;
		i_numero_dias[4]=31;
		i_numero_dias[5]=30;
		i_numero_dias[6]=31;
		i_numero_dias[7]=31;
		i_numero_dias[8]=30;
		i_numero_dias[9]=31;
		i_numero_dias[10]=30;
		i_numero_dias[11]=31;
		
		// Se divide la cadena en sus componentes 
		matriz=cad_fecha.split ("/");	
		
		// ¿ División con exito ?
		if (matriz.length<=1)
		{
			// Se intenta la división usando como caracter separador el 
			// guion.
			matriz=cad_fecha.split ("-");
		}
		
		if (isNaN(matriz [2]))
			resultado=false;
		if (isNaN(matriz [1]))
			resultado=false;
		if (isNaN(matriz [0]))
			resultado=false;
			
		// ¿ Alguna de las dos separaciones ha tenido éxito ?
		if (resultado==true)
		{
			if (matriz.length==3)
				{
				
				eval ("i_annos="+matriz [2]+";");
				eval ("i_meses="+matriz [1]+";");
				eval ("i_dias="+matriz [0]+";");		
				
				// Años...
				if ((i_annos>2100) || (i_annos<1900))
						resultado=false;
				else 
					{
					// Si el año está correcto ajustamos el número de días
					// de febrero si el año es bisiesto
					if (es_bisiesto (i_annos))
						i_numero_dias [1]=29;
								
					// Meses
					if ((i_meses<1) || (i_meses>12))
						resultado=false;
						
					// Dias, validación del número de días.
					if (resultado)
						if ((i_dias<1) || (i_dias>i_numero_dias [i_meses-1]))
							resultado=false;
					}
				}
			else 
				// La división en cadenas ha dado como resultado
				resultado=false;
		}
			
		return (resultado);
	}

	/*-----------------------------------------------------------------------------------------------------
	'Descripción : Indica si un combo tiene seleccionada la opcion vacia
	'Entradas : El value del option seleccionado
	'Salidas: True/False
	'Observaciones: Para que funcione se tiene que usar la funcion rellenacombo que pone un 
					cero en el option vacio
	'------------------------------------------------------------------------------------------------------*/
	function ValidarComboVacio(optionvalue)
	{
		return (optionvalue != 0)
	}
	/*-----------------------------------------------------------------------------------------------------
	'Descripción : Valida que el dni sea correcto
	'Entradas : sCadena
	'Salidas: True/False
	'Observaciones:
	'------------------------------------------------------------------------------------------------------*/
function ValidarDNI(sCadena)
	{		
		var iContador;
		var iLongitud;
		
		//Si la variable sCadena no está vacía
		if (sCadena != "")
		{
			iLongitud = sCadena.length;
			//Recorremos la cadena carácter a carácter
			for (iContador=0;iContador < iLongitud;iContador++)
			{
				//Si encontramos un carácter que no sea un número...
				if (isNaN(parseInt(sCadena.charAt(iContador))))			
				{
					//...advertimos al usuario que no se pueden introducir letras
					alert ("Introduzca un DNI correcto (sólo números)");
					return (false);
				}
				//Si no
				else
				{
					//Si llegamos al final de la cadena...
					if (iContador == iLongitud-1)
					{
						//...y la longitud es menor de 7
						if (iLongitud < 7)
						{
							//Mostramos mensaje advirtiendo que el campo no puede tener
							//una longitud menor de 7
							alert ("Introduzca un DNI correcto (mínimo 7 dígitos)");
							return (false);
						}					
					}	
				}
			}
		}
		return (true);
	}

   /*-----------------------------------------------------------------------------------------------------
	'Descripción : Valida que el codigo postal sea correcto
	'Entradas : sCadena
	'Salidas: True/False
	'Observaciones: 
	'------------------------------------------------------------------------------------------------------*/
	function ValidarCodigoPostal( sCadena)
	{
		
		var iLongitud; 
		var iContador;
		
		//Si la variable sCadena no está vacía
		if (sCadena != "")
		{
			iLongitud = sCadena.length;
			//Recorremos la cadena carácter a carácter
			for (iContador=0;iContador < iLongitud;iContador++)
			{
				//Si encontramos un carácter que no sea un número...
				if (isNaN(parseInt(sCadena.charAt(iContador))))			
				{
					//...advertimos al usuario que no se pueden introducir letras
					alert ("Introduzca un Código Postal correcto (sólo números)");
					return (false);
				}
				//Si no
				else
				{
					//Si llegamos al final de la cadena...
					if (iContador == iLongitud-1)
					{
						//...y la longitud es menor de 5
						if (iLongitud != 5)
						{
							//Mostramos mensaje advirtiendo que el campo no puede tener
							//una longitud menor de 5
							alert ("Introduzca un Código Postal correcto (5 dígitos)");
							return (false);
						}					
					}	
				}
			}
		}
		return (true);
	}

   /*-----------------------------------------------------------------------------------------------------
	'Descripción : Valida que el telefono sea correcto
	'Entradas : sCadena
	'Salidas: True/False
	'Observaciones: 
	'------------------------------------------------------------------------------------------------------*/
	function ValidarTelefono(sCadena)
	{		
		var iLongitud; 
		var iContador;
		
		//Si la variable sCadena no está vacía
		if (sCadena != "")

		{
			iLongitud = sCadena.length;
			//Recorremos la cadena carácter a carácter
			for (iContador=0;iContador < iLongitud;iContador++)
			{
				//Si encontramos un carácter que no sea un número...
				if (isNaN(parseInt(sCadena.charAt(iContador))))			
				{
					//...advertimos al usuario que no se pueden introducir letras
						alert ("Introduzca un Teléfono correcto (sólo números)");
						return (false);
				}
				//Si no
				else
				{	
					//Si el primer dígito no es un 6 o un 9 mostramos mensaje de error
					if (iContador == 0)
					{
						if ((sCadena.charAt(iContador)!=6)&&(sCadena.charAt(iContador)!=9))
						{
								alert ("Introduzca un Teléfono correcto (debe comenzar por 6 o por 9)");
								return (false);
						}	
					}	
							
					//Si llegamos al final de la cadena
					if (iContador == iLongitud-1)
					{
						//Si la longitud es menor de 9
						if (iLongitud < 9)
						{
							//Mostramos mensaje advirtiendo que el campo no puede tener
							//una longitud menor de 9							
								alert ("Introduzca un Teléfono  correcto (mínimo 9 dígitos)");
								return (false);
							
						}					
					}	
				}
			}
		}
		return (true);
	}

/*-----------------------------------------------------------------------------------------------------
	'Descripción : Valida que el formato de la dirección de correo.
	'Entradas : sCadena
	'Salidas: True/False
	'Observaciones: 
	'------------------------------------------------------------------------------------------------------*/
	function ValidarEMail(sCadena)
	{		
		var iLongitud; 
		var iContador;

		//Si la variable sCadena no está vacía
		if (sCadena != "")
		{
			iLongitud = sCadena.length;
			//Recorremos la cadena carácter a carácter
			for (iContador=0;iContador < iLongitud;iContador++)
			{
				//Si no encontramos el carácter "@"
				if ((sCadena.charAt(iContador)!= "@"))
				{	
					//Si hemos llegado al final de la cadena
					if (iContador == iLongitud-1)
					{
						//Advertimos al usuario que el E-Mail debe contener el carácter "@"
						alert ("Introduzca una dirección de e-mail correcta");
						return (false);
					}
				}
				else
				{
					return(true);
				}						
			}
		}		
		return(true)
	}

/*-----------------------------------------------------------------------------------------------------
'Descripción : Funci¢n que analiza un cif/nif y devuelve si es erroneo
'Entradas : Cadena con el cif/nif a validar
'Salidas: Devuelve la cadena sin ningun espacio
'Observaciones: esta funcion llama a ValidarCIF para comprobar si se trata de un cif
'Autor: FCR 12/12/2000
'------------------------------------------------------------------------------------------------------*/  	
function ValidarDNINIF(cifnif)
{
	var vnif,vdni
	var letranif,numero,letra
	
	cifnif = TrimJS(cifnif);		
	cifnif = cifnif.toUpperCase();
	letranif = cifnif.substr(0,1);

	if (isNaN(letranif))
	{
		if (letranif != "X" && letranif != "Z")
		{
			if (!ValidarCIF(cifnif))
			{
				//alert("El CIF no es correcto")
				return false
			}
			else
			{
				return true
			}
		}
		else
		{
			cifnif = cifnif.substr(1);
		}
	}
	vdni=cifnif.substr(0,cifnif.length-1) //Numeros del DNI
	if (vdni.length > 9) 
	{
//		alert("El NIF no puede tener mas de 8 números")
		return false
	}
	vnif=cifnif.substr(cifnif.length-1,1); //Letra del DNI
	numero=vdni - Math.round(vdni / 23) * 23; //Calculo de la letra
	if (numero < 0) // esto es por que al redondear suma uno y hay que corregirlo
		numero += 23; // sumamos 23 porque se multiplico el 1 que sumamos por 23
	switch (numero)
	{
		case 0: 
		{	letra="T";
			break;
		}
		case 1: 
		{	letra="R";
			break;
		}
		case 2: 
		{	letra="W";
			break;
		}
		case 3: 
		{	letra="A";
			break;
		}
		case 4: 
		{	letra="G";
			break;
		}
		case 5: 
		{	letra="M";
			break;
		}
		case 6: 
		{	letra="Y";
			break;
		}
		case 7: 
		{	letra="F";
			break;
		}
		case 8: 
		{	letra="P";
			break;
		}
		case 9: 
		{	letra="D";
			break;
		}
		case 10: 
		{	letra="X";
			break;
		}
		case 11: 
		{	letra="B";
			break;
		}
		case 12: 
		{	letra="N";
			break;
		}
		case 13: 
		{	letra="J";
			break;
		}
		case 14: 
		{	letra="Z";
			break;
		}
		case 15: 
		{	letra="S";
			break;
		}
		case 16: 
		{	letra="Q";
			break;
		}
		case 17: 
		{	letra="V";
			break;
		}
		case 18: 
		{	letra="H";
			break;
		}
		case 19: 
		{	letra="L";
			break;
		}
		case 20: 
		{	letra="C";
			break;
		}
		case 21: 
		{	letra="K";
			break;
		}
		case 22: 
		{	letra="E";
			break;
		}
	}
	if (letra != vnif)
	{
	//	alert("Los datos del nif no son correctos")
		return false
	}
	return true
}
/*-----------------------------------------------------------------------------------------------------
'Descripción : Funcion que comprueba si una cadena es un cif correcto
'Entradas : Cadena con el cif a validar
'Salidas: Devuelve la cadena sin ningun espacio
'Observaciones: utiliza una serie de alert's si falla
'Autor: FCR 12/12/2000
'------------------------------------------------------------------------------------------------------*/  	
function ValidarCIF(cif)
{
	var cadenacif = new Array("A","B","C","D","E","F","G","H","I","J")
	var arrcif = new Array(9)
	var aux1
	var aux2
	var i
	var digito
	
	for (i=0;i<=8;i++)
	{ 
		arrcif[i] = (cif.substr(i,1) - 1) + 1;
	}
	
	aux1 = arrcif[2] + arrcif[4] + arrcif[6]
	aux2 = suma_impares(arrcif[1]) + suma_impares(arrcif[3]) + suma_impares(arrcif[5]) + suma_impares(arrcif[7])
	aux1 = aux1 + aux2
	digito = 10 - (aux1%10)
	if (cadenacif[digito-1] == cif.substr(8,1))
	{
		return (true)
	}
	else
	{
		if (!isNaN(cif.substr(8,1)))
		{
			if (digito == 10) digito=0;
			return (digito==arrcif[8])
		}
		else
		{
			return (false)
		}
	}
}
function suma_impares(ndigito)
{
   var nsuma
   nsuma = ndigito * 2
   if (nsuma >= 10) nsuma = (nsuma%10) + 1;
   return nsuma
}
/*-----------------------------------------------------------------------------------------------------
'Descripción : Funcion Trim en javascript que elimina espacios de una cadena.
'Entradas : Cadena que se quiere tratar
'Salidas: Devuelve la cadena sin ningun espacio.
'Observaciones: Con una cadena en blanco no se ha probado, es posible que falle
'Autor: FCR 12/12/2000
'------------------------------------------------------------------------------------------------------*/  	
function TrimJS(cadena)
{
	var compruebaizquierda=/^ .+$/
	var compruebaderecha=/^.+ $/
	var correcto
	correcto=false
	while (correcto==false)
	{
		if (compruebaizquierda.test(cadena))
		{
			cadena = cadena.substr(1);
		}
		else
		{
			if (compruebaderecha.test(cadena))
			{
				cadena = cadena.substr(0,cadena.length-1)
			}
			else
			{
				correcto=true
			}	
		}
	}
	return (cadena)
}

function PasarPuntoAComa(strValor)   {
   var cadena 
   
      strValor = Trim(strValor)       
	  cadena=''	
      for (var i=0; i < strValor.length ; i++) {
          if (strValor.charAt(i)== '.')
			 cadena=cadena + ','
		  else
			cadena=cadena + strValor.charAt(i)
             
      }
      
      return cadena
	}   
	
function PasarComaAPunto(strValor)   {
   var cadena 
   
      strValor = Trim(strValor)       
	  cadena=''	
      for (var i=0; i < strValor.length ; i++) {
          if (strValor.charAt(i)== ',')
			 cadena=cadena + '.'
		  else
			cadena=cadena + strValor.charAt(i)
             
      }
      
      return cadena
	}   
/*-----------------------------------------------------------------------------------------------------
'Descripción : Compara dos fechas
'Entradas : Las fechas a comparar
'Salidas: 1 si la primera fecha es mayor, 0 si son iguales, -1 si la primera fecha es menor
'Observaciones: Asume que las fechas son correctas, asume que las fechas tienen uno de estos dos formatos:
	// dd/mm/aaaa o bien dd-mm-aaaa
'------------------------------------------------------------------------------------------------------*/
 function ComparaFechas(cadfecha1, cadfecha2)   {
 
 var matriz1;
 var matriz2;
 var i_annos1;
 var i_annos2;
 var i_meses1;
 var i_meses2;
 var i_dias1;
 var i_dias2;

		matriz1=cadfecha1.split ("/");
		matriz2=cadfecha2.split ("/");		
		
		// ¿ División con exito ?
		if (matriz1.length<=1)
		{
			// Se intenta la división usando como caracter separador el guion.
			matriz1=cadfecha1.split ("-");
		}

		if (matriz2.length<=1)
		{
			// Se intenta la división usando como caracter separador el guion.
			matriz2=cadfecha2.split ("-");
		}
				
		// ¿ Alguna de las dos separaciones ha tenido éxito ?
		eval ("i_annos1="+matriz1 [2]+";");
		eval ("i_meses1="+matriz1 [1]+";");
		eval ("i_dias1="+matriz1 [0]+";");		

		eval ("i_annos2="+matriz2 [2]+";");
		eval ("i_meses2="+matriz2 [1]+";");
		eval ("i_dias2="+matriz2 [0]+";");		
		
		if (i_annos1 > i_annos2)
		{
			return 1;
		}
		else
		{
			if (i_annos2 > i_annos1)
			{
				return -1;
			}
			else
				if (i_meses1 > i_meses2)
				{
					return 1;
				}
				else
					if (i_meses2 > i_meses1)
					{
						return -1;
					}
					else
						if (i_dias1 > i_dias2)
						{
							return 1;
						}
						else
							if (i_dias2 > i_dias1)
							{
								return -1;
							}
							else
							{
								return 0;
							}
		};

}

function ValidarCCC(ccc)
{
	var entidadoficina
	var ccuenta
	var dccalculado
	var dcobtenido
	var dc1
	var dc2
	var resultado
	if (ccc.lenght = 20)
	{
		entidadoficina = ccc.substring(0,8)
		dcobtenido=ccc.substring(8,10)
		ccuenta=ccc.substring(10,20)
		dc1 =dc(entidadoficina)
		dc2 =dc(ccuenta)
		resultado=(dcobtenido==(String(dc1)+String(dc2)))
	}
	else
	{
		resultado=false
	}
	return resultado
}
//Funcion privada para ValidarCCC
function dc(numero)
{
	var pesos =new Array(6,3,7,9,10,5,8,4,2,1)
	var resultado=0
	var i
	for (i=numero.length;i>0 ;i--)
	{
		resultado+=numero.substring(i-1,i)*pesos[numero.length-i]
	}
	resultado=11-(resultado % 11)
	if (resultado==10)
		resultado=1
	if (resultado==11)
		resultado=0
	return resultado
}

///////////////////////////////////////////////////////////////
// NOMBRE: calculaletranif
// FUNCION: Calcula la letra del nif.
// PARAMETROS DE ENTRADA: Un número (puede ser una cadena) con 
// el DNI al que hay que calcular la letra.
// VALOR DE RETORNO: Devuelve una cadena con nif y la letra.
// COMENTARIO: Asume que la variable que recibe es un DNI
// (no un CIF ni un NIF).
// En caso de error retorna una cadena vacía.
function calculaletranif (sdni)
{
	var retorno;
	var numero,control,letra,veces,variable,ceros;
	

	sdni = sdni.toUpperCase();
	if (sdni.substr(0,1)!="X" && sdni.substr(0,1)!="Z")
	{
		// Comprobamos que sea un número que no
  	// tiene más de 9 dígitos

  	control=parseInt (sdni,10);
  	retorno="";
  	if (!isNaN (control))
  	 if ((control>9)  && (control<999999999))
  	 {
  	 //  Fórmula del cálculo de letra
  	 numero=(control)-(Math.floor(control/23)*23);
  	 switch (numero)
  		{
  			case 0:
  				letra="T";
  				break;						
  			case 1:
  				letra="R";
  				break;
  			case 2:
  				letra="W";
  				break;				
  			case 3:
  				letra="A";
  				break;
  			case 4:
  				letra="G";
  				break;				
  			case 5:
  			    letra="M";
  				break;
  			case 6:
  				letra="Y";
  				break;
  			case 7:
  				 letra="F";
  				 break;
  			case 8:
  				letra="P";
  				break;
  			case 9:
  				letra="D";
  				break;
  			case 10:
  			   letra="X";
  			   break;
  			case 11:
  				letra="B";
  				break;				
  			case 12:
  				letra="N";				
  				break;
  			case 13:
  				letra="J";
  				break;
  			case 14:
  				letra="Z";
  				break;
  			case 15:
  				letra="S";
  				break;
  			case 16:
  				letra="Q";
  				break;
  			case 17:
  				letra="V";
  				break;
  			case 18:
  				letra="H";
  				break;
  			case 19:
  				letra="L";
  				break;
  			case 20:
  				letra="C";
  				break;
  			case 21:
  				letra="K";
  				break;
  			case 22:
  				letra="E";
  				break;
  		}
  		
  	 variable=String (control)
  	 ceros=""
  	 veces=9-variable.length;
  	
  	 for (i=0;i<veces;i++)
  	 	ceros+='0';
  	 variable=ceros+variable;		
  	 //retorno=String (control)+letra;
  	 retorno=variable+letra;
  	}
	}
	else
	 retorno=sdni;
 	return (retorno);
	
}
///////////////////////////////////////////////////////////////
// NOMBRE: calcularedad
// FUNCION: Calcula la edad a partir de una fecha de nacimiento
// PARAMETROS DE ENTRADA: Una fecha.
// VALOR DE RETORNO: Devuelve la edad calculada
// En caso de error retorna una 0.
//Comentarios: Asume que la fecha viene en el formato dd/mm/aaaa
function calcularedad (fechanacimiento)
{
// calculamos la fecha dada en el formato de mysql
	edad=0;
	if (ValidarFecha (fechanacimiento))
	{
		matriz=fechanacimiento.split ("/");	
		if (matriz.length==3)
		{//if (matriz.length==3)
		
			eval ("i_anno="+matriz [2]+";");
			eval ("i_mes="+matriz [1]+";");
			eval ("i_dia="+matriz [0]+";");
			

			
			var mydate=new Date();
			var year=mydate.getYear();
			var day=mydate.getDate();
			var month=mydate.getMonth()+1;
			
			var edad=year-i_anno;
		
			if (i_mes==month)
			{
				if (i_dia > day)
					edad=edad-1;
			}
			else if (i_mes > month)
				{
					edad=edad-1;
				}
		}//if (matriz.length==3)
	}
	return (edad);		
}

// Solo admite teclear números.
function num_onkeypress(evento)
{
	if (document.all)  // explorer
	{
		if ((event.keyCode < 47) || (event.keyCode > 57)) 
		       {event.returnValue = false;};
	}
	else
	{
		if (evento.charCode !=0 && (evento.charCode < 48 || evento.charCode > 57)) 
		       {return false; evento.returnValue = false};
	};
}
	

function num_coma(evento)
{
// el punto es el 46
// backspace es el 8
// los numéros val de 48 al 57
	if (document.all)  //explorer
	{
		if ((event.keyCode > 57) || (event.keyCode<48 && event.keyCode!=8 && event.keyCode!=46)) 
		       {event.returnValue = false;};
	}
	else
	{
		if ((evento.charCode!=0 && evento.charCode!=46 && evento.charCode < 48) || (evento.charCode > 57)) 
		       {return false; evento.returnValue = false};
	};
}

function QuitaSaltos(Texto)
{
	for(j=0;j<2;j++)
	{
		for(i=0;i<Texto.length;i++)
		{
			if((Texto.charCodeAt(i)==10) && (Texto.charCodeAt(i+1)==13) || (Texto.charCodeAt(i)==13) && (Texto.charCodeAt(i+1)==10))
			{
			Texto=Texto.substring(0,i) + "chr(13)"+ Texto.substring(i+2,Texto.length);
			//alert(Texto);
			}
			//alert(Texto.charCodeAt(i));
		}
	}
	return(Texto);
	//alert (Texto);
}

function CambioSaltos(Texto)
{
	for(j=0;j<2;j++)
	{
		for(i=0;i<Texto.length;i++)
		{
			/*if((Texto.charCodeAt(i)==10) && (Texto.charCodeAt(i+1)==13) || (Texto.charCodeAt(i)==13) && (Texto.charCodeAt(i+1)==10))
			{
				Texto=Texto.substring(0,i) + "chr(13)chr(10)"+ Texto.substring(i+2,Texto.length);
			}*/
			if((Texto.charCodeAt(i)==10) || (Texto.charCodeAt(i)==13))
			{
				Texto=Texto.substring(0,i) + "chr(13)chr(10)"+Texto.substring(i+1,Texto.length);
			}
		}
	}
	return(Texto);
}

function CambioSaltos2(Texto)
{
	for(j=0;j<2;j++)
	{
		for(i=0;i<Texto.length;i++)
		{
			/*if((Texto.charCodeAt(i)==10) && (Texto.charCodeAt(i+1)==13) || (Texto.charCodeAt(i)==13) && (Texto.charCodeAt(i+1)==10))
			{
				Texto=Texto.substring(0,i) + "chr(13)chr(10)"+ Texto.substring(i+2,Texto.length);
			}*/
			if((Texto.charCodeAt(i)==10) || (Texto.charCodeAt(i)==13))
			{
				Texto=Texto.substring(0,i) + "chr(13)"+Texto.substring(i+1,Texto.length);
			}
		}
	}
	return(Texto);
}