// - longitud_minima: Es una array numérico que indica los caracteres mínimos que se 
//						deben introducir (los máximos se controlan en la caja de texto).
//                    NOTA: Si es 0 es que no tiene longitud mínima.


// Función que valida un formulario
//
// Valores de entrada: 
// - objetos: Es un array de tipo objetos con los nombres de los objetos a validar
//
// - tipo_campo: Es un array de tipo numérico que indica qué tipo de contenido va a tener 
//					el campo (ej: nif, fecha, texto, numérico etc...)
//	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)
//
// - nombre_campo: Es un array de tipo texto que indica el nombre del campo
//					(ej: nombre, apellidos, nif, cp, etc...)
//
// - obligatorios: Es un array de 1's y 0's indicando qué campos son los obligatorios y cuales no.
//
// - sospechosos: Es un array de 1's y 0's indicando qué campos queremos ver si tienen caracteres sospechosos (<,>,/,%,...)
//
// - permite_comillas_en_sospechosos: Es un array de 1's y 0's indicando qué campos queremos que permitan la ' en el texto cuando mire caracteres sospechosos
//
// - limite: Es un array en el que cada elemento está formado por dos números separados por dos puntos
//			 En el caso de que un campo no sea numérico y sea de tipo texto se tomará como el número de caracteres mínimos y máximos a escribir
//           Ejemplo de un array de 4 elementos: 0:100, -100:700, 3:10, 0:32000
// Ejemplo de uso:
//
//			objetos = new Array(document.formulario.nombre,document.formulario.direccion,document.formulario.poblacion,document.formulario.cp,document.formulario.telefono,document.formulario.presidente,document.formulario.nif,document.formulario.email,document.formulario.url,document.formulario.url_logo,document.formulario.responsable,document.formulario.tfono_responsable,document.formulario.movil_responsable,document.formulario.mail_responsable);
//			tipo_campo = new Array(1,1,1,2,2,1,4,3,8,8,1,2,2,3);
//			nombre_campo = new Array('nombre','dirección','población','código postal','teléfono','presidente','NIF','email','URL','URL del logo','responsable','teléfono del responsable','móvil del responsable','email del responsable');
//			obligatorios = new Array(1,0,0,0,0,0,0,0,0,0,0,0,0,0);
//			sospechosos = new Array(1,1,1,0,0,1,0,1,1,1,1,0,0,1);
//			permitir_comillas = new Array(1,1,0,0,0,0,0,0,0,0,0,0,0,0);
//			limites = new Array('1:70','0:120','0:30','1000:99999','0:999999999','0:50','*','*','*','*','0:70','0:999999999','0:999999999','*');
//
//			if (validarNuevo(objetos, tipo_campo, nombre_campo, obligatorios, sospechosos, permitir_comillas, limites))
//			{
//				.
//				.
//				.
//			}

// Vbles a utilizar a lo largo del fichero
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;
				}


			
			}
	
		}

		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;
}



//*****************************************************************************
// 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!=1) {alert('El formato de la hora es erroneo.\n\r Formato: hh:mm') ;return false;}  // si hubiese segundos nsep!=2

  // 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 (mayusculas.indexOf(car)>=0) return (mayusculas.indexOf(car)>=0); return(-1);
   }


  // 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') ;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;}
}