/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
                             C O N S T A N T E S
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/

LETTERS = "áéíóúÁÉÍÓÚabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
LETRAS = "abcdefghijklmnñopqrstuvwxyzABCDEFGHIJKLMNÑOPQRSTUVWXYZ";
LETRAS_AMADEUS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
DIGITS = "0123456789";
ZIP_VALID = DIGITS;
PHONE_VALID = DIGITS + "+- ()";
PVP = DIGITS + ".,";
MAIL_VALID = LETTERS + DIGITS + ";._@-";
SELECTED = "Xx";
//INVALID_FOR_TEXT = DIGITS + "!·\\\"$%&/=?¿|@#`+*^[]{}´¨_<>:;";
INVALID_FOR_TEXT = "!·\\\"'$%&=?¿|@#`+*^[]{}´¨_<>;";
INVALID_FOR_URL = "!·\\\"'$%()¿|@#`+*^[]{}´¨<>;";
INVALID_FOR_MAIL = "!·\\\"'$%()¿|#`+*^[]{}´¨<>;";
INVALID_NAME = "!·\\\"'$%()¿|#`+*^[]{}´¨<>:áéíóúÁÉÍÓÚäëïöüÄËÏÖÜâêîôûÂÊÎÔÛ";
INVALID_DATE = LETRAS+"!·\\\"'$%()¿|#`+*^[]{}´¨<>:áéíóúÁÉÍÓÚäëïöüÄËÏÖÜâêîôûÂÊÎÔÛ";
INVALID_TIME = "&/€!·\\\"'$%()¿|#`+*^[]{}´¨<>;áéíóúÁÉÍÓÚäëïöüÄËÏÖÜâêîôûÂÊÎÔÛ ";
INVALID_AMADEUS= "áéíóúÁÉÍÓÚàèìòùÀÈÌÒÙäëïöüÄËÏÖÜâêîôûÂÊÎÔÛ`";
INVALID_NONE="";
INVALID_NUMBER = ":+-()" + LETRAS + INVALID_FOR_TEXT+"ºª€¬¡ç*/";
DATE_VALID=DIGITS + "/";
CIF_CODE = "1";
NIF_CODE = "2";
// Navigators
var browser = navigator.appName;
var version = navigator.appVersion
var ver1 = version.substring(0,1)
var ver2 = version.lastIndexOf("MSIE")
var ver3 = version.substring(ver2+5,ver2+6)
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
                   F U N C I O N E S   D E    C A M P O S
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/

/**-------------------------------------*/
//Funcion: getLength
//Parametros:
//	logitud, tamaño del input(size).
//Retorno: La longitud modificada según el
//         el navegador utilizado.
//**-------------------------------------**
function getLength(longitud){
	browser=navigator.appName;
	diff = 0;
	if ((browser == "Netscape") && (ver1 < 5)){ // Si es Netscape inferior a la versión 6
		if (longitud<2) {
	 		diff = (longitud/10)*1.2;
		} else {
			diff = (longitud/10)*3.2;
		}
 	}
 	return (longitud - diff);
}
/**------------------------------------------------------*/
//Funcion: getInputText
//Parametros:
//	nombre, nombre del input que quieres crear.
//	type, tipo del input.
//  size, tamaño del input, auxiliado por la función
//        getLength.
//  maxlength, cantidad de carácteres permitidos
//             en el input.
//  clase, la clase de estilos que se le aplicará.
//  codigo, aquí podemos introducir todos los eventos
//          permitidos por el input
//  value, valor por defecto del input.
//  para, si le pasamos el valor (nombre) validará con 
//        con la cadena INVALID_FOR_URL
//  tab, con este indice controlaremos el tabindex
//Retorno: Pinta un input con el formato
//         que nosotros hemos elegido.
//**------------------------------------------------------**
function getInputText(name,type,size,maxlength,clase,codigo,value,para,tab){
	//alert('Dentro : '+name+' '+type+' '+maxlength+' '+clase+' '+codigo+' '+value);
	literal = '<input type="'+type+'" name="'+name+'" id="'+name+'" maxlength="'+maxlength+'"  value="'+value+'" tabindex="'+tab+'" ';
	if(clase != ""){
		literal +=  ' class="'+clase+'" ';
	}
	if(size  != ""){
		literal += ' size="'+getLength(size)+'" ';
	}
	literal += ' '+codigo;
	literal += ' onKeyUp="var newval=comprueba(value,\''+para+'\');if(value != newval) {value = newval;}">';
	//alert(literal);
	return literal;
}
/**-------------------------------------*/
//Funcion: getRows
//Parametros:
//	longitud, numero de filas del textarea.
//Retorno: número de filas adecuado para 
//         cada navegador.
//**-------------------------------------**
function getRows(longitud){
	browser=navigator.appName;
	diff = 0;
	if (browser == "Netscape"){
		if (longitud<3) {
	 		diff = 0;
		} else {
			diff = (longitud/10)*3;
		}
 	}
 	return (longitud - diff);
}
/**-------------------------------------*/
//Funcion: getCols
//Parametros:
//	longitud, numero de columnas del textarea.
//Retorno: número de columnas adecuado para 
//         cada navegador.
//**-------------------------------------**
function getCols(longitud){
	browser=navigator.appName;
	diff = 0;
	if (browser == "Netscape"){
		if (longitud<10) {
	 		diff = 0;
		} else {
			diff = (longitud/10)*4;
		}
 	}
 	return (longitud - diff);
}
/**------------------------------------------------------*/
//Funcion: getTextArea
//Parametros:
//	nombre, nombre del textarea que quieres crear.
//  rows, número de filas.
//  cols, número de columnas.
//  clase, la clase de estilos que se le aplicará.
//  codigo, aquí podemos introducir todos los eventos
//          permitidos por el input
//  value, valor por defecto del input.
//Retorno: Pinta un textarea con el formato
//         que nosotros hemos elegido.
//**------------------------------------------------------**
function getTextArea(name, cols, rows, clase, codigo, value, para){
  //alert('Dentro : '+name+' '+rows+' '+cols+' '+clase+' '+codigo+' '+value);
	literal='<textarea name="'+name+'" ';
	if(clase!=""){
		literal+=' class="'+clase+'" ';
	}
	if(rows!=""){
		literal+=' rows="'+rows+'" ';
	}
	if(cols!=""){
		literal+=' cols="'+cols+'" ';
	}
	literal+=' '+codigo;
	literal += ' onKeyUp="var newval=comprueba(value,\''+para+'\');if(value != newval) {value = newval;}">';
	literal+=''+value+'</textarea>';
	//alert(literal);
	return literal;
}
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
                   F U N C I O N E S   D E    V A L I D A C I O N E S
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
//**----------------------------------------------------------------*/
//Funcion: validateHour
//Parametros:
//	str, 			cadena de caracteres
//	separador,		separador entre horas y minutos
//Retorno: true/false
//
// Se comprueba si 'str' es una hora válida, con formato 'HHseparadorMM'.
//**----------------------------------------------------------------*/
function validateHour (str, separador){
	if (str.length > 0){
		if (!validate (str, DIGITS+separador)){
			return false;
		}
		if(str.length != 5){
			return false;
		}
  		if(str.indexOf(separador) == 2){
			if(validate (str.substring(0,2), DIGITS) && validate (str.substring(3,5), DIGITS)) { 
				Phora = parseInt(str.substring(0,2));                          
				Pminutos = parseInt(str.substring(3,5))
				if(!(Phora <0  || Phora >23 || Pminutos <0 || Pminutos >59)){
		        		return true;
				}else{
					return false;
				}
			}else{
				return false;
			}
		}else{
			return false;
		}		
	}
	return true;
}
//**----------------------------------------------------------------*/
//Funcion: isFilled
//Parametros:
//	str, cadena de caracteres
//Retorno: true/false.
//
// Comprueba que una cadena de caracteres determinada contiene
// algún caracter distinto de espacios.
//**----------------------------------------------------------------*/
function isFilled (str)
{
	for (c = 0; c < str.length; c++)
	{
		if (str.charAt(c) != " ")
		{
			return true;
		}
	}
	return false;
}

