//	tipos:
//		1 - Texto
//		2 - Numérico (no va a contener ningún tipo de letra, sólo números y los signos + y -)
//		3 - Mail
//		4 - NIF (8 números + letra)
//		5 - Fecha (dd/mm/aaaa)
//		6 - Hora  (hh:mm)
//		7 - CCC (cuenta del banco)
//		8 - URL (sin http. En caso de que llevara http, la función lo quita)
//		9 - Real (= que numérico pero admite cualquier número de decimales)
//		10- Moneda (= que Real pero como máximo 2 decimales)
//		11- Tipo numérico con coma flotante (hace falta límite)
//		12- Movil (No hace falta limite)
var cadena_numeros="0123456789";
var puntodecimal=".,";
var signos="+-";
var separadorfecha="/";
var separadorhora=":";
var posicion=0;
var posicion=0;
var numdecimales=0;


function validarNuevo(objetos, tipo_campo, nombre_campo, obligatorios, sospechosos, permite_comillas_en_sospechosos, limite)
{

	// Averiguamos el número de campos a valiadr
	numero_de_campos = objetos.length;

	var indice = 0;
	var hay_error = 0;

	// Empezamos a validar campo por campo
	for (indice = 0; indice <= numero_de_campos; indice++)
	{
		
		// Comprobamos si es obligatorio (sea el campo del tipo que sea)
		if ((obligatorios[indice] == 1) && (objetos[indice].value == ""))
		{
			alert("El campo " + nombre_campo[indice] + " es obligatorio");
			hay_error = 1;
		}	


		if ((sospechosos[indice] == 1) && (hay_error == 0))
		{
			//if (!mirarSospechoso(objetos[indice].value,permite_comillas_en_sospechosos[indice])) hay_error=1;
			if (!mirarSospechoso(objetos[indice],permite_comillas_en_sospechosos[indice])) hay_error=1;
		}

			
		if (hay_error == 0)
		{
			// Si llega aquí es que ya ha pasado el obligatorio y los caracteres sospechosos
			switch (tipo_campo[indice])
			{			

				case 1: // tipo texto (hace falta límite)
				{
					cadena_l = limite[indice];
					limites = cadena_l.split(":");
					if (((objetos[indice].value).length < limites[0]) || ((objetos[indice].value).length > limites[1]))
					{
						if (limites[0] == limites[1]) alert("El campo " + nombre_campo[indice] + " debe tener " + limites[0] + " caracteres");
						else alert("El campo " + nombre_campo[indice] + " debe tener como mínimo " + limites[0] + " caracteres y " + limites[1] + " como máximo");				
						hay_error = 1;
					}
					break;
				}

				case 2: // tipo numérico (hace falta límite)
				{
					if (!compruebaentero(objetos[indice].value))
					{
						alert("El campo " + nombre_campo[indice] + " es de tipo numérico entero (sin comas), no puede contener letras");
						hay_error = 1;
					}
					else  // si entra aquí es porque el campo es todo números
					{
						cadena_l = "" + limite[indice];
						limites = cadena_l.split(":");

						if ((parseInt(objetos[indice].value,10) < parseInt(limites[0])) || (parseInt(objetos[indice].value,10) > parseInt(limites[1])))
						{						
							if (limites[0] == limites[1]) alert("El campo " + nombre_campo[indice] + " debe tener el valor " + limites[0]);
							else alert("El campo " + nombre_campo[indice] + " debe estar entre " + limites[0] + " y " + limites[1]);
							hay_error = 1;
						}
					}
					break;
				}

				case 3: // tipo mail (hace falta límite)
				{
					if (!ValidarEmail(objetos[indice].value)) hay_error = 1;
					break;
				}

				case 4: // tipo NIF (NO hace falta límite)
				{
					if (!compruebanif(objetos[indice].value)) hay_error = 1;
					break;
				}

				case 5: // tipo fecha (NO hace falta límite)
				{
					if (!compruebafecha(objetos[indice].value)) hay_error = 1;
					break;
				}

				case 6: // tipo hora (NO hace falta límite)
				{
					if (!compruebahora(objetos[indice].value)) hay_error = 1;
					break;
				}

				case 7: // tipo CCC (NO hace falta límite)
				{
					if ((!validarCCC(objetos[indice].value)) && (hay_error==0)) hay_error = 1;
					else
					{
						cuenta = objetos[indice].value;
						ccc = cuenta.split("-");
						digito_control = calculaDC(ccc[0], ccc[1], ccc[3]);
						if (digito_control != parseInt(ccc[2]))
						{
							alert("El número de CCC no es correcto");
							hay_error = 1;
						}
					}
					break;
				}

				case 8: // tipo URL (hace falta límite)
				{
					cadena_l = limite[indice];
					limites = cadena_l.split(":");
					if (((objetos[indice].value).length < limites[0]) || ((objetos[indice].value).length > limites[1]))
					{
						if (limites[0] == limites[1]) alert("El campo " + nombre_campo[indice] + " debe tener " + limites[0] + " caracteres");
						else alert("El campo " + nombre_campo[indice] + " debe tener como mínimo " + limites[0] + " caracteres y " + limites[1] + " como máximo");				
						hay_error = 1;
					}

					if (hay_error == 0)
					{
						if (!validaURL(objetos[indice].value)) hay_error = 1;
					}

					break;
				}

				case 9,10: // 9:tipo real (hace falta límite) o 10:tipo moneda (como máximo 2 decimales)
				{
					if (!compruebareal(objetos[indice].value))
					{
						switch(valor) {
							case 1: msgError= "Campo está vacío."; break;
							case 2: msgError= "Caracter ilegal en un número."; break;
							case 3: msgError= "Caracter ilegal."; break;
							case 4: msgError= "solo ha insertado un signo."; break;
							case 5: msgError= "Parte decimal vacia."; break;
						}
						alert("El campo " + nombre_campo[indice] + " debe ser de tipo real. " + msgError);
						hay_error = 1;
					}
					else  // si entra aquí es porque el campo es todo números
						if ((numdecimales>2) && (tipo_campo[indice]==10))
						{
							alert("El campo " + nombre_campo[indice] + " debe ser de tipo moneda con un máximo de 2 decimales.");
							hay_error = 1;
						}
						else
						{
							cadena_l = "" + limite[indice];
							limites = cadena_l.split(":");

							if ((parseFloat(objetos[indice].value,10) < parseFloat(limites[0])) || (parseFloat(objetos[indice].value,10) > parseFloat(limites[1])))
							{						
								if (limites[0] == limites[1]) alert("El campo " + nombre_campo[indice] + " debe tener el valor " + limites[0]);
								else alert("El campo " + nombre_campo[indice] + " debe estar entre " + limites[0] + " y " + limites[1]);
								hay_error = 1;
							}
						}
					break;
				}

				case 11: // tipo numérico con coma flotante (hace falta límite)
				{
					if (!compruebareal(objetos[indice].value))
					{
						alert("El campo " + nombre_campo[indice] + " es de tipo numérico, no puede contener letras");
						hay_error = 1;
					}
					else  // si entra aquí es porque el campo es todo números
					{
						cadena_l = "" + limite[indice];
						limites = cadena_l.split(":");

						if ((parseFloat(objetos[indice].value,10) < parseFloat(limites[0])) || (parseFloat(objetos[indice].value,10) > parseFloat(limites[1])))
						{						
							if (limites[0] == limites[1]) alert("El campo " + nombre_campo[indice] + " debe tener el valor " + limites[0]);
							else alert("El campo " + nombre_campo[indice] + " debe estar entre " + limites[0] + " y " + limites[1]);
							hay_error = 1;
						}
					}
					break;
				}
				case 12: // tipo movil (NO hace falta límite)
				{
					if (!compruebaMovil(objetos[indice].value)) hay_error = 1;
					break;
				}
				case 13: // NIF / NIE / y Otros (hasta 15)
				{
					if (!compruebaNIF_NIE(objetos[indice].value, 1)) hay_error = 1;
					break;
				}
				case 14: // NIF y NIE solo
				{
					if (!compruebaNIF_NIE(objetos[indice].value)) hay_error = 1;
					break;
				}

			}
	
		}

		if (hay_error == 1) 
		{
			objetos[indice].select();
			objetos[indice].focus();
			break; //Si hay error que no continue el bucle
		}

	}

 	if (hay_error == 1) return false;
	else return true;

}