//**----------------------------------------------------------------*/
//Funcion: validate
//Parametros:
//	str, 	cadena de caracteres
//	valStr,	conjunto de caracteres válidos
//Retorno: true/false.
//
// Comprueba que todos los carateres una cadena determinada 'str' están
// presentes en el conjunto de caracteres 'valStr'
//**----------------------------------------------------------------*/
function validate (str, valStr)
{
	for (c = 0; c < str.length; c++)
	{
		if (valStr.indexOf (str.charAt (c)) == -1)
		return false;
	}
	return true;
}

//**----------------------------------------------------------------*/
//Funcion: unvalidate
//Parametros:
//	str, 	cadena de caracteres
//	valStr,	conjunto de caracteres válidos
//Retorno: true/false.
//
// Comprueba que ninguno de los carateres una cadena determinada 'str' están
// presentes en el conjunto de caracteres 'valStr'
//**----------------------------------------------------------------*/
function unvalidate (str, valStr)
{
	for (c = 0; c < str.length; c++)
	{
		if (valStr.indexOf (str.charAt (c)) != -1)
		{
			return false;
		}
	}
	return true;
}

//**----------------------------------------------------------------*/
//Funcion: unvalidateURL
//Parametros:
//	str, 	cadena de caracteres
//	valStr,	conjunto de caracteres válidos
//Retorno: entero, siendo este entero la posición dentro de la cadena 
//         del caracter no válido , o -1 si son todos válidos.
//
// Comprueba que ninguno de los carateres una cadena determinada 'str' 
// están presentes en el conjunto de caracteres 'valStr'. 
// Se diferencia de la unvalidate en que devuelve la posición del 
// caracter no válido para poder eliminarlo de la cadena posteriormente.
//**----------------------------------------------------------------*/
function unvalidateURL (str, valStr)
{
 for (c = 0; c < str.length; c++)
 {
  if (valStr.indexOf (str.charAt (c)) != -1)
  {
   return(c);
  }
 }
 return(-1);
}

//**----------------------------------------------------------------*/
//Funcion: validateURL
//Parametros:
//	str, 	cadena de caracteres
//	param,	parametro que distingue entre validaciones para URL's 
//		y nombres
//Retorno: true/false
//
// Comprueba que ningundo de los carateres una cadena determinada 'str' 
// están presentes en el conjunto de caracteres INVALID_NAME o INVALID_FOR_URL. 
// Se diferencia de la validate en que el conjunto de caracteres válido 
// depende del parámetro 'para'.
// 
// NOTA: esta función se podría eliminar y sustituir sus llamadas por 
//	 llamadas a validate(str,INVALID_NAME) o validate(str,INVALID_FOR_URL).
//**----------------------------------------------------------------*/
function validateURL (str,para)
{
 var cadena = '';
 if (str.length > 0)
 {
  if(para=='nombre'){
  	var index = unvalidateURL(str, INVALID_NAME);
  	cadena = INVALID_NAME;
  }else if(para=='fecha'){
  	var index = unvalidateURL(str, INVALID_DATE);
  	cadena = INVALID_DATE;
  }else if(para=='hora'){
  	var index = unvalidateURL(str, INVALID_TIME);
  	cadena = INVALID_TIME;
  }else if(para=='url'){
	var index = unvalidateURL(str, INVALID_FOR_URL);
	cadena = INVALID_FOR_URL;
  }else if(para=='email'){
  	var index = unvalidateURL(str, INVALID_FOR_MAIL);
  	cadena = INVALID_FOR_MAIL;
  }else if(para=='amacmd'){
	var index = unvalidateURL(str, INVALID_AMADEUS);
	cadena = INVALID_AMADEUS;
  }else if(para=='none'){
	var index = unvalidateURL(str, INVALID_NONE);
	cadena = INVALID_NONE;
  }else if(para=='number'){
  	//alert('Dentro de Number');
	var index = unvalidateURL(str, INVALID_NUMBER);
	cadena = INVALID_NUMBER;
  }else{
	var index = unvalidateURL(str, INVALID_FOR_TEXT);
	cadena = INVALID_FOR_TEXT;
  }
  if (index != -1)
  {
   //alert(index+" - "+str+" - "+para+" - "+unvalidateURL(str, INVALID_FOR_TEXT));
   //alert ("Los caracteres "+cadena+" no están permitidos");
   return false;
  }
 }
 return true;
}

//**----------------------------------------------------------------*/
//Funcion: limpiaURL
//Parametros:
//	str, 	cadena de caracteres
//	param,	parametro que distingue entre validaciones para URL's 
//		y nombres
//Retorno: cadena de caracteres sin caracteres no permitidos
//
// Elimina de la cadena 'str' todos los caracteres no permitidos. El
// conjunto de caracteres no permitidos depende del parámetro 'para'
// 
//**----------------------------------------------------------------*/
function limpiaURL(str,para) {
 var cadena = "";
  if(para=='nombre'){
  	cadena = "INVALID_NAME";
  }else if(para=='fecha'){
  	cadena = "INVALID_DATE";
  }else if(para=='hora'){
  	cadena = "INVALID_TIME";
  }else if(para=='url'){
	cadena = "INVALID_FOR_URL";
  }else if(para=='email'){
  	cadena = "INVALID_FOR_MAIL";
  }else if(para=='amacmd'){
	cadena = "INVALID_AMADEUS";
  }else if(para=='none'){
	cadena = "INVALID_NONE";
	}else if(para=='number'){
	cadena = "INVALID_NUMBER";
  }else{
	cadena = "INVALID_FOR_TEXT";
  }
 
 for (c = str.length-1; c >= 0; c--)
 {
  if (eval(cadena+".indexOf(str.charAt (c))") != -1)
  {
    str = str.substring(0,c)+str.substring(c+1);
  }
 }
 return(str);
}

//**----------------------------------------------------------------*/
//Funcion: validateAlphabeticStr
//Parametros:
//	str, 		cadena de caracteres
//	desc,		descripción del campo empleada en los avisos que se 
//			muestran al usuario en caso de error
//	compulsory,	indica si el campo es obligatorio o no. 
//Retorno: true/false
//
// Si el campo no es obligatorio  ( 'compulsory' == false ) y 'str' 
// está vació no se realiza ninguna comprobación.
// Si es obligatorio ( 'compulsory' == true ) y está vació se muestra 
// un aviso indicando esta circunstancia.
// Si es obligatorio y no está vació la función comprueba que los 
// caracteres de la cadena 'str' no pertenecen al conjunto INVALID_FOR_TEXT.
// 
//**----------------------------------------------------------------*/
function validateAlphabeticStr( str, desc, compulsory ){
	if( compulsory == true && !isFilled (str) ){
		alert( desc + " es un campo obligatorio." );
		return false;
	}
	
	if( str.length > 0 ){
		if( !unvalidate(str, INVALID_FOR_TEXT + DIGITS) ){
			alert( desc + " sólo puede contener carácteres alfabéticos" );
			return false;
		}
	}
	return true;
}