//*****************************************************************************
// Función para mirar si alguien pone un caracter sospechoso en la caja de texto, y se lo borra
//
// Se le pasa como parámetro el nombre de un objeto. Ej: document.formulario.texto
//
// Para añadir un nuevo caracter sospechoso, únicamente se debe incluir un nuevo 
// elemento en el array, es decir, añadir esto: ,"caracter_malo"
//


		function mirarSospechoso(objeto, permite_comilla)
		{
			caracteres_no_permitidos = new Array("<",">",";","\"","\\","%","$","&","[","]","{","}","*","!");

			// Si el parametro sin_comilla vale 0 quiere decir que el usuario no podrá escribir el caracter '
			if (permite_comilla==0) 
			{
				longitud=caracteres_no_permitidos.length;
				caracteres_no_permitidos[longitud]="'";
			}

			sw = 0;
			texto = "" + objeto.value;
			for (i = 0; i <= caracteres_no_permitidos.length; i++)
			{
				if (texto.indexOf(caracteres_no_permitidos[i]+"") != -1)	
				{
					caracter_malo = caracteres_no_permitidos[i];
					sw = 1;				
				}
			}



			if (sw == 1)
			{
				alert("El caracter " + caracter_malo + " no está permitido");
				//objeto.value = texto.substring(0,texto.length-1)
				objeto.focus();
				return false
			}
			else return true
		}