//**----------------------------------------------------------------*/
//Funcion: validateMail
//Parametros:
//	str, 		cadena de caracteres
//	desc,		descripción del campo empleada en los avisos que se 
//			muestran al usuario en caso de error
//	compulsory,	indica si el campo es obligatorio o no. 
//Retorno: true/false
//
// Si el campo no es obligatorio  ( 'compulsory' == false ) y 'str' 
// está vació no se realiza ninguna comprobación.
// Si es obligatorio ( 'compulsory' == true ) y está vació se muestra 
// un aviso indicando esta circunstancia.
// Si es obligatorio y no está vació la función comprueba que los 
// caracteres de la cadena 'str' no pertenecen al conjunto MAIL_VALID.
// Así mismo comprueba ciertos aspectos de la cadena, de forma que no 
// permite cadenas de longitud menor que 5, con espacios en blanco, sin 
// '@' y/o sin '.'
// 
//**----------------------------------------------------------------*/
function validateMail (str, desc, compulsory){
	if (compulsory == true && !isFilled (str)){
		alert (desc + " es un campo obligatorio.");
		return false;
	}
	if(str.indexOf(";") != -1){
		mail = str.substring(0,str.indexOf(";"));
	}else{
		mail = str;
	}
	var index = str.indexOf(";");
	//alert(mail+",index="+index);
	for(var i=0;i<mail.length;i++){
		if (str.length > 0){
			if (str.length < 5){
				alert (desc + " es demasiado corta.");
				return false;
			}
			if (!validate (mail, MAIL_VALID)){
			 //alert(mail);
				alert (desc +" "+mail+" no es válida.");
				return false;
			}
			if (str.indexOf ("@") == -1 || str.indexOf (".") == -1 || str.indexOf (" ") != -1){
				alert (desc + " no es válida.");
				return false;
			}
		}
	mail= str.substring(index+1,str.length);
	index = str.indexOf(";");
	//alert(mail+",index="+index);
	}//end for
	return true;
}

function validaMail(str) {
	if(str.indexOf(";") != -1){
		mail = str.substring(0,str.indexOf(";"));
	}else{
		mail = str;
	}
	var index = str.indexOf(";");
	//alert(mail+",index="+index);
	for(var i=0;i<mail.length;i++){
		if (str.length > 0){
			if (str.length < 5){
				return false;
			}
			if (!validate (mail, MAIL_VALID)){
				return false;
			}
			if (str.indexOf ("@") == -1 || str.indexOf (".") == -1 || str.indexOf (" ") != -1){
				return false;
			}
		}
		mail= str.substring(index+1,str.length);
		index = str.indexOf(";");
		//alert(mail+",index="+index);
	}//end for
	return true;
}

//**----------------------------------------------------------------*/
//Funcion: validatePhone
//Parametros:
//	str, 		cadena de caracteres
//	desc,		descripción del campo empleada en los avisos que se 
//			muestran al usuario en caso de error
//	compulsory,	indica si el campo es obligatorio o no. 
//Retorno: true/false
//
// Si el campo no es obligatorio  ( 'compulsory' == false ) y 'str' 
// está vació no se realiza ninguna comprobación.
// Si es obligatorio ( 'compulsory' == true ) y está vació se muestra 
// un aviso indicando esta circunstancia.
// Si es obligatorio y no está vació la función comprueba que los 
// caracteres de la cadena 'str' no pertenecen al conjunto PHONE_VALID.
// Así mismo comprueba ciertos aspectos de la cadena, de forma que no 
// permite cadenas de longitud menor que 9, que no empiecen por 
// '6','8' o '9',con un número de digitos menor que 9.
// 
//**----------------------------------------------------------------*/
function validatePhone (str, desc, compulsory)
{
	if (compulsory == true && !isFilled (str))
	{
		alert (desc + " es un campo obligatorio.");
		return false;
	}
	
	if (str.length > 0)
	{
		if (str.length < 9)
		{
			alert (desc + " es demasiado corto.");
			return false;
		}
		if (str.charAt (0) != '6' && str.charAt (0) != '9' && str.charAt (0) != '8')
		{
			alert (desc + " es incorrecto.");
			return false;
		}
		if (!validate (str, PHONE_VALID))
		{
			alert (desc + " no es válido.");
			return false;
		}
		dashes = 0;
		for (i=0;i< str.length;i++)
		{
			if (str.charAt (i) == '-')
			{
				dashes++;
			}
		}
		if ((str.length - dashes) != 9)
		{
			alert (desc + " no es válido");
			return false;
		}
	}
	return true;
}

function validaPhone(str) {
	if (str.length > 0) {
		if (str.length < 9) {
			return false;
		}
		if (!validate (str, PHONE_VALID))
		{
			return false;
		}
	}
	return true;
}
//**----------------------------------------------------------------*/
//Funcion: validateFax
//Parametros:
//	str, 		cadena de caracteres
//	desc,		descripción del campo empleada en los avisos que se 
//			muestran al usuario en caso de error
//	compulsory,	indica si el campo es obligatorio o no. 
//Retorno: true/false
//
// Si el campo no es obligatorio  ( 'compulsory' == false ) y 'str' 
// está vació no se realiza ninguna comprobación.
// Si es obligatorio ( 'compulsory' == true ) y está vació se muestra 
// un aviso indicando esta circunstancia.
// Si es obligatorio y no está vació la función comprueba que los 
// caracteres de la cadena 'str' no pertenecen al conjunto PHONE_VALID.
// Así mismo comprueba ciertos aspectos de la cadena, de forma que no 
// permite cadenas de longitud menor que 9, que no empiecen por 
// '8' o '9',con un número de digitos menor que 9.
// 
//**----------------------------------------------------------------*/
function validateFax (str, desc, compulsory)
{
	if (compulsory == true && !isFilled (str))
	{
		alert (desc + " es un campo obligatorio.");
		return false;
	}
	
	if (str.length > 0)
	{
		if (str.length < 9)
		{
			alert (desc + " es demasiado corto.");
			return false;
		}
		if (str.charAt (0) != '9' && str.charAt (0) != '8')
		{
			alert (desc + " es incorrecto");
			return false;
		}
		if (!validate (str, PHONE_VALID))
		{
			alert (desc + " no es válido.");
			return false;
		}
		dashes = 0;
		for (i=0;i< str.length;i++)
		{
			if (str.charAt (i) == '-')
			{
				dashes++;
			}
		}
		if ((str.length - dashes) != 9)
		{
			alert (desc + " no es válido");
			return false;
		}
	}
	return true;
}

//**----------------------------------------------------------------*/
//Funcion: validateZip
//Parametros:
//	str, 		cadena de caracteres
//	provStr,	código de provincia
//	desc,		descripción del campo empleada en los avisos que se 
//			muestran al usuario en caso de error
//	compulsory,	indica si el campo es obligatorio o no. 
//Retorno: true/false
//
// Si el campo no es obligatorio  ( 'compulsory' == false ) y 'str' 
// está vació no se realiza ninguna comprobación.
// Si es obligatorio ( 'compulsory' == true ) y está vació se muestra 
// un aviso indicando esta circunstancia.
// Si es obligatorio y no está vació la función comprueba que los 
// caracteres de la cadena 'str' no pertenecen al conjunto ZIP_VALID.
// Así mismo comprueba ciertos aspectos de la cadena, de forma que no 
// permite cadenas de longitud menor que 5 y que los dos primeros 
// dígitos coincidan con los dígitos de la provincia dada por 'provStr'.
// 
//**----------------------------------------------------------------*/
function validateZip (str, provStr, desc, compulsory)
{
	if (compulsory == true && !isFilled (str))
	{
		alert (desc + " es un campo obligatorio.");
		return false;
	}
	
	if (str.length > 0)
	{
		if (str.length < 5)
		{
			alert (desc + " es demasiado corto.");
			return false;
		}
		if (!validate (str, ZIP_VALID))
		{
			alert (desc + " no es válido.");
			return false;
		}
		if (parseInt(str.substring (0, 2)) != parseInt(provStr))
		{
			alert (desc + " no se corresponde con la provincia seleccionada.");
			return false;
		}
	}
	return true;
}

//**----------------------------------------------------------------*/
//Funcion: validateTime
//Parametros:
//	stime, 		cadena de caracteres
//Retorno: '' en caso de error/ 'stime' si todo es correcto
//
// Se comprueba que 'stime' sea de la forma 'HH:MM'.
// La hora se puede introducir en formato 'HH:MM' o 'HHMM'.
// Siempre se devuelve en formato 'HH':MM'.
// 
//**----------------------------------------------------------------*/
function validateTime(stime){
 var desplazamiento =0; 
 if ((stime.length < 4) || (stime.length > 5)) return "";
 if (stime.length==5) {
  	desplazamiento =1;
 }
 var hora = stime.substring(0,2);
 var min  = stime.substring(2+desplazamiento,4+desplazamiento);
  if ((!validate(hora,DIGITS))||(!validate(hora,DIGITS))) {
   return "";
 }
 ihora = parseInt(hora);
 imin = parseInt(min);
 if ((ihora>23)||(imin>59)) return "";
 
 if (stime.length==5){
   if (!stime.substring(3,4)==":"){
	    return "";
   }
 }else{
  stime=hora+":"+min;
 }

 return stime;
}

//**----------------------------------------------------------------*/
//Funcion: isLeapYear
//Parametros:
//	year, 		número
//Retorno: true/false
//
// Se comprueba si 'year' es un año bisiesto o no.
// 
//**----------------------------------------------------------------*/
function isLeapYear (year)
{
	return ((((year%4)==0) && !((year%100)==0)) || (((year%4)==0) && ((year%400)==0)));
}