//*****************************************************************************
// Función para validar CCC
function calculaDC(entidad, oficina,numero)
{
	codigoEntidad1 = eval(entidad.charAt(3));
	codigoEntidad2 = eval(entidad.charAt(2));
	codigoEntidad3 = eval(entidad.charAt(1));
	codigoEntidad4 = eval(entidad.charAt(0));
	codigoOficina1 = eval(oficina.charAt(3));
	codigoOficina2 = eval(oficina.charAt(2));
	codigoOficina3 = eval(oficina.charAt(1));
	codigoOficina4 = eval(oficina.charAt(0));
	numeroCuenta1 = eval(numero.charAt(9));
	numeroCuenta2 = eval(numero.charAt(8));
	numeroCuenta3 = eval(numero.charAt(7));
	numeroCuenta4 = eval(numero.charAt(6));
	numeroCuenta5 = eval(numero.charAt(5));
	numeroCuenta6 = eval(numero.charAt(4));
	numeroCuenta7 = eval(numero.charAt(3));
	numeroCuenta8 = eval(numero.charAt(2));
	numeroCuenta9 = eval(numero.charAt(1));
	numeroCuenta10 = eval(numero.charAt(0));
// Calculando el primer dígito de control
	control1 = codigoOficina1*6;
	control1+= codigoOficina2*3;
	control1+= codigoOficina3*7;
	control1+= codigoOficina4*9;
	control1+= codigoEntidad1*10;
	control1+= codigoEntidad2*5;
	control1+= codigoEntidad3*8;
	control1+= codigoEntidad4*4;
	
	control1 = control1%11;
	control1= 11 - control1;
	if (control1 > 9) {
	control1=11 - control1;
	}
	//calculando el segundo dígito de control
	control2 = numeroCuenta1*6;
	control2+= numeroCuenta2*3;
	control2+= numeroCuenta3*7;
	control2+= numeroCuenta4*9;
	control2+= numeroCuenta5*10;
	control2+= numeroCuenta6*5;
	control2+= numeroCuenta7*8;
	control2+= numeroCuenta8*4;
	control2+= numeroCuenta9*2;
	control2+= numeroCuenta10*1;
	
	control2 = control2%11;
	control2 = 11 - control2;
	if (control2 > 9){
		control2=11 - control2;
	}
	
	// Dígitos de control calculados
	retorno= (String(control1)+String(control2));
return retorno
}