//**----------------------------------------------------------------*/
//Funcion: validateDate
//Parametros:
//	str, 			cadena de caracteres
//	desc,			descripción del campo empleada en los avisos que se 
//				muestran al usuario en caso de error
//	compulsory,		indica si el campo es obligatorio o no. 
//	canBeInTheFuture,	indica si puede ser en el futuro
//	mostrar,		indica si se tienen que mostrar los avisos
//Retorno: true/false
//
// Se comprueba si 'str' es una fecha válida, con formato 'dd/mm/yyyy'.
// El formato de entrada de la fecha puede ser uno de los siguientes:
//	-  'dd/mm/yyyy'
//	-  'dd/mm/yy'
//	-  'ddmmyyyy'
//	-  'ddmmyy'
//**----------------------------------------------------------------*/
function validateDate (str, desc, compulsory, canBeInTheFuture, mostrar)
{
	mensaje = "La fecha debe ser de la forma\ndd/mm/aaaa";

	if (compulsory && (!isFilled (str) || str=='dd/mm/aaaa'))
	{
		        if (mostrar)
			alert (desc + " es un campo obligatorio.");
			return false;
	}
	
	if (str.length > 0)
	{
		if (!validate (str, DATE_VALID))
		{
		        if (mostrar)
			alert (desc + " no es una fecha valida.\n"+mensaje);
			return false;
		}
		if((str.length < 6) || (str.length == 7) || (str.length == 9))
		{
			if (mostrar)
				alert (desc + " debe ser de la forma ddmmaa, ddmmaaaa, dd/mm/aa o dd/mm/aaaa.\n");
			return false;
		
		}
		if(str.length == 10){
			if(str.substring(2,3) == "/" && str.substring(5,6) == "/"){
				compactedDate = str.substring (0, 2) + str.substring (3, 5) + str.substring (6, 10);
			}else{
				if (mostrar) 
					alert (desc + " no es una fecha valida.\n"+mensaje);
				return false;
			}
		}else if(str.length == 8){
			if(str.substring(2,3) == "/" && str.substring(5,6) == "/"){
				compactedDate = str.substring (0, 2) + str.substring (3, 5) + "20"+ str.substring (6, 8);
			}else{
				if (str.substring(2,3) != "/" && str.substring(5,6) != "/"){
					compactedDate = str;
				}else {
					return false;
				}
			}
		}else if(str.length == 6){
			compactedDate = str.substring (0, 4) +"20"+ str.substring (4, 6);
		}
		if (!validate (compactedDate, DIGITS))
		{
		        if (mostrar)
			alert (desc + " no es una fecha valida.\n"+mensaje);
			return false;
		}
		if(compactedDate.substring (0, 1) == "0"){
			day = parseInt (compactedDate.substring (1, 2));
		}else{
			day = parseInt (compactedDate.substring (0, 2));
		}
		if(compactedDate.substring (2, 3) == "0"){
			month = parseInt (compactedDate.substring (3, 4));
		}else{
			month = parseInt (compactedDate.substring (2, 4));
		}
		year = parseInt (compactedDate.substring (4, 8));
		REGULAR_MONTHS = new Array (31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31);
		LEAP_MONTHS = new Array (31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31);
		curDate = new Date ();

		if((month < 1) || (month > 12)){
		        if (mostrar)
			alert("Mes no valido.\nDebe estar entre 1 y 12.");
			return false;
		}
		//alert(canBeInTheFuture);
		if (!canBeInTheFuture)
		{
			curYear = curDate.getYear();
			curMonth = curDate.getMonth () + 1;
     //alert(curYear+">"+year);
		 //alert(curMonth+">"+month);
		 //alert(curDate.getDate()+" >"+ day);
			if (curYear < year || 
			    curYear == year && curMonth < month ||
			    curYear == year && curMonth == month  && curDate.getDate()<day)
			{
                      		        if (mensaje)
					alert (desc + " es posterior a la fecha actual.");
					return false;
			}
		}

		if (isLeapYear (year))
		{
			if (day < 1 || day > LEAP_MONTHS[month-1])
			{
        		        if (mostrar)
				alert (desc + " no es una fecha válida. 1");
				return false;
			}
		}
		else
		{
			if (day < 1 || day > REGULAR_MONTHS[month-1])
			{
        		        if (mostrar)
				alert (desc + " no es una fecha válida. 2");
				return false;
			}
		}	
	}
	return true;
}

//**----------------------------------------------------------------*/
//Funcion: validateYear
//Parametros:
//	str, 			cadena de caracteres
//	desc,			descripción del campo empleada en los avisos que se 
//				muestran al usuario en caso de error
//	compulsory,		indica si el campo es obligatorio o no. 
//Retorno: true/false
//
// Se comprueba si 'str' es una añó válido,inferior al año en curso
// pero no menor de 1800.
//**----------------------------------------------------------------*/
function validateYear (str, desc, compulsory)
{
	if (compulsory == true && !isFilled (str))
	{
		alert (desc + " es un campo obligatorio.");
		return false;
	}
	
	if (str.length != 4)
	{
		alert (desc + " debe tener por 4 dígitos.");
		return false;
	}
	
	if (!validate (str, DIGITS))
	{
		alert (desc + " es inválido.");
		return false;
	}
	
	year = parseInt (str);
	curYear = new Date().getYear() + 1900;
	
	if (year < 1800)
	{
		alert (desc + " es demasiado antiguo");
		return false;
	}
	
	if (year > curYear)
	{
		alert (desc + " debe ser menor del año actual (" + curYear + ")");
		return false;
	}
	return true;
}

//**----------------------------------------------------------------*/
//Funcion: validateNIF
//Parametros:
//	nif, 			número de identificación fiscal
//	desc,			descripción del campo empleada en los avisos que se 
//				muestran al usuario en caso de error
//Retorno: true/false
//
// Se comprueba si 'nif' es un nif válido.
//**----------------------------------------------------------------*/
function validateNIF (nif, desc)
{
	numeros=nif.substring (0, nif.length-1);
	letra=nif.substring (nif.length-1).toUpperCase();
	if (!validate (numeros, DIGITS) || !validate (letra, LETTERS))
	{
		alert (desc + " no es correcto");
		return false;
	}
	ctrlLetters = 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","T");
	index = numeros - (parseInt (numeros/23)*23);
	if (ctrlLetters[index] != letra)
	{
		alert (desc + " no es correcto");
		return false;
	}
	return true;
}

//**----------------------------------------------------------------*/
//Funcion: validateCIF
//Parametros:
//	cif, 			código de identificación fiscal
//	desc,			descripción del campo empleada en los avisos que se 
//				muestran al usuario en caso de error
//Retorno: true/false
//
// Se comprueba si 'cif' es un cif válido.
//**----------------------------------------------------------------*/
function validateCIF (cif, desc) {
	var letras = "ABCDEFGHPQS";
	var letras2 = "ABCDEFGHIJ";
	var numeros = "0123456789";
    
	// Comprobar la longitud
	if (cif.length != 9)
	{
		alert (desc + " no tiene una longitud correcta");
		return false;
	}
	
	// Comprobar la primera letra
	if (letras.indexOf (cif.toUpperCase().charAt (0)) == -1)
	{
		alert (desc + " no es correcto.");
		return false;
	}
	
	// Comprobar que el resto son numeros (salvo el ultimo)
	for (var n = 1; n < (cif.length - 1); n++)
	{
		if (numeros.indexOf (cif.charAt (n)) == -1)
		{
			alert (desc + " no es correcto.");
			return false;
		}
	}    
	
	// Calcular los pesos
	var i1 = 2 * parseInt (cif.charAt (1));
	if (i1 > 9)
	{
		i1 = 1 + i1 % 10;
	}
	var i3 = 2 * parseInt (cif.charAt (3));
	if (i3 > 9)
	{
		i3 = 1 + i3 % 10;
	}
	var i5 = 2 * parseInt (cif.charAt (5));
	if (i5 > 9)
	{
		i5 = 1 + i5 % 10;
	}
	var i7 = 2 * parseInt (cif.charAt (7));
	if (i7 > 9)
	{
		i7 = 1 + i7 % 10;
	}    
	
	// Sumar cifras y quedarnos con la ultima
	var suma = i1 + parseInt (cif.charAt (2)) +
	           i3 + parseInt (cif.charAt (4)) +
	           i5 + parseInt (cif.charAt (6)) +
	           i7;
	suma = suma.toString().charAt (suma.toString().length - 1);
	
	// Comprobar la letra o el digito de control
	var digito = 10 - suma;
	if (digito == 10)
	{
		digito = 0;
	}
	var letra = 10 - suma;
	if (letra == 0)
	{
		letra = 10;
	}
	var letraOk = letras2.toUpperCase().charAt (letra - 1);
	if ((cif.toUpperCase().charAt (8) == letraOk) || (cif.charAt (8) == digito))
	{
		return true;
	}
	
	alert (desc + " no es correcto");
	return false;
}
  
//**----------------------------------------------------------------*/
//Funcion: validateDocument
//Parametros:
//	str, 			documento
//	docType,		tipo de docuemento
//	desc,			descripción del campo empleada en los avisos que se 
//				muestran al usuario en caso de error
//	compulsory,		indica si el campo es obligatorio
//Retorno: true/false
//
// Se comprueba si 'str' es un documento del tipo indicado por 'docType'.
//**----------------------------------------------------------------*/
function validateDocument (str, docType, desc, compulsory)
{
	if (compulsory == true && !isFilled (str))
	{
		alert (desc + " es un campo obligatorio.");
		return false;
	}
	
	if (docType == CIF_CODE)
	{
		return validateCIF (str, desc);
	}
	else if (docType == NIF_CODE)
	{
		return validateNIF (str, desc);
	}
}

//**----------------------------------------------------------------*/
//Funcion: carga_cadena
//Parametros:
//	el_string, 		cadena de caracteres
//	el_array,		array de la misma longitud que 'el_string' 
//				que contiene una representación en float
//				de 'el_string'
//Retorno: true/false
//
//**----------------------------------------------------------------*/
function carga_cadena (el_string, el_array) 
{
	for(c=0; c < el_string.length; c++)
	{
  		el_array[c] = parseFloat (el_string.substring(c, c + 1));
  	}
}

//**----------------------------------------------------------------*/
//Funcion: validateBankAccount
//Parametros:
//	bank, 		código de banco
//	agency,		código de agencia
//	dc,		dígitos de control
//	acc,		número de cuenta
//Retorno: true/false
//
// Se comprueba que el conjunto 'bank','agency','dc' y 'acc' forman
// un número de cuenta válido.
//**----------------------------------------------------------------*/
function validateBankAccount (bank, agency, dc, acc)
{
	if (bank.length != 4)
	{
		alert ("El código del banco debe tener 4 dígitos.");
		return false;
	}
	if (agency.length != 4)
	{
		alert ("El código de la agencia bancaria debe tener 4 dígitos.");
		return false;
	}
	if (dc.length != 2)
	{
		alert ("Los dígitos de control de la cuanta bancaria deben ser 2.");
		return false;
	}
	
	zeroes = "0000000000";
	acc = zeroes.substring (0, acc.length-10) + acc;
	
	if (!validate (bank, DIGITS) || !validate (agency, DIGITS) ||
	    !validate (dc, DIGITS) || !validate (acc, DIGITS))
	{
		alert ("Los campos de una cuenta bancaria sólo pueden estar compuestos por dígitos.");
		return false;
	}
	
	Entidad = new Array(bank.length);
	Sucursal = new Array(agency.length);
	Digito = new Array(dc.length);
	Cuenta = new Array(acc.length);
	carga_cadena(bank,Entidad);
	carga_cadena(agency,Sucursal);
	carga_cadena(acc,Cuenta);
	var calculo1 = Entidad[0]*4 + Entidad[1]*8 + Entidad[2]*5 + Entidad[3]*10 + Sucursal[0]*9 + Sucursal[1]*7 + Sucursal[2]*3 + Sucursal[3]*6 ;
	var calculo2 = calculo1/11;
	var calculo3 = parseInt(calculo2);
	var calculo4 = calculo3 * 11;
	var calculo5 = calculo1 - calculo4;
	Digito1 = 11 - calculo5;
	var calculoa = Cuenta[0]*1 + Cuenta[1]*2 + Cuenta[2]*4 + Cuenta[3]*8 + Cuenta[4]*5 + Cuenta[5]*10 + Cuenta[6]*9 + Cuenta[7]*7 + Cuenta[8]*3 + Cuenta[9]*6;
	var calculob = calculoa/11;
	var calculoc = parseInt(calculob);
	var calculod = calculoc * 11;
	var calculoe = calculoa - calculod;
	Digito2 = 11 - calculoe;
	if (Digito1 ==10) Digito1=1;
	if (Digito1 ==11) Digito1=0;
	if (Digito2 ==10) Digito2=1;
	if (Digito2 ==11) Digito2=0;
	carga_cadena(dc,Digito);
	if(!((Digito[0] == Digito1) && (Digito[1] == Digito2)))
	{
		alert ("La cuenta bancaria no es válida.");
  	return false;
	}
  return true;
}