function validarCCC(cadena)
{
	var hayError = 0;
	if (cadena.charAt(4) != '-') hayError = 1;
	if (cadena.charAt(9) != '-') hayError = 1;
	if (cadena.charAt(12) != '-') hayError = 1;
	if (isNaN(parseInt(cadena.substring(0,4),10))) hayError = 1;
	if (!compruebaentero(cadena.substring(0,4))) hayError = 1;
	if (isNaN(parseInt(cadena.substring(5,9),10))) hayError = 1;
	if (!compruebaentero(cadena.substring(5,9))) hayError = 1;
	if (isNaN(parseInt(cadena.substring(10,12),10))) hayError = 1;
	if (!compruebaentero(cadena.substring(10,12))) hayError = 1;
	if (isNaN(parseInt(cadena.substring(13,23),10))) hayError = 1;
	if (!compruebaentero(cadena.substring(13,23))) hayError = 1;
	if (hayError == 1)
	{ 
		alert("El nº de cuenta no sea correcta o que no se utilice el formato adecuado.\n\r Formato: XXXX-YYYY-DD-CCCCCCCCCC Donde: \n\r XXXX es el nº de entidad\n\r YYYY nº de oficina \n\r DD digitos de control\n\r CCCCCCCCCC nº de la cuenta"); 
		return false; 
	}
	else return true;
}

function esvacio(objeto) {
	var valor = "" + objeto.value;
	if (valor.length == 0) return true; else return false;
}

// Función para validar un número entero
	// Comprueba si un signo se encuetra en la posición correcta 
	function signocorrecto(contenido)
	{
		if (contenido.length == 0) return true;
		else 
		{
    	  if (!numero(contenido.charAt(0))&&!signo(contenido.charAt(0))) return false;
    	  else return true;
		}
   	}

   function numero(car)
   {
	   return (cadena_numeros.indexOf(car) >= 0)
   }

   // Determina si un carácter es un signo positivo o negativo
   function signo(car)
   {
   		return (signos.indexOf(car)>=0)
   }


   // Comprueba si el contenido es un número es entero
   function compruebaentero(contenido)
   { 
	if (!signocorrecto(contenido)) return false;    
	else
	{
		if (numero(contenido.charAt(0))) return(compruebanatural(contenido)) // No tiene signo.
		else return(compruebanatural(contenido.substring(1,contenido.length))) // tiene signo
	}
   }



   function compruebanatural(contenido)
   {
	   if (contenido.length == 0) return true; 
	   for (var i=0; i<contenido.length;i++) //>
	   {
			if (!numero(contenido.charAt(i))) return false;  //no todos los caracteres son números
	   }
	   return true; // todos son numeros
   }
   
   
//*****************************************************************************
// Función para validar el REAL
// Comprueba si el contenido es un número es real

  // Comprueba si el contenido es un número es entero
    // Comprueba si el contenido es un número es natural incluido el 0
   function Rcompruebanatural(contenido)
   {
   if (contenido.length == 0)
      {
      valor=1;
      posicion=1; 
      return false;
      }  
   for (var i=0; i<contenido.length;i++)
      {
      if (!numero(contenido.charAt(i)))
         {
         valor=2;
         posicion=i+1;
         return false;
         } 
      }
   return true;
   }

   // Comprueba si un signo se encuetra en la posición correcta 
   function Rsignocorrecto(contenido)
   {
   if (contenido.length == 0)
      {
      valor=1;
      posicion=1; 
      return false;
      }
   else 
      if (!numero(contenido.charAt(0))&&!signo(contenido.charAt(0)))
         {
         valor=3;
         posicion=1; 
         return false;
         }
      else
         return true;
   }

   // Comprueba si el contenido es un número es entero
   function Rcompruebaentero(contenido)
   { 
   if (!Rsignocorrecto(contenido))
      return false;
   else 
      if (numero(contenido.charAt(0)))
         var aux=Rcompruebanatural(contenido);
      else
         { 
         var aux=Rcompruebanatural(contenido.substring(1,contenido.length));
         if (!aux)
            posicion++; 
         if (valor==1)
            {
            valor=4;
            posicion=1;
            }
         }
   return aux;   
   }

   // Comprueba si el contenido es un número es real
   function compruebareal(contenido)
   { 
   valor=0;
   posicion=0;
   var aux=Rcompruebaentero(contenido);
   var posicionpunto=posicion-1;
   if (!aux && valor==2 &&
      puntodecimal.indexOf(contenido.charAt(posicionpunto))>=0) 
      {
      var aux=Rcompruebanatural(contenido.substring(posicion,contenido.length)); 
	  numdecimales = contenido.length-posicion
      if (!aux && valor==1)
         {
         valor=5;
         }
      if (!aux)
         posicion+=posicionpunto+1;
      }
   return aux;
   }
  


//-->
//*****************************************************************************
// Función para validar el email


function ValidarEmail(Mail)
{
    if (Mail.length==0) return true;
	var mailOk=0; arroba=0, punto=0;
	arroba=Mail.indexOf("@");
	Mail=Mail.substring(arroba+1,Mail.length)
	punto=Mail.indexOf(".")
	Mail=Mail.substring(punto+1,Mail.length)
	if (arroba>0 && punto>0 && Mail.length>1) return true;
	else 
	{ 
		alert('La cuenta de email no es correcta'); 
		return false; 
	}
	
}

//*****************************************************************************
// Valida una fecha o una hora
// Determina si un año es bisiesto
function bisiesto(anio) 
{
  if (((anio % 4 == 0) && anio % 100 != 0) || anio % 400 == 0) 
  return true;
  return false;
}


// Comprueba si una fecha es correcta *************************************
function compruebafecha(contenido)
{
  if (contenido.length==0) return true;
  var nsep=0;
  // Comprobación de la sintáxis de una fecha 
  for (var i=0; i<contenido.length; ++i) //>
  {
      var car=contenido.charAt(i);
      if (!numero(car)&&car!=separadorfecha) {alert('El formato de la fecha es erroneo.\n\r Formato: dd/mm/aaaa') ;return false;}
      if (car==separadorfecha) nsep++ 
  }
  if (nsep!=2) {alert('El formato de la fecha es erroneo.\n\r Formato: dd/mm/aaaa') ;return false;}

  // Comprobación de la semántica de una fecha
  var pos1=contenido.indexOf(separadorfecha);
  var dia=contenido.substring(0,pos1);
  var pos2=contenido.indexOf(separadorfecha,pos1+1);
  var mes=contenido.substring(pos1+1,pos2); 
  var anio=contenido.substring(pos2+1,10);
  if (anio<0||anio>9999) {alert('El año no es correcto'); return false;}
  if (mes<1||mes>12) {alert('El mes no es correcto'); return false;}
  if ((dia<1 || dia>31)||(mes==4&&dia>30)||(mes==6&&dia>30)
	||(mes==9&&dia>30)||(mes==11&&dia>30)
	||(mes==2&&bisiesto(anio)&&dia>29)
	||(mes==2&&!bisiesto(anio)&&dia>28)) {alert('El día no es correcto'); return false;}
  return true 
}

// Comprueba si una hora es correcta  *************************************
function compruebahora(contenido)
{
  if (contenido.length==0) return true
  var nsep=0; 
  // Comprobación de la sintáxis de una hora 
  for (var i=0; i<contenido.length; ++i) // >
  {
    var car=contenido.charAt(i);
    if (!numero(car) && car!=separadorhora) {alert('El formato de la hora es erroneo.\n\r Formato: hh:mm') ;return false;}
    if (car==separadorhora) nsep++ 
  }

  // if (nsep!=2) return false;  // si queremos obligar a que ponga los segundos
  // if (nsep!=1) return false;  // si queremos obligar a que ponga los minutos
  if (nsep!=1) contenido += separadorhora+"00";  // si no queremos obligar a nada (le ponemos ":00" al final)
  // Comprobación de la semántica de una hora 
  var pos1=contenido.indexOf(separadorhora);
  var horas=contenido.substring(0,pos1);
  var minutos=contenido.substring(pos1+1,contenido.length);   //(pos1+1,pos2);
  if (parseInt(horas) > 24||horas.length>2 || isNaN(parseInt(horas))) {alert('La hora no es correcta') ;return false;}
  if (parseInt(minutos) > 59||minutos.length>2 || isNaN(parseInt(minutos))) {alert('Los minutos no son correctos') ;return false;}
  return true 
}