//**----------------------------------------------------------------*/
//Funcion: emailChecker
//Parametros:
//	email, 		cadena de caracteres
//
//Retorno: true/false
//
// Comprueba que el 'email' tiene el formato de una cuenta de correo.
//**----------------------------------------------------------------*/
function emailChecker(email){
 var index_of_at = email.indexOf("@");
 var index_of_last_dot = email.lastIndexOf(".");
 var extension = email.substring((index_of_last_dot+1)).length;
 var length = email.length;
 if ((index_of_at < 1) || (index_of_last_dot < index_of_at) || (index_of_last_dot > length - 3) || (index_of_last_dot +1 < length - extension)){
 	return false;
 }else{	
 	return true;
 }
}
/**-------------------------------------*/
//Funcion: comprueba
//Parametros:
//	texto, texto para comprobar.
//Retorno: La cadena con los carácteres
//         incorrectos eliminados.
//**-------------------------------------**
function comprueba(texto,para) {
  var correcto = validateURL(texto,para);
//  alert(correcto);
  if (!correcto) {
    return(limpiaURL(texto,para));
  } else {
    return(texto);
  }
}
/**------------------------------------------------------*/
//Funcion: InputText
//Parametros:
//	nombre, nombre del input que quieres crear.
//	type, tipo del input.
//  size, tamaño del input, auxiliado por la función
//        getLength.
//  maxlength, cantidad de carácteres permitidos
//             en el input.
//  clase, la clase de estilos que se le aplicará.
//  codigo, aquí podemos introducir todos los eventos
//          permitidos por el input
//  value, valor por defecto del input.
//  para, si le pasamos el valor (nombre) validará con 
//        con la cadena INVALID_FOR_URL
//  tab, con este indice controlaremos el tabindex
//Retorno: Escribe un input type="text"
//**------------------------------------------------------**
function InputText( name, size, maxlength, clase, codigo, value, para, tab ){
	var output = '<input type="text" name="' + name + '" maxlength="' + maxlength + '"  value="' + value + '" tabindex="' + tab + '" ';
	output += (clase != "")? ' class="' + clase + '" ' : '';
	output += (size  != "")? ' size="' + getLength(size) + '" ' : '';
	output += ' ' + codigo;
	output += ' onKeyUp="var newval=comprueba(value,\''+para+'\');if(value != newval) {value = newval;}">';
	document.write(output);
}

function InputPass( name, size, maxlength, clase, codigo, value, para, tab ){
	var output = '<input type="password" name="' + name + '" maxlength="' + maxlength + '"  value="' + value + '" tabindex="' + tab + '" ';
	output += (clase != "")? ' class="' + clase + '" ' : '';
	output += (size  != "")? ' size="' + getLength(size) + '" ' : '';
	output += ' ' + codigo;
	output += ' onKeyUp="var newval=comprueba(value,\''+para+'\');if(value != newval) {value = newval;}">';
	document.write(output);
}

function getImage(id,src,width,heigth){
	var output = '<img id="'+id+'" name="'+id+'" src="'+src+'" width="'+width+'" height="'+heigth+'"/>';
	return output;
}

function validaExpediente(expediente) {
	var letraExp = 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");

	expediente = expediente.toUpperCase();
	var empresa = expediente.substring(1,3);
	var letra = expediente.substring(expediente.length-1);
	expediente = expediente.substring(3, expediente.length-1);
	while (empresa.substring(0,1) == "0") {
		empresa = empresa.substring(1);
	}
	while (expediente.substring(0,1) == "0") {
		expediente = expediente.substring(1);
	}
	expediente = empresa + expediente;
	var index = parseInt(expediente) - (Math.floor(parseInt(expediente)/23)*23);
	if (letra == letraExp[index]) {
		return(true);
	}
	return(false);
}

//**----------------------------------------------------------------*/
//Funcion: validatePhonePT
//Parametros:
//	str, 		cadena de caracteres
//	desc,		descripción del campo empleada en los avisos que se 
//			muestran al usuario en caso de error
//	compulsory,	indica si el campo es obligatorio o no. 
//Retorno: true/false
//
// Nueva función para que valide también los teléfonos de PT.
//
//**----------------------------------------------------------------*/
function validatePhonePT (str, desc, compulsory)
{
	if (compulsory == true && !isFilled (str))
	{
		alert (desc + " es un campo obligatorio.");
		return false;
	}

	if (str.length > 0)	{
		
		if (str.length > 5)	{
			var telefonoString = new String(str);
			var regExpTelefono = /^\+?[\d\s\-\(\))]{3,}$/;
			if (!telefonoString.match(regExpTelefono)) {
				alert (desc + " es incorrecto.");
				return false;
				
			}

		} else {
			alert (desc + " es demasiado corto.");
			return false;
			
		}

	} else {
		alert (desc + " es un campo obligatorio.");
		return false;
		
	}

	return true;
}