//*****************************************************************************
// Valida un NIF

   numeros="0123456789";
   mayusculas="ABCDEFGHIJKLMNÑOPQRSTUVWXYZ";
   minusculas="abcdefghijklmnñopqrstuvwxyz";
   errorNif= new creaerrorNif();  
   erroresNif= new Array();
   erroresNif[1]="Campo obligatorio (8 números + 1 letra). Falta su valor";
   erroresNif[2]="Faltan caracteres: 8 números + 1 letra.";
   erroresNif[3]="Faltan caracteres 8 números + 1 letra (opcional).";
   erroresNif[4]="Carácter ilegal: los 8 primeros caracteres deben ser números";
   erroresNif[5]="Carácter ilegal: el último caracter debe ser una letra";
   erroresNif[6]="Letra del NIF incorrecta";

  
   // Crea un objeto que guarda un indice a la posición y al mensaje de error
   function creaerrorNif()
   {
   this.valor=0;
   this.posicion=0;
   return this
   }
  
   // Determina si un caracter es un número
   function numero(car)
   {
   return (numeros.indexOf(car)>=0)
   }

  // Determina si un caracter es un número
   function esletra(car)
   {
	   if (minusculas.indexOf(car) >= 0) return true; else if (mayusculas.indexOf(car) >= 0) return true; else return false;
   }


  // No se comprueba si el DNI es correcto (8 numeros)
   function CalculaLetraNIF(Dni) 
   {

     var clave=new Array("T","R","W","A","G","M","Y","F","P","D","X","B","N","J","Z","S","Q","V","H","L","C","K","E"); 
     //alert("El NIF es : ".concat(Number(Dni) , clave[Dni%23]));
     return(clave[Dni%23]);
   }

	function CalculaNIF(Dni) 
	{

     var clave=new Array("T","R","W","A","G","M","Y","F","P","D","X","B","N","J","Z","S","Q","V","H","L","C","K","E"); 
     //alert("El NIF es : ".concat(Number(Dni) , clave[Dni%23]));
     return("".concat(Number(Dni) , clave[Dni%23]));
	}
	
   // Comprueba si el contenido corresponde a un NIF (8 numeros + 1 letra)

   function compruebanif(contenido)
   {
		var letraCalculada;

		if ((contenido.length > 0) && (contenido.length != 9)) {alert('El NIF debe tener 8 números y 1 letra') ;return false;}
	   
		for (var i=0; i<8;i++)
		{
    	  if (!numero(contenido.charAt(i))) {alert('Alguno de los 8 primeros caracteres no es un número') ;return false;}
		}

		if (contenido.length==9)
		{
			if (!esletra(contenido.charAt(8))) {alert('No se ha escrito una letra, o ésta es errónea') ;return false;}
			else
			{
			  letraCalculada= CalculaLetraNIF(contenido.substring(0,8));
			  if (contenido.charAt(8).toUpperCase() != letraCalculada)
			  {
		            {alert('La letra no es correcta, no se corresponde con los números aportados. Revise la letra o alguno de los números.') ;return false;}
			  }
			}
	   }
	   return true;
   }
   
	function compruebanie(contenido)
	{
		var letraCalculada;
		if ((contenido.length > 0) && (contenido.length != 8)) {alert('El NIE debe tener una X y 7 números') ;return false;}
		if (contenido.charAt(0).toUpperCase() != "X"){ alert('El primer caracter no es correcto. Deber ser X.') ;return false;}
		for (var i=1; i<7;i++) {
    	  if (!numero(contenido.charAt(i))) {alert('A partir del 2 caracter incluido, todos deben ser números') ;return false;}
		}
		return true;
   }

	function compruebaNIF_NIE(contenido, otro) 
	{
		
		if ((contenido.length > 0) && (contenido.length == 9)) {
			for (var i=0; i<8;i++) {
	    	  if (!numero(contenido.charAt(i))) {alert('NIF: Alguno de los 8 primeros caracteres no es un número') ;return false;}
			}
			if (!esletra(contenido.charAt(8))) {alert('NIF: No se ha escrito una letra, o ésta es errónea'); return false;}
			else {
			  letraCalculada = CalculaLetraNIF(contenido.substring(0,8));
			  if (contenido.charAt(8).toUpperCase() != letraCalculada) {alert('La letra no es correcta, no se corresponde con los números aportados. Revise la letra o alguno de los números.') ;return false;}
			}
		}
		if ((contenido.length > 0) && (contenido.length == 8)) {
			if (contenido.charAt(0).toUpperCase() != "X"){ alert('Si es NIF le falta la letra en el 9º caracter. Si es NIE el primer caracter no es correcto. Deber ser X.');return false;}
			for (var i=1; i<7;i++) {
			  if (!numero(contenido.charAt(i))) {alert('NIE: A partir del 2º caracter incluido, todos deben ser números.') ;return false;}
			}
		}
		if ((contenido.length > 0) && (contenido.length != 8) && (contenido.length != 9)) {
			if (otro == 1)  {							
				var longitud = contenido.length;
				for (var i=1; i<longitud; i++) {
				  if ( (!numero(contenido.charAt(i))) && (!esletra(contenido.charAt(i))) ) {alert('Los caracteres del documento acreditativo deben ser números o letras.') ;return false;}
				}
			} else {alert('EL NIF (8 nros y 1 letra) o el NIE (X y 7 nros) deben de tener 8 y 9 caracteres respectivamente.') ;return false;}
		}
		return true;
	}
   

//*****************************************************************************
// Valida un MOVIL

function compruebaMovil(contenido) {

	if (contenido.length == 0) return true;
	if (contenido.length != 9) {
		 alert('El telefono movil debe tener 9 números.');
		 return false;
	}
	for (var i=0; i<9;i++) {
		if (!numero(contenido.charAt(i))) {
			alert("Todos los caracteres del teléfono móvil deben ser números.");
			return false;
		}
	}
	if (contenido.charAt(0) != 6) {
		alert("El telefono móvil no es correcto.");
		return false;
	}
	return true;
}



//*****************************************************************************
// Valida una URL

function validaURL(URL)
{
	var Cadena="";
	Cadena+=URL;

	if (Cadena.substring(0,7)=="http://") Cadena = Cadena.substring(7,Cadena.length)
	else
		if (Cadena.substring(0,7)=="http:\\\\") Cadena = Cadena.substring(7,Cadena.length)
		else
			if (Cadena.substring(0,6)=="http:/") Cadena = Cadena.substring(6,Cadena.length)
			else
				if (Cadena.substring(0,5)=="http:") Cadena = Cadena.substring(5,Cadena.length)
				else
					if (Cadena.substring(0,5)=="http ") Cadena = Cadena.substring(5,Cadena.length)
					else
						if (Cadena.substring(0,4)=="http") Cadena = Cadena.substring(4,Cadena.length)
	
	if (Cadena.length==0) return true;
	if(Cadena.indexOf(".")>0)
	{
		Cadena=Cadena.substring(Cadena.indexOf(".")+1,Cadena.length)
			if(Cadena.indexOf(".")>0)
			{				
				Cadena=Cadena.substring(Cadena.indexOf(".")+1,Cadena.length)
				if(Cadena.length>=2)
				{
					return true;
				}
				else {alert('No es una dirección web válida') ;return false;}
			}
			else {alert('No es una dirección web válida') ;return false;}
	}
	else {alert('No es una dirección web válida') ;return false;}
}


// ---------------- caracteresPermitidos: [cualquiera, 1 solo numeros, 2 solo letras, 3 solo numeros y letras]
function compruebaContenido(objeto, nombre, vacio, minimo, maximo, caracteresPermitidos, sospechosos, comillas) {
	var contenido = "" + objeto.value;
	var longitud = contenido.length;
	if ((vacio == 0) && (longitud == 0)) {
		alert('El ' + nombre + ' debe tener ' +  minimo + ' caracteres como mínimo.');
		 return false;
	}
	
	if ((minimo > -1) && (longitud < minimo) && (longitud > 0)) {
		alert('El ' + nombre + ' debe tener ' +  minimo + ' caracteres como mínimo.');
		 return false;
	}

	if (longitud > maximo) {
		alert('El ' + nombre + ' debe tener ' +  minimo + ' caracteres como máximo.');
		 return false;
	}

	if (caracteresPermitidos > 0) {
		for (var i=0; i<longitud; i++) {
			if ((caracteresPermitidos == 3) && (!numero(contenido.charAt(i))) && (!esletra(contenido.charAt(i))) ) {
				alert('Los caracteres de ' + nombre + ' deben ser números o letras.');
				return false;
			}
			if ((caracteresPermitidos == 2) && (!esletra(contenido.charAt(i))) ) {
				alert('Los caracteres de ' + nombre + ' deben ser letras.');
				return false;
			}
			if ((caracteresPermitidos == 1) && (!numero(contenido.charAt(i))) ) {
				alert('Los caracteres de ' + nombre + ' deben ser números.');
				return false;
			}
		}
	} else if (!mirarSospechoso(objeto, comillas)) return false;
	return true;
}