/*
* Author(s)   : Jordi Raya
* Date        : 19/02/2003
* Version     : 1.07
* Last update : 20/10/2003
* File        : validador.js
* Description : Funciones de validación de campos de formularios
*   El comportamiento de las validaciones, junto con una descripción de los parámetros, pueden observarse en el archivo validador.htm
*   Necesita un archivo con los mensajes de error que se vayan a utilizar, tipo validador_errores_es.js
*   Necesita el archivo formato.js para construir los objetos de tipo Formato que se utilizen
*   Las funciones públicas devolverán true o false en función del parámetro msg, o una Array con los mensajes de error si msg es null
*/

// cadenas de validación

var cadenaAlfabeto      = "ABCÇDEFGHIJKLMNÑOPQRSTUVWXYZabcçdefghijklmnñopqrstuvwxyzÁÉÍÓÚÀÈÌÒÌÙÄËÏÖÜÂÊÎÔÛáéíóúàèìòìäëïöüâêîôû";
var cadenaAlfabetoASCII = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
var cadenaLetrasNombres = "ABCÇDEFGHIJKLMNÑOPQRSTUVWXYZabcçdefghijklmnñopqrstuvwxyzÁÉÍÓÚÀÈÌÒÌÙÄËÏÖÜÂÊÎÔÛáéíóúàèìòìäëïöüâêîôû-'";
var cadenaNumeros       = "1234567890";
var cadenaEmail         = cadenaNumeros + cadenaAlfabetoASCII + "@._-";
var cadenaASCII         = "";
for (n=32; n<128; n++){ cadenaASCII += String.fromCharCode(n); }

function fechaMayorOIgualQue(fec0, fec1){ 
    var bRes = false; 
    var sDia0 = fec0.value.substr(0, 2); 
    var sMes0 = fec0.value.substr(3, 2); 
    var sAno0 = fec0.value.substr(6, 4); 
    var sDia1 = fec1.value.substr(0, 2); 
    var sMes1 = fec1.value.substr(3, 2); 
    var sAno1 = fec1.value.substr(6, 4); 
    if (sAno0 > sAno1) bRes = true; 
    else { 
     if (sAno0 == sAno1){ 
      if (sMes0 > sMes1) bRes = true; 
      else { 
       if (sMes0 == sMes1) 
        if (sDia0 >= sDia1) bRes = true; 
      } 
     } 
    } 
    return bRes; 
   } 

function validar_select(objeto,campo)
{
	if (objeto.options[objeto.selectedIndex].value == 0)
	{
		alert("Debe selecionar el campo "+campo);
		return false;
	} 

	return true;

}

function validar_radio(objeto,campo)
{
	var i=0;
	var encontrado = false;

	
	if(objeto.checked==true) {encontrado = true};
	
	while ((i<objeto.length) && (!encontrado))
	{ 
       if (objeto[i].checked)
	   {
	   	 	encontrado = true;
	   }
	   i++;
    } 
	if (!encontrado)
	{
		alert("Debe indicar "+campo);
	}
	return encontrado;
}

function validar_check(nombrecheck,formulario, mensaje)
{

	for(i=0; i<formulario.elements.length; i++) {
	    if(formulario.elements[i].name==nombrecheck) {
		  	if(formulario.elements[i].checked)	{
				return true;
			}
		}
	}

	alert("Debe seleccionar "+mensaje);
	return false;	
}

// funciones públicas de validación alfanuméricas

function isTexto(obj,nom,obl,msg,foc,spa){
  var args = isTexto.arguments;	
  var cad = getInputString(obj);	
  var errors = new Array();
  if ((obl == false) && (cad == "")){ return processErrors(obj,msg,foc,errors); }
  errors = addErrors(checkCommonText(cad,nom,obl,spa,null,null,6,7,args),errors); 
  return processErrors(obj,msg,foc,errors);  	  	
}

function isTextoASCII(obj,nom,obl,msg,foc,spa){
  var args = isTextoASCII.arguments;
  var cad = getInputString(obj);
  var errors = new Array();
  if ((obl == false) && (cad == "")){ return processErrors(obj,msg,foc,errors); }
  errors = addErrors(checkCommonText(cad,nom,obl,spa,cadenaASCII,errorCaracteresNoValidos,6,7,args),errors);
  return processErrors(obj,msg,foc,errors); 
}

function isAlfanumerico(obj,nom,obl,msg,foc,spa){
  var args = isAlfanumerico.arguments;
  var cad = getInputString(obj);
  var errors = new Array();
  if ((obl == false) && (cad == "")){ return processErrors(obj,msg,foc,errors); }
  errors = addErrors(checkCommonText(cad,nom,obl,spa,cadenaAlfabeto + cadenaNumeros + " ",errorSoloAlfanumerico,6,7,args),errors);
  return processErrors(obj,msg,foc,errors); 
}

function isAlfanumericoASCII(obj,nom,obl,msg,foc,spa){
  var args = isAlfanumericoASCII.arguments;
  var cad = getInputString(obj);  
  var errors = new Array();
  if ((obl == false) && (cad == "")){ return processErrors(obj,msg,foc,errors); }
  errors = addErrors(checkCommonText(cad,nom,obl,spa,cadenaAlfabetoASCII + cadenaNumeros + " ",errorSoloAlfanumericoASCII,6,7,args),errors);   
  return processErrors(obj,msg,foc,errors);  
}

function isAlfanumericoFormato(obj,nom,obl,msg,foc,spa,formato){
  var args = isAlfanumericoFormato.arguments;
  var cad = getInputString(obj);  
  var errors = new Array();
  if ((obl == false) && (cad == "")){ return processErrors(obj,msg,foc,errors); }
  var cadComparar = null;
  if (formato != null){
    cadComparar = cadenaNumeros + formato.getIdioma().getAlfabeto();
  }  
  errors = addErrors(checkCommonText(cad,nom,obl,spa,cadComparar,errorCaracteresNoValidos,7,8,args),errors);  
  return processErrors(obj,msg,foc,errors);
}

function isAlfabetico(obj,nom,obl,msg,foc,spa){	
  var args = isAlfabetico.arguments;
  var cad = getInputString(obj);
  var errors = new Array();
  if ((obl == false) && (cad == "")){ return processErrors(obj,msg,foc,errors); }
  errors = addErrors(checkCommonText(cad,nom,obl,spa,cadenaAlfabeto + " ",errorSoloAlfabetico,6,7,args),errors); 
  return processErrors(obj,msg,foc,errors);
}

function isAlfabeticoASCII(obj,nom,obl,msg,foc,spa){	
  var args = isAlfabeticoASCII.arguments;
  var cad = getInputString(obj);
  var errors = new Array();
  if ((obl == false) && (cad == "")){ return processErrors(obj,msg,foc,errors); }
  errors = addErrors(checkCommonText(cad,nom,obl,spa,cadenaAlfabetoASCII + " ",errorSoloAlfabeticoASCII,6,7,args),errors);   
  return processErrors(obj,msg,foc,errors);
}

function isAlfabeticoFormato(obj,nom,obl,msg,foc,spa,formato){
  var args = isAlfabeticoFormato.arguments;
  var cad = getInputString(obj);  
  var errors = new Array();
  if ((obl == false) && (cad == "")){ return processErrors(obj,msg,foc,errors); }
  var cadComparar = null;
  if (formato != null){
    cadComparar = formato.getIdioma().getAlfabeto();
  }  
  errors = addErrors(checkCommonText(cad,nom,obl,spa,cadComparar,errorCaracteresNoValidos,7,8,args),errors);  
  return processErrors(obj,msg,foc,errors);
}

function isNombre(obj,nom,obl,msg,foc,spa){	
  var args = isNombre.arguments;
  var cad = getInputString(obj);
  var errors = new Array();
  if ((obl == false) && (cad == "")){ return processErrors(obj,msg,foc,errors); }
  errors = addErrors(checkCommonText(cad,nom,obl,spa,cadenaLetrasNombres + " ",errorCaracteresNoValidos,6,7,args),errors);    
  return processErrors(obj,msg,foc,errors);  
}

function isNumerico(obj,nom,obl,msg,foc,spa){
  var args = isNumerico.arguments;
  var cad = getInputString(obj);
  var errors = new Array();
  if ((obl == false) && (cad == "")){ return processErrors(obj,msg,foc,errors); }
  errors = addErrors(checkCommonText(cad,nom,obl,spa,cadenaNumeros + " ",errorSoloNumerico,6,7,args),errors);   
  return processErrors(obj,msg,foc,errors);
}

function isValidoInclusivo(obj,nom,obl,msg,foc,spa,cadValidacion){
  var args = isValidoInclusivo.arguments;
  var cad = getInputString(obj);
  var errors = new Array();
  if ((obl == false) && (cad == "")){ return processErrors(obj,msg,foc,errors); }
  errors = addErrors(checkCommonText(cad,nom,obl,spa,cadValidacion + " ",errorCaracteresNoValidos,7,8,args),errors);   
  return processErrors(obj,msg,foc,errors);
}

function isValidoExclusivo(obj,nom,obl,msg,foc,spa,cadInvalidacion){
  var args = isValidoExclusivo.arguments;
  var cad = getInputString(obj);
  var errors = new Array();
  if ((obl == false) && (cad == "")){ return processErrors(obj,msg,foc,errors); }  
  if (obl != null){
    errors = addErrors(checkCompulsory(cad,nom,obl),errors);
  } 
  if (spa != null){
    errors = addErrors(checkSpaces(cad,nom,spa),errors);
  }
  if (cadInvalidacion != null){
    errors = addErrors(checkNotInString(cad,nom,cadInvalidacion,errorCaracteresNoValidos),errors);
  }
  if ((args.length > 7) && (args[7] != null)){
    errors = addErrors(checkMinLength(cad,nom,args[7]),errors);    
  }  	
  if ((args.length > 8) && (args[8] != null)){
    errors = addErrors(checkMaxLength(cad,nom,args[8]),errors);	
  }  
  return processErrors(obj,msg,foc,errors);
}


// funciones públicas de validación numéricas

function isEntero(obj,nom,obl,msg,foc,formato){	
  var args = isEntero.arguments;
  var cad = getInputString(obj);
  var errors = new Array();
  if ((obl == false) && (cad == "")){ return processErrors(obj,msg,foc,errors); }  
  if (obl != null){
    errors = addErrors(checkCompulsory(cad,nom,obl),errors);
  }  
  if (formato == null){
    formato = new Formato();
  }
  errors = addErrors(checkUnsigned(cad,nom),errors);
  errors = addErrors(checkInString(cad,nom,cadenaNumeros + formato.getSeparadorMiles(),errorCaracteresNoValidos),errors);
  errors = addErrors(checkFormatInteger(cad,nom,formato),errors);      
  if (errors.length == 0){   
    if ((args.length > 6) && (args[6] != null)){
      errors = addErrors(checkMinIntegerValue(cad,nom,args[6]),errors);    
    }  	
    if ((args.length > 7) && (args[7] != null)){
      errors = addErrors(checkMaxIntegerValue(cad,nom,args[7]),errors);	
    }      
  }
  if ((args.length > 8) && (args[8] != null)){
    errors = addErrors(checkMinLength(cad,nom,args[8]),errors);    
  }  	
  if ((args.length > 9) && (args[9] != null)){
    errors = addErrors(checkMaxLength(cad,nom,args[9]),errors);	
  }   
  return processErrors(obj,msg,foc,errors);
}

function isEnteroSigno(obj,nom,obl,msg,foc,formato){	
  var args = isEnteroSigno.arguments;
  var cad = getInputString(obj);
  var errors = new Array();
  if ((obl == false) && (cad == "")){ return processErrors(obj,msg,foc,errors); }  
  if (obl != null){
    errors = addErrors(checkCompulsory(cad,nom,obl),errors);
  }  
  if (formato == null){
    formato = new Formato();
  }
  var signo = getSign(cad);  
  cad = getUnsignedPart(cad); 
  errors = addErrors(checkInString(cad,nom,cadenaNumeros + formato.getSeparadorMiles(),errorCaracteresNoValidos),errors);
  cad = signo + cad;
  errors = addErrors(checkFormatInteger(cad,nom,formato),errors);      
  if (errors.length == 0){   
    if ((args.length > 6) && (args[6] != null)){
      errors = addErrors(checkMinIntegerValue(cad,nom,args[6]),errors);    
    }  	
    if ((args.length > 7) && (args[7] != null)){
      errors = addErrors(checkMaxIntegerValue(cad,nom,args[7]),errors);	
    }      
  }
  if ((args.length > 8) && (args[8] != null)){
    errors = addErrors(checkMinLength(cad,nom,args[8]),errors);    
  }  	
  if ((args.length > 9) && (args[9] != null)){
    errors = addErrors(checkMaxLength(cad,nom,args[9]),errors);	
  }   
  return processErrors(obj,msg,foc,errors);
}

function isDecimal(obj,nom,obl,msg,foc,formato){	
  var args = isDecimal.arguments;
  var cad = getInputString(obj);      
  var errors = new Array();
  if ((obl == false) && (cad == "")){ return processErrors(obj,msg,foc,errors); }  
  if (obl != null){
    errors = addErrors(checkCompulsory(cad,nom,obl),errors);
  }  
  if (formato == null){
    formato = new Formato();
  }
// comprobacion y tratamiento de entero  
  if ( (args.length > 8) && (args[8] == 0) && (!isCharInString(cad,formato.getSimboloDecimal())) ){
    errors = addErrors(checkUnsigned(cad,nom),errors);
    errors = addErrors(checkInString(cad,nom,cadenaNumeros + formato.getSeparadorMiles(),errorCaracteresNoValidos),errors);
    errors = addErrors(checkFormatInteger(cad,nom,formato),errors);
    if (errors.length == 0){   
      if ((args.length > 6) && (args[6] != null)){
        errors = addErrors(checkMinIntegerValue(cad,nom,args[6]),errors);    
      }  	
      if ((args.length > 7) && (args[7] != null)){
        errors = addErrors(checkMaxIntegerValue(cad,nom,args[7]),errors);	
      }      
    }
    if ((args.length > 8) && (args[8] != null)){
      errors = addErrors(checkMinLength(cad,nom,args[8]),errors);    
    }  	
    if ((args.length > 9) && (args[9] != null)){
      errors = addErrors(checkMaxLength(cad,nom,args[9]),errors);	
    }
    return processErrors(obj,msg,foc,errors);     
  }  
// fin de la comprobacion    
  errors = addErrors(checkUnsigned(cad,nom),errors);
  errors = addErrors(checkInString(cad,nom,cadenaNumeros + formato.getSimboloDecimal() + formato.getSeparadorMiles(),errorCaracteresNoValidos),errors);
  errors = addErrors(checkFormatDecimal(cad,nom,formato),errors);          
  if (errors.length == 0){
    var decimalPart = getDecimalPart(cad,formato);
    var numeroDecimales = decimalPart.length;
    if (numeroDecimales == 0){
      errors[errors.length] = changeMsg(errorDecimalSinDecimales,nom,null,null,null,null);
    }   
    if ((args.length > 6) && (args[6] != null)){
      errors = addErrors(checkMinIntegerValue(cad,nom,args[6],formato),errors);    
    }  	
    if ((args.length > 7) && (args[7] != null)){
      errors = addErrors(checkMaxIntegerValue(cad,nom,args[7],formato),errors);	
    }
    if ((args.length > 8) && (args[8] != null)){
      errors = addErrors(checkMinDecimalLength(cad,numeroDecimales,nom,args[8]),errors);    
    }  	
    if ((args.length > 9) && (args[9] != null)){
      errors = addErrors(checkMaxDecimalLength(cad,numeroDecimales,nom,args[9]),errors);	
    }      
  }  
  if ((args.length > 10) && (args[10] != null)){
    errors = addErrors(checkMinLength(cad,nom,args[10]),errors);    
  }  	
  if ((args.length > 11) && (args[11] != null)){
    errors = addErrors(checkMaxLength(cad,nom,args[11]),errors);	
  }    
  return processErrors(obj,msg,foc,errors);
}

function isDecimalSigno(obj,nom,obl,msg,foc,formato){	
  var args = isDecimalSigno.arguments;
  var cad = getInputString(obj);
  var errors = new Array();
  if ((obl == false) && (cad == "")){ return processErrors(obj,msg,foc,errors); }  
  if (obl != null){
    errors = addErrors(checkCompulsory(cad,nom,obl),errors);
  }  
  if (formato == null){
    formato = new Formato();
  }
  var signo = getSign(cad);  
  cad = getUnsignedPart(cad); 
// comprobacion y tratamiento de entero  
  if ( (args.length > 8) && (args[8] == 0) && (!isCharInString(cad,formato.getSimboloDecimal())) ){   
    errors = addErrors(checkInString(cad,nom,cadenaNumeros + formato.getSeparadorMiles(),errorCaracteresNoValidos),errors);
    cad = signo + cad;
    errors = addErrors(checkFormatInteger(cad,nom,formato),errors);      
    if (errors.length == 0){   
      if ((args.length > 6) && (args[6] != null)){
        errors = addErrors(checkMinIntegerValue(cad,nom,args[6]),errors);    
      }  	
      if ((args.length > 7) && (args[7] != null)){
        errors = addErrors(checkMaxIntegerValue(cad,nom,args[7]),errors);	
      }      
    }
    if ((args.length > 8) && (args[8] != null)){
      errors = addErrors(checkMinLength(cad,nom,args[8]),errors);    
    }  	
    if ((args.length > 9) && (args[9] != null)){
      errors = addErrors(checkMaxLength(cad,nom,args[9]),errors);	
    }   
    return processErrors(obj,msg,foc,errors);
  }
// fin de la comprobacion  
  errors = addErrors(checkInString(cad,nom,cadenaNumeros + formato.getSimboloDecimal() + formato.getSeparadorMiles(),errorCaracteresNoValidos),errors);
  cad = signo + cad;  
  errors = addErrors(checkFormatDecimal(cad,nom,formato),errors);          
  if (errors.length == 0){
    var decimalPart = getDecimalPart(cad,formato);
    var numeroDecimales = decimalPart.length;
    if (numeroDecimales == 0){
      errors[errors.length] = changeMsg(errorDecimalSinDecimales,nom,null,null,null,null);
    }   
    if ((args.length > 6) && (args[6] != null)){
      errors = addErrors(checkMinIntegerValue(cad,nom,args[6],formato),errors);    
    }  	
    if ((args.length > 7) && (args[7] != null)){
      errors = addErrors(checkMaxIntegerValue(cad,nom,args[7],formato),errors);	
    }
    if ((args.length > 8) && (args[8] != null)){
      errors = addErrors(checkMinDecimalLength(cad,numeroDecimales,nom,args[8]),errors);    
    }  	
    if ((args.length > 9) && (args[9] != null)){
      errors = addErrors(checkMaxDecimalLength(cad,numeroDecimales,nom,args[9]),errors);	
    }      
  }  
  if ((args.length > 10) && (args[10] != null)){
    errors = addErrors(checkMinLength(cad,nom,args[10]),errors);    
  }  	
  if ((args.length > 11) && (args[11] != null)){
    errors = addErrors(checkMaxLength(cad,nom,args[11]),errors);	
  }    
  return processErrors(obj,msg,foc,errors);
}


// funciones públicas de formato establecido

function isFecha(obj,nom,obl,msg,foc,formato){
  var args = isFecha.arguments;
  var cad = getInputString(obj);
  var errors = new Array();
  if ((obl == false) && (cad == "")){ return processErrors(obj,msg,foc,errors); }  
  if (obl != null){
    errors = addErrors(checkCompulsory(cad,nom,obl),errors);
  }
  if (formato == null){
    formato = new Formato();	
  }
  errors = addErrors(checkSpaces(cad,nom,false),errors);
  errors = addErrors(checkInString(cad,nom,cadenaNumeros + formato.getSeparadorFecha(),errorCaracteresNoValidos),errors);
  errors = addErrors(checkMinLength(cad,nom,6),errors);
  errors = addErrors(checkMaxLength(cad,nom,10),errors);
  var cadDia  = "";
  var cadMes  = "";
  var cadAnyo = "";
  var check = true;
  if (errors.length == 0){    
    var totalSeparadores = countChars(cad,formato.getSeparadorFecha());
    if (totalSeparadores == 2){
      var cifras = cad.split(formato.getSeparadorFecha());
      if (cifras.length == 3){
        cadDia  = cifras[formato.getPosicionDia()];
        cadMes  = cifras[formato.getPosicionMes()];
        cadAnyo = cifras[formato.getPosicionAnyo()];
        if (!isNumerico(cadDia,null,true,false,false,false,formato.getMinLongitudDia(),formato.getMaxLongitudDia())){ check = false; }   
        if (!isNumerico(cadMes,null,true,false,false,false,formato.getMinLongitudMes(),formato.getMaxLongitudMes())){ check = false; }   
        if (!isNumerico(cadAnyo,null,true,false,false,false,formato.getMinLongitudAnyo(),formato.getMaxLongitudAnyo())){ check = false; }
        if (!check){
          errors[errors.length] = changeMsg(errorFormatoFecha,nom,null,null,null,null); 
        }
      }  
    } else {
       errors[errors.length] = changeMsg(errorFormatoFecha,nom,null,null,null,null);   
    } 
  }  
  if (errors.length == 0){
    erorrs = addErrors(checkFecha(nom,nom,nom,cadDia,cadMes,cadAnyo),errors);
  }
  if (errors.length == 0){
    if ((args.length > 6) && (args[6] != null)){
      errors = addErrors(checkMinDate(cad,nom,args[6],formato),errors);    
    }  	
    if ((args.length > 7) && (args[7] != null)){
      errors = addErrors(checkMaxDate(cad,nom,args[7],formato),errors);	
    }       
  }
  return processErrors(obj,msg,foc,errors);
}

function isFechaMult(objDia,objMes,objAnyo,nomDia,nomMes,nomAnyo,nom,obl,msg,foc,formato){
  var args = isFechaMult.arguments;
  var errors = new Array();
  var cadDia  = getInputString(objDia);
  var cadMes  = getInputString(objMes);
  var cadAnyo = getInputString(objAnyo);	  
  if (obl == false){
    if ((cadDia == "") && (cadMes == "") && (cadAnyo == "")){
      return processErrors(objDia,msg,foc,errors);
    }
  }
  if (formato == null){
    formato = new Formato();
  }
  errors = addErrors(isNumerico(cadDia,nomDia,true,null,false,false,formato.getMinLongitudDia(),formato.getMaxLongitudDia()),errors);
  errors = addErrors(isNumerico(cadMes,nomMes,true,null,false,false,formato.getMinLongitudMes(),formato.getMaxLongitudMes()),errors);
  errors = addErrors(isNumerico(cadAnyo,nomAnyo,true,null,false,false,formato.getMinLongitudAnyo(),formato.getMaxLongitudAnyo()),errors);  
  if (errors.length == 0){
    erorrs = addErrors(checkFecha(nomDia,nomMes,nomAnyo,cadDia,cadMes,cadAnyo),errors);
  }
  if (errors.length == 0){
    var cadFecha = "";
    var cifra0 = "";
    var cifra1 = "";
    var cifra2 = "";
    if (formato.getPosicionDia() == 0){
      cifra0 = cadDia;
    } else if (formato.getPosicionDia() == 1){
      cifra1 = cadDia;   
    } else if (formato.getPosicionDia() == 2){
      cifra2 = cadDia;
    }
    if (formato.getPosicionMes() == 0){
      cifra0 = cadMes;
    } else if (formato.getPosicionMes() == 1){
      cifra1 = cadMes;   
    } else if (formato.getPosicionMes() == 2){
      cifra2 = cadMes;
    }    
    if (formato.getPosicionAnyo() == 0){
      cifra0 = cadAnyo;
    } else if (formato.getPosicionAnyo() == 1){
      cifra1 = cadAnyo;   
    } else if (formato.getPosicionAnyo() == 2){
      cifra2 = cadAnyo;
    }    
    cadFecha = cifra0 + formato.getSeparadorFecha() + cifra1 + formato.getSeparadorFecha() + cifra2;    
    if ((args.length > 11) && (args[11] != null)){
      errors = addErrors(checkMinDate(cadFecha,nom,args[11],formato),errors);    
    }  	
    if ((args.length > 12) && (args[12] != null)){
      errors = addErrors(checkMaxDate(cadFecha,nom,args[12],formato),errors);	
    }       
  }  
  return processErrors(objDia,msg,foc,errors);
}

function isEmail(obj,nom,obl,msg,foc){
  var args = isEmail.arguments;	
  var cad = getInputString(obj);	
  var errors = new Array();
  if ((obl == false) && (cad == "")){ return processErrors(obj,msg,foc,errors); }  
  if (obl != null){
    errors = addErrors(checkCompulsory(cad,nom,obl),errors);
  } 
  errors = addErrors(checkSpaces(cad,nom,false),errors);
  errors = addErrors(checkInString(cad,nom,cadenaEmail,errorCaracteresNoValidos),errors);  
  var totalArrobas = countChars(cad,'@');
  if (totalArrobas > 1){
    errors[errors.length] = changeMsg(errorMasDeUnaArroba,nom,null,null,null,null);
  }
  if (totalArrobas == 0){
    errors[errors.length] = changeMsg(errorNoHayArroba,nom,null,null,null,null);
  }
  if (errors.length == 0){
    var cuenta   = cad.substring(0,cad.indexOf('@'));
    var dominio  = cad.substring(cad.indexOf('@')+1,cad.length);
    var posPunto = dominio.lastIndexOf('.');
    if (cuenta.length < 1){
      errors[errors.length] = changeMsg(errorLongitudIncorrectaCuenta,nom,null,null,null,null);
    }
    if (dominio.length < 4){
      errors[errors.length] = changeMsg(errorLongitudIncorrectaDominio,nom,null,null,null,null);
    }            
    if (posPunto == -1){
      errors[errors.length] = changeMsg(errorNoPuntoEnDominio,nom,null,null,null,null)
    }     
// comprobacion de posible IP en dominio
    if (errors.length == 0){
      if ((isNumerico(removeChars(dominio,'.'),null,true,false,false,false)) && (!isIP(dominio,null,null,false,false))){
        errors[errors.length] = changeMsg(errorPosibleIPDominioIncorrecta,nom,null,null,null,null);
      }
    }    
// comprobacion de dominio    
    if ((errors.length == 0) && (!isIP(dominio,null,null,false,false))){
      var caracteresAntesPunto   = dominio.substring(0,posPunto);
      var caracteresDespuesPunto = dominio.substring(posPunto+1,dominio.length);      
      var check = true;
      if (caracteresAntesPunto.length < 1){
      	check = false;    	
      }           
      if ((caracteresDespuesPunto.length < 2) || (caracteresDespuesPunto.length > 4)){
      	check = false;
      }            	      
      if (!isInString(caracteresAntesPunto,cadenaNumeros + cadenaAlfabetoASCII +"-.")){
      	check = false;
      }     	      
      if (!isInString(caracteresDespuesPunto,cadenaAlfabetoASCII)){
      	check = false;
      }      	      
      if (!check){
        errors[errors.length] = changeMsg(errorValidacionDominio,nom,null,null,null,null);
      }
    }
  }     
  if ((args.length > 5) && (args[5] != null)){
    errors = addErrors(checkMinLength(cad,nom,args[5]),errors);    
  }  	
  if ((args.length > 6) && (args[6] != null)){
    errors = addErrors(checkMaxLength(cad,nom,args[6]),errors);	
  }    
  return processErrors(obj,msg,foc,errors);  	  	
}

function isIP(obj,nom,obl,msg,foc){
  var args = isIP.arguments;	
  var cad = getInputString(obj);	
  var errors = new Array();
  if ((obl == false) && (cad == "")){ return processErrors(obj,msg,foc,errors); }  
  if (obl != null){
    errors = addErrors(checkCompulsory(cad,nom,obl),errors);
  } 
  errors = addErrors(checkSpaces(cad,nom,false),errors);
  errors = addErrors(checkInString(cad,nom,cadenaNumeros + ".",errorCaracteresNoValidos),errors);
  errors = addErrors(checkMinLength(cad,nom,7),errors);  
  errors = addErrors(checkMaxLength(cad,nom,15),errors);
  if ((errors.length == 0) && (countChars(cad,'.') == 3)){
    var numeros = cad.split('.');
    if (numeros.length == 4){
      for(n=0; n<numeros.length; n++){
        var valor = parseInt(numeros[n],10);
        if ((valor < 0) || (valor > 255)){
          errors[errors.length] = changeMsg(errorRangoIP,nom,null,null,null,null);
          break;
        }	
      }
    } else {
      errors[errors.length] = changeMsg(errorValidacionIP,nom,null,null,null,null);
    }  
  } else {
    errors[errors.length] = changeMsg(errorFormatoIP,nom,null,null,null,null);
  }
  return processErrors(obj,msg,foc,errors);
}

function isIPMult(num1,num2,num3,num4,nomNum1,nomNum2,nomNum3,nomNum4,nomIP,obl,msg,foc){
  var errors = new Array();
  var cadNum1 = getInputString(num1);
  var cadNum2 = getInputString(num2);
  var cadNum3 = getInputString(num3);
  var cadNum4 = getInputString(num4);      
  if (obl == false){
    if ((cadNum1 == "") && (cadNum2 == "") && (cadNum3 == "") && (cadNum4 == "")){
      return processErrors(num1,msg,foc,errors);
    }
  }   
  errors = addErrors(isEntero(cadNum1,nomNum1,true,null,false,null,0,255,1,3),errors);
  errors = addErrors(isEntero(cadNum2,nomNum2,true,null,false,null,0,255,1,3),errors);
  errors = addErrors(isEntero(cadNum3,nomNum3,true,null,false,null,0,255,1,3),errors);
  errors = addErrors(isEntero(cadNum4,nomNum4,true,null,false,null,0,255,1,3),errors);
  return processErrors(num1,msg,foc,errors);
}

function isNIF(obj,nom,obl,msg,foc){
  var args = isNIF.arguments;	
  var cad = getInputString(obj);	
  var errors = new Array();
  if ((obl == false) && (cad == "")){ return processErrors(obj,msg,foc,errors); }  
  if (obl != null){
    errors = addErrors(checkCompulsory(cad,nom,obl),errors);
  }
  errors = addErrors(checkSpaces(cad,nom,false),errors); 
  errors = addErrors(checkMinLength(cad,nom,2),errors); 
  
  if ((cad.substring(0,1).toUpperCase() == 'X') || (cad.substring(0,1).toUpperCase() == 'Y') || (cad.substring(0,1).toUpperCase() == 'Z')) {  
	  errors = addErrors(checkMaxLength(cad,nom,10),errors);	}
  else {  errors = addErrors(checkMaxLength(cad,nom,9),errors); }
  
  if (errors.length == 0){
    var check = true;
	if (cad.substring(0,1).toUpperCase() == 'X') {
	    var numero = cad.substring(1,cad.length-1);}
	else if (cad.substring(0,1).toUpperCase() == 'Y') {
	    var numero = '1'+ cad.substring(1,cad.length-1);}
	else if (cad.substring(0,1).toUpperCase() == 'Z') {
	    var numero = '2'+ cad.substring(1,cad.length-1);}
	else {
	    var numero = cad.substring(0,cad.length-1); }
   	var letra = cad.substring(cad.length-1,cad.length);
    errors = addErrors(checkInString(numero,nom,cadenaNumeros,errorSoloNumerosNIF),errors);
    errors = addErrors(checkInString(letra,nom,cadenaAlfabetoASCII,errorSoloLetrasNIF),errors);
    if (parseInt(numero,10) == 0){
      check = false;
    }
    var index = parseInt(numero,10) % 23;
    var letrasNIF = 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');  
    if (letra.toUpperCase() != letrasNIF[index]){
      check = false;
    }
    if (!check){
      errors[errors.length] = changeMsg(errorValidacionNIF,nom,null,null,null,null);
    }  
  }
  return processErrors(obj,msg,foc,errors);  	  	
}

function isCIF(obj,nom,obl,msg,foc){
  var args = isCIF.arguments;	
  var cad = getInputString(obj);	
  var errors = new Array();
  
  //******Agregado Romeo ***********/
  var patron = new RegExp("^[ABCDEFGHJNPQRSUVW]{1}");
  
  if ( cad.search(patron) == -1 ) { 
  	return  false;
  }
  //******Agregado Romeo ***********/

  
  if ((obl == false) && (cad == "")){ return processErrors(obj,msg,foc,errors); }  
  if (obl != null){
    errors = addErrors(checkCompulsory(cad,nom,obl),errors);
  }
  errors = addErrors(checkSpaces(cad,nom,false),errors); 
  errors = addErrors(checkMinLength(cad,nom,9),errors);  	
  errors = addErrors(checkMaxLength(cad,nom,9),errors);	
  errors = addErrors(checkInString(cad,nom,cadenaNumeros + cadenaAlfabetoASCII,errorCaracteresNoAdmitidosCIF),errors);
  if (errors.length == 0){
	  
    var check = false;
    cad = cad.toUpperCase();	
	
	// sacado de http://www.q3.nu/trucomania/truco.cgi?337&ing  	
    var letrasCIF = new Array('J','A','B','C','D','E','F','G','H','I'); 
    var sumap = 0;
    var sumai = 0;
    var p;
    var r;
    var dc;        
    sumap = parseInt(cad.substring(2,3)) + parseInt(cad.substring(4,5)) + parseInt(cad.substring(6,7));
    for(n=1; n<=8; n++){
      p = 2 * parseInt(cad.substring(n,n+1));
      if (p > 9) {
        sumai += parseInt((p / 10),10) + (p % 10);
      } else {
        sumai += p;
      }
      n ++;
    }
    r = sumap + sumai; // r es el resultado de las sumas de los productos
    dc = r % 10;       // calculamos el digito de control que es el modulo de la suma de los productos
    dc = 10 - dc;      // complemento a 10 del digito de control
    if (dc == 10) {    // si el digito de control es 10 se le asigna el 0
      dc = 0;
    }
    if ( !isDigit(cad.charAt(8)) ){
      if (letrasCIF[dc] == cad.charAt(8).toUpperCase()){
        check = true;
      }	    	   
    } else {
      if (dc == parseInt(cad.substring(8,9))){
        check = true;
      } 
    }
	
    if (!check){
      errors[errors.length] = changeMsg(errorValidacionCIF,nom,null,null,null,null);
    }   
  }
  return processErrors(obj,msg,foc,errors);
}

function isCodigoPostal(obj,nom,obl,msg,foc){
  var args = isCodigoPostal.arguments;
  var cad = getInputString(obj);
  var errors = new Array();
  if ((obl == false) && (cad == "")){ return processErrors(obj,msg,foc,errors); } 
  errors = addErrors(isNumerico(cad,nom,true,null,false,false,5,5),errors);
  if (errors.length == 0){
    var check = true;
    var codigoProvincia = parseInt(cad.substring(0,2),10);
    if ((codigoProvincia < 1) || (codigoProvincia > 52)){
      check = false;
    }
    if (cad.substring(2,5) == "000"){
      check = false;
    }
    if (!check){
      errors[errors.length] = changeMsg(errorValidacionCodigoPostal,nom,null,null,null,null);
    }
  }
  return processErrors(obj,msg,foc,errors);  	
}

function isCuentaBancaria(obj,nom,obl,msg,foc){
  var errors = new Array();
  var cad = getInputString(obj);
  if ((obl == false) && (cad == "")){ return processErrors(obj,msg,foc,errors); }  
  if (obl != null){
    errors = addErrors(checkCompulsory(cad,nom,obl),errors);
  } 
  errors = addErrors(isNumerico(cad,nom,true,null,false,false,20,20),errors);
  if (errors.length == 0){
    var check = true;
    var cadBanco    = cad.substring(0,4);
    var cadSucursal = cad.substring(4,8);
    var cadDigitos  = cad.substring(8,10);
    var cadCuenta   = cad.substring(10,20);
    if ((cadBanco == "0000") || (cadCuenta == "0000000000")){
      check = false;
    } 
    var digit1 = calculateControlDigit("00" + cadBanco + cadSucursal);
    var digit2 = calculateControlDigit(cadCuenta);
    var digitosCalculados = new String(digit1) + new String(digit2);
    if (digitosCalculados != cadDigitos){
      check = false;
    }
    if (!check){
      errors[errors.length] = changeMsg(errorValidacionCuentaBancaria,nom,null,null,null,null);
    }
  }
  return processErrors(obj,msg,foc,errors); 
}

function isCuentaBancariaMult(banco,sucursal,digitos,cuenta,nomBanco,nomSucursal,nomDigitos,nomCuenta,nomCuentaBancaria,obl,msg,foc){
  var errors = new Array();
  var cadBanco    = getInputString(banco);
  var cadSucursal = getInputString(sucursal);
  var cadDigitos  = getInputString(digitos);
  var cadCuenta   = getInputString(cuenta);      
  if (obl == false){
    if ((cadBanco == "") && (cadSucursal == "") && (cadDigitos == "") && (cadCuenta == "")){
      return processErrors(banco,msg,foc,errors);
    }
  }
  errors = addErrors(isNumerico(cadBanco,nomBanco,true,null,false,false,4,4),errors);
  errors = addErrors(isNumerico(cadSucursal,nomSucursal,true,null,false,false,4,4),errors);
  errors = addErrors(isNumerico(cadDigitos,nomDigitos,true,null,false,false,2,2),errors);
  errors = addErrors(isNumerico(cadCuenta,nomCuenta,true,null,false,false,10,10),errors);
  if (errors.length == 0){
    var check = true;
    if ((cadBanco == "0000") || (cadCuenta == "0000000000")){
      check = false;
    } 
    var digit1 = calculateControlDigit("00" + cadBanco + cadSucursal);
    var digit2 = calculateControlDigit(cadCuenta);
    var digitosCalculados = new String(digit1) + new String(digit2);
    if (digitosCalculados != cadDigitos){
      check = false;
    }
    if (!check){
      errors[errors.length] = changeMsg(errorValidacionCuentaBancariaMult,nomCuentaBancaria,null,null,null,null);
    }             
  }
  return processErrors(banco,msg,foc,errors);    	
}

function isHoraValida(obj,nom,obl,msg,foc){
  var args = isHoraValida.arguments;
  var cad = getInputString(obj);
  var errors = new Array();
  if ((obl == false) && (cad == "")){ return processErrors(obj,msg,foc,errors); } 
  
   var patron = new RegExp("^([0-1][0-9]|2[0-3]):[0-5][0-9]$");
  
  if (cad.search(patron) == -1 ) { 
	errors[errors.length] = changeMsg('El campo NOMBRE_CAMPO no contiene un formato valido hh:mm',nom,null,null,null,null);
  	return processErrors(obj,msg,foc,errors);
  }
  
  return processErrors(obj,msg,foc,errors);  	
}


function CompararHoras(sHora1, sHora2) { 
     
    var arHora1 = sHora1.split(":",2); 
    var arHora2 = sHora2.split(":",2); 
     
	var hh1 = parseInt(arHora1[0],10)
	var mm1 = parseInt(arHora1[1],10)
	var hh2 = parseInt(arHora2[0],10)
	var mm2 = parseInt(arHora2[1],10)

    // Comparar 
    if (hh1<hh2 || (hh1==hh2 && mm1<mm2)) 
       //return "sHora1 MENOR sHora2"; 
		return -1
    else if (hh1>hh2 || (hh1==hh2 && mm1>mm2)) 
        //return "sHora1 MAYOR sHora2"; 
		return 1
    else  
        //return "sHora1 IGUAL sHora2"; 
		return 0
} 

// Funcion para redondear un numero al numero de decimales pasado como segundo parametro
function redondea(fixNumber, decimalPlaces)
{
 var xxx = Math.pow(10,decimalPlaces);
  fixNumber = Math.round(fixNumber * xxx) / xxx;
 return fixNumber;
}
	


// funciones privadas agrupadas por comodidad

function checkCommonText(cad,nom,obl,spa,cadComparar,cadError,min,max,args){
  var errors = new Array()
  if (obl != null){
    errors = addErrors(checkCompulsory(cad,nom,obl),errors);
  } 
  if (spa != null){
    errors = addErrors(checkSpaces(cad,nom,spa),errors);
  }
  if ((cadComparar != null) && (cadError != null)){
    errors = addErrors(checkInString(cad,nom,cadComparar,cadError),errors);
  }
  if ((args.length > min) && (args[min] != null)){
    errors = addErrors(checkMinLength(cad,nom,args[min]),errors);    
  }  	
  if ((args.length > max) && (args[max] != null)){
    errors = addErrors(checkMaxLength(cad,nom,args[max]),errors);	
  }  
  return errors;
}


// funciones privadas de tratamiento de cadenas (pueden reaprovecharse)

function reverseString(cad){
  var cadReversed = "";
  for(n=cad.length; n>=0; n--){
    cadReversed += cad.charAt(n);
  }
  return cadReversed;
}

function countChars(cad,car){
  var cont = 0;
  for (n=0; n<cad.length; n++){
    if (cad.charAt(n) == car){
      cont ++;
    }
  }
  return cont;	
}

function removeChars(cad,car){
  var cadCleaned = "";
  for (n=0; n<cad.length; n++){
    if(cad.charAt(n) != car){
      cadCleaned += cad.charAt(n);
    }
  }
  return cadCleaned;
}


// funciones privadas de funcionamiento interno

function addErrors(errorsArr,errorsTotalArr){
  for (n=0; n<errorsArr.length; n++){
    errorsTotalArr[errorsTotalArr.length] = errorsArr[n];	
  }
  return errorsTotalArr;
}

function getInputString(obj){
  var cad = ""
  if (obj.value){
    cad = obj.value;
  } else {
    if (obj.value == "" ){ 
      cad = obj.value
    } else {
      cad = obj;
    }	
  }
  return cad;
}

function changeMsg(descError,nom,longitud,longitudCorrecta,valor,valorCorrecto){  
  var cad = descError.replace(/NOMBRE_CAMPO/g, nom);
  if (longitud != null){
    cad = cad.replace(/LONGITUD_CAMPO/g,longitud)
  }
  if (longitudCorrecta != null){  	
    cad = cad.replace(/LONGITUD_CORRECTA/g,longitudCorrecta)
  }  
  if (valor != null){
    cad = cad.replace(/VALOR_CAMPO/g,valor)
  }  
  if (valorCorrecto != null){
    cad = cad.replace(/VALOR_CORRECTO/g,valorCorrecto)
  }    
  return cad;  	
}

function processErrors(obj,msg,foc,errors){
  var cad = "";	
  if (errors.length > 0){
    for (n=0; n<errors.length; n++){
      cad += errors[n];
      if (n != errors.length -1){
        cad += "\n";
      }
    }
    if (msg == true){ alert(cad); }	
    if ((foc == true) && (obj != null)){ obj.focus(); } 
    if (msg == null){ return errors; }   
    return false;  
  }
  if (msg == null){ return errors; }	     	
  return true;
}


// funciones privadas de tratamiento numérico 

function getIntegerValue(cad){	
  var cadenaCleaned = "";
  var cadenaOriginal = new String(cad);
  var cadena = getUnsignedPart(cadenaOriginal);
  var signo = getSign(cadenaOriginal);  
  for (n=0; n<cadena.length; n++){
    if (isDigit(cadena.charAt(n))){
      cadenaCleaned += cadena.charAt(n);
    }
  }
  return parseInt(signo + cadenaCleaned,10);
}

function getDecimalValue(cad,formato){
  var cadenaOriginal = new String(cad);
  if (cadenaOriginal.lastIndexOf(formato.getSimboloDecimal()) == -1) {
    cadenaOriginal = cadenaOriginal + formato.getSimboloDecimal() + "00";
  }	
  var integerPart = getIntegerPart(cadenaOriginal,formato);
  var decimalPart = getDecimalPart(cadenaOriginal,formato); 
  var cadena = getIntegerValue(integerPart) +"."+ decimalPart;
  return parseFloat(cadena,10);   
} 

function getIntegerPart(cad,formato){
  var posicionDecimal = cad.lastIndexOf(formato.getSimboloDecimal());
  return cad.substring(0,posicionDecimal);
}

function getDecimalPart(cad,formato){
  var posicionDecimal = cad.lastIndexOf(formato.getSimboloDecimal());
  return cad.substring(posicionDecimal+1,cad.length);
}

function getSign(cad){
  if ((cad.charAt(0) == "+") || (cad.charAt(0) == "-")){
    return cad.charAt(0); 
  }
  return ""; 
}

function getUnsignedPart(cad){
  if ((cad.charAt(0) == "+") || (cad.charAt(0) == "-")){ 	
    return cad.substring(1,cad.length);
  }
  return cad;
}


// funciones privadas de tratamiento de fechas

function getDateValue(cad,formato){
  var cifras  = cad.split(formato.getSeparadorFecha());
  var cadDia  = cifras[formato.getPosicionDia()];
  var cadMes  = cifras[formato.getPosicionMes()];
  var cadAnyo = cifras[formato.getPosicionAnyo()];
  var dia = parseInt(cadDia,10);
  var mes = parseInt(cadMes,10);
  var anyo = parseInt(cadAnyo,10);
  mes = mes - 1;
  if (anyo < 100){
    anyo = anyo + 1900;
  }  
  return new Date(anyo,mes,dia);  
}


// funciones privadas de comprobación

function checkCompulsory(cad,nom,obl){	
  var errors = new Array()
  if ((obl == true) && (cad == "")){
    errors[errors.length] = changeMsg(errorCampoObligatorioVacio,nom,null,null,null,null);
  }
  return errors;	
}

function checkSpaces(cad,nom,spa){
  var errors = new Array();
  if (spa == false){
    for(n=0; n<cad.length; n++){
      if(cad.charAt(n) == " "){
        errors[errors.length] = changeMsg(errorNoAdmiteEspacios,nom,null,null,null,null);
        break;
      }
    }
  }
  return errors;	
}

function checkMinLength(cad,nom,min){
  var errors = new Array();
  if (cad.length < min){
    errors[errors.length] = changeMsg(errorNoAlcanzaLongitudMinima,nom,cad.length,min,null,null);      
  }
  return errors;	
}

function checkMaxLength(cad,nom,max){
  var errors = new Array();
  if (cad.length > max){
    errors[errors.length] = changeMsg(errorExcedeLongitudMaxima,nom,cad.length,max,null,null);      
  }
  return errors;	
}

function checkMinDecimalLength(cad,numDecs,nom,min){
  var errors = new Array();
  if (numDecs < min){
    errors[errors.length] = changeMsg(errorNoAlcanzaDecimalesMinimos,nom,numDecs,min,null,null);      
  }
  return errors;	
}

function checkMaxDecimalLength(cad,numDecs,nom,max){
  var errors = new Array();
  if (numDecs > max){
    errors[errors.length] = changeMsg(errorExcedeDecimalesMaximos,nom,numDecs,max,null,null);      
  }
  return errors;
}

function checkMinIntegerValue(val,nom,min){
  var errors = new Array();
  if (getIntegerValue(val) < getIntegerValue(min)){
    errors[errors.length] = changeMsg(errorNoAlcanzaValorMinimo,nom,null,null,val,min);      
  }
  return errors;	
}

function checkMaxIntegerValue(val,nom,max){
  var errors = new Array();	
  if (getIntegerValue(val) > getIntegerValue(max)){
    errors[errors.length] = changeMsg(errorExcedeValorMaximo,nom,null,null,val,max);      
  }
  return errors;	
}

function checkMinDecimalValue(val,nom,min,formato){
  var errors = new Array();
  if (getDecimalValue(val,formato) < getDecimalValue(min,formato)){
    errors[errors.length] = changeMsg(errorNoAlcanzaValorMinimo,nom,null,null,val,min);      
  }
  return errors;	
}

function checkMaxDecimalValue(val,nom,max,formato){
  var errors = new Array();	
  if (getDecimalValue(val,formato) > getDecimalValue(max,formato)){
    errors[errors.length] = changeMsg(errorExcedeValorMaximo,nom,null,null,val,max);      
  }
  return errors;	
}

function checkMinDate(val,nom,min,formato){
  var errors = new Array();
  if ( getDateValue(val,formato).getTime() < getDateValue(min,formato).getTime() ){
    errors[errors.length] = changeMsg(errorNoAlcanzaFechaMinima,nom,null,null,val,min);
  }
  return errors;
}

function checkMaxDate(val,nom,max,formato){
  var errors = new Array();
  if ( getDateValue(val,formato).getTime() > getDateValue(max,formato).getTime() ){
    errors[errors.length] = changeMsg(errorExcedeFechaMaxima,nom,null,null,val,max);
  }
  return errors;
}

function checkUnsigned(cad,nom){	
  var errors = new Array();
  if (getSign(cad) != ""){
    errors[errors.length] = changeMsg(errorSignoEnUnsigned,nom,null,null,null,null)
  }
  return errors;
}  

function checkInString(cad,nom,cadComparar,cadError){
  var errors = new Array();
  var check = true;
  for(n=0; n<cad.length; n++){
    for(m=0; m<cadComparar.length; m++){
      if(cad.charAt(n) == cadComparar.charAt(m)){
      	break;
      }  
    }
    if (m == cadComparar.length){ 
      check = false;
      break;
    }
  }
  if (!check){
    errors[errors.length] = changeMsg(cadError,nom,null,null,null,null);
  }  
  return errors;	
}

function checkNotInString(cad,nom,cadComparar,cadError){
  var errors = new Array();
  var check = true;	
  for(n=0; n<cad.length; n++){
    for(m=0; m<cadComparar.length; m++){
      if(cad.charAt(n) == cadComparar.charAt(m)){
        errors[errors.length] = changeMsg(cadError,nom,null,null,null,null);
        return errors;
      }
    }
  }
  return errors;	
}

function checkFormatInteger(cad,nom,formato){
  var errors = new Array();
  if ((formato == null) || (formato.getSeparadorMiles() == null)){ return errors; }	
  cad = getUnsignedPart(cad);
  cad = formato.getSeparadorMiles() + reverseString(cad);  
  var cont = 1;
  for(n=1; n<cad.length; n++){
    if (cont == 4){	
      if (cad.charAt(n) != formato.getSeparadorMiles()){
        errors[errors.length] = changeMsg(errorFormatoIncorrectoEnteros,nom,null,null,null,null);
        break;
      }
      if ((n == cad.length-1) && (!isDigit(cad.charAt(n)))){
        errors[errors.length] = changeMsg(errorFormatoIncorrectoEnteros,nom,null,null,null,null);
        break;        
      }
      cont = 0;
    } else {
      if (!isDigit(cad.charAt(n))){
        errors[errors.length] = changeMsg(errorFormatoIncorrectoEnteros,nom,null,null,null,null);
        break;
      }    
    }   
    cont ++;
  }
  return errors;
}

function checkFormatDecimal(cad,nom,formato){
  var errors = new Array();
  if ((formato == null) || (formato.getSimboloDecimal() == null)){ return errors; }
  if (cad.lastIndexOf(formato.getSimboloDecimal()) == -1){
    errors[errors.length] = changeMsg(errorDecimalSinSimbolo,nom,null,null,null,null);
    return errors;
  }
  var integerPart = getIntegerPart(cad,formato);
  var decimalPart = getDecimalPart(cad,formato);
  if (formato.getSeparadorMiles() != null){
    integerPart = getUnsignedPart(integerPart);
    integerPart = formato.getSeparadorMiles() + reverseString(integerPart);    
    var cont = 1;
    for(n=1; n<integerPart.length; n++){
      if (cont == 4){	
        if (integerPart.charAt(n) != formato.getSeparadorMiles()){      	
          errors[errors.length] = changeMsg(errorFormatoIncorrectoDecimales,nom,null,null,null,null);
          break;
        }
        if ((n == integerPart.length - 1) && (!isDigit(integerPart.charAt(n)))){     	
          errors[errors.length] = changeMsg(errorFormatoIncorrectoDecimales,nom,null,null,null,null);
          break;        
        }
        cont = 0;
      } else {    	
        if (!isDigit(integerPart.charAt(n))){
          errors[errors.length] = changeMsg(errorFormatoIncorrectoDecimales,nom,null,null,null,null);
          break;
        }    
      }   
      cont ++;
    }
  }  
  errors = addErrors(checkInString(decimalPart,nom,cadenaNumeros,errorSoloNumerosEnParteDecimal),errors);  
  return errors;  
}

function checkFecha(nomDia,nomMes,nomAnyo,cadDia,cadMes,cadAnyo){
  var errors = new Array();
  var dia  = parseInt(cadDia,10);
  var mes  = parseInt(cadMes,10);
  var anyo = parseInt(cadAnyo,10);
  if (dia < 1){
    errors[errors.length] = changeMsg(errorDiaNoAlcanzaValorMinimo,nomDia,null,null,cadDia,"1");
  }
  if (dia > 31){
    errors[errors.length] = changeMsg(errorDiaExcedeValorMaximo,nomDia,null,null,cadDia,"31");
  }
  if (mes < 1){
    errors[errors.length] = changeMsg(errorMesExcedeValorMaximo,nomMes,null,null,cadMes,"1");
  }
  if (mes > 12){
    errors[errors.length] = changeMsg(errorMesExcedeValorMaximo,nomMes,null,null,cadMes,"12");
  }
  if (errors.length == 0){
    if ( ((mes==4) || (mes==6) || (mes==9) || (mes==11)) && (dia==31) ) {
      errors[errors.length] = changeMsg(errorNumeroDiasIncorrecto,nomDia,null,null,cadDia,"30");
    }
    if (mes == 2){
      var isBisiesto = ( (anyo % 4 == 0) && ((anyo % 100 != 0) || (anyo % 400 == 0)) );
      var maxDiasFebrero = isBisiesto? 29 : 28;
      if (dia > maxDiasFebrero) {
	errors[errors.length] = changeMsg(errorNumeroDiasIncorrecto,nomDia,null,null,cadDia,maxDiasFebrero);
      }
    }
  }
  return errors;  
}


// funciones privadas de comprobación interna (devuelven true/false)

function isInString(cad,cadComparar){
  var check = true;
  for(n=0; n<cad.length; n++){
    for(m=0; m<cadComparar.length; m++){
      if(cad.charAt(n) == cadComparar.charAt(m)){
      	break;
      }  
    }
    if (m == cadComparar.length){ 
      check = false;
      break;
    }
  }  
  return check;	
}

function isCharInString(cad,char){
  for(n=0; n<cad.length; n++){
    if(cad.charAt(n) == char){
      return true;
    }
  }
  return false;	
}

function isDigit(car){
  return ((car >= "0") && (car <= "9"));
}


// funciones privadas de cálculo

function calculateControlDigit(num){
  var numero = new Array();
  var multiplicador = new Array(1,2,4,8,5,10,9,7,3,6);
  var total = 0;
  for (n=0; n<num.length; n++){
    numero[n] = num.charAt(n);
  }
  for (n=0; n<numero.length; n++) {
    total += parseInt(numero[n],10) * multiplicador[n];
  }
  var digit = 11 - (total % 11);  
  if (digit == 11) { return 0; }
  if (digit == 10) { return 1; }
  return digit;    	
}


// valida el rango entre 2 fechas, en formato dd/mm/yyyy 
// devuelve true si fec0 es mayor o igual que fec1
function fechaMayorOIgualQue(fec0, fec1){
    var bRes = false;
    var sDia0 = fec0.value.substr(0, 2);
    var sMes0 = fec0.value.substr(3, 2);
    var sAno0 = fec0.value.substr(6, 4);
    var sDia1 = fec1.value.substr(0, 2);
    var sMes1 = fec1.value.substr(3, 2);
    var sAno1 = fec1.value.substr(6, 4);
    if (sAno0 > sAno1) bRes = true;
    else {
     if (sAno0 == sAno1){
      if (sMes0 > sMes1) bRes = true;
      else {
       if (sMes0 == sMes1)
        if (sDia0 >= sDia1) bRes = true;
      }
     }
    }
    return bRes;
   }





// AutPrestFunciones.js contiene un conjunto de funciones que serán utilizadas
// por los validadores correspondientes


//------------------------------------------------------------------------------------------------
//Función que devuelve 'true' si una tupla (mes,anno) es igual que el actual.
//------------------------------------------------------------------------------------------------
function igualMesAnnoActual(mes,anno)
{
	var fechaActual = new Date();
	var mesActual = fechaActual.getMonth()+1 ;
	var annoActual = fechaActual.getFullYear();

	return ((anno==annoActual)&&(mes==mesActual));
}

//------------------------------------------------------------------------------------------------
//Función que devuelve 'true' si una tupla (mes,anno) es mayor que el actual.
//------------------------------------------------------------------------------------------------
function mayorMesAnnoActual(mes,anno)
{
	var fechaActual = new Date();
	var mesActual = fechaActual.getMonth()+1 ;
	var annoActual = fechaActual.getFullYear();

	if (anno>annoActual)
		return true;
	else if (anno<annoActual)	
		return false;
	else if (anno==annoActual)	
	{
		if (mes>mesActual)
			return true;
		else if (mes<=mesActual)
			return false;	
	}
}

//------------------------------------------------------------------------------------------------
//Función que devuelve 'true' si una tupla (mes,anno) es mayor que otra tupla (mes,anno).
//------------------------------------------------------------------------------------------------
function mesAnnoMayorMesAnno(mes1,anno1,mes2,anno2)
{
	if (anno1>anno2)
		return true;
	else if (anno1<anno2)
		return false;
	else if (anno1==anno2)		
	{
		if (parseInt(mes1)>parseInt(mes2))
			return true;
		else if (parseInt(mes1)<=parseInt(mes2))
			return false;	
	}
}

//------------------------------------------------------------------------------------------------
//Función que devuelve la cantidad de meses entre dos tuplas (mes,anno). Incluye tb los
//meses especificados. Los meses válidos son: 1, 2, 3,...,12. No funciona p.e. con 01 o 15.
//------------------------------------------------------------------------------------------------
function cantidadMeses(mes1,anno1,mes2,anno2)
{  
	
	if (anno1==anno2)
	{
		if (mes1>mes2) return (parseInt(mes1)-parseInt(mes2)+1);
		else if (mes1<mes2) return (parseInt(mes2)-parseInt(mes1)+1);
		else if (mes1==mes2) return 0;
	}
	else if (anno1>anno2)
	{
		//(hasta diciembre del mes del año menor)
		//+ (12 meses por cada año intermedio)
		//+ (meses del año mayor)
		return ((13-parseInt(mes2))+(12*(parseInt(anno1)-parseInt(anno2)-1))+parseInt(mes1));
	}
	else if (anno1<anno2)
	{
		//(hasta diciembre del mes del año menor)
		//+ (12 meses por cada año intermedio)
		//+ (meses del año mayor)
		return ((13-parseInt(mes1))+(12*(parseInt(anno2)-parseInt(anno1)-1))+parseInt(mes2));
	}		
}


//------------------------------------------------------------------------------------------------
//Función que devuelve 'true' si la cadena pasada solo contiene espacios en blanco.
//------------------------------------------------------------------------------------------------
function hayEspacios(cadena){
	var patron = /^\s+$/;
	var cadenaEncontrada =cadena.match(patron);
	if(cadenaEncontrada != null)
		return true;
	return false;
}

//------------------------------------------------------------------------------------------------
//Función que devuelve 'true' si la cadena pasada no contiene nada.
//------------------------------------------------------------------------------------------------
function campoVacio(cadena)
  { 	
    longitud= cadena.length;
    numeroDeBlancos=0;
    
    for(var i=0;i<longitud;i++)
    {
        if(cadena.substring(i,i+1)==" ")
	    numeroDeBlancos++;
	else
	    break;
    }
    if(numeroDeBlancos==longitud)
	return true;
    else
        return false;    
  }

//------------------------------------------------------------------------------------------------
//Función que rellena con 0´s a la izquierda si es necesario. Recibe:
// cadena: el nombre de la caja de texto que contiene el campo a rellenar
// longitud: la longitud máxima de esa cadena
// Devuelve la cadena recibida con 0´s a la izquierda si es necesario
//------------------------------------------------------------------------------------------------
function rellenaCerosIzquierda(cadena,longitud){
var cero = "";
var i;	
	for (i = cadena.length ; i < longitud;i++)
	// Concateno el caracter '0'. 
	// OJO: Se está trabajando con strings
		cero+="0";

// Añado ceros a la cadena, en el caso que hiciera falta introducir alguno
cadena = cero + cadena;

return cadena;
}  

//------------------------------------------------------------------------------------------------
//Función que rellena con 0´s a la derecha si es necesario. Recibe:
// cadena: el nombre de la caja de texto que contiene el campo a rellenar
// longitud: la longitud máxima de esa cadena
// Devuelve la cadena recibida con 0´s a la derecha si es necesario
//------------------------------------------------------------------------------------------------
function rellenaCerosDerecha(cadena,longitud){
var cero = "";
var i;	
	for (i = cadena.length ; i < longitud;i++)
	// Concateno el caracter '0'. 
	// OJO: Se está trabajando con strings
		cero+="0";

// Añado ceros a la cadena, en el caso que hiciera falta introducir alguno
cadena = cadena + cero;

return cadena;
}  


//------------------------------------------------------------------------------------------------
//Función que devuelve 'true' si la cadena pasada contiene sólo números.
//------------------------------------------------------------------------------------------------
function soloNumeros(cadena){
	var patron = /^[0-9]+$/;
	var cadenaEncontrada =cadena.match(patron);
	if(cadenaEncontrada != null)
		return true;
	return false;
}
//------------------------------------------------------------------------------------------------
//Función que devuelve 'true' si la cadena pasada es un numero real.
//------------------------------------------------------------------------------------------------
function esReal(cadena){
	var patron = /^[0-9\,]+$/;
	var cadenaEncontrada =cadena.match(patron);
	var longitud= cadena.length;
	//no puede haber mas de una coma
	var numComas=0;
	for(var i=0;i<longitud;i++)
	{
	 	if (cadena.charAt(i)==',')
	 	{	 	
	 		numComas=numComas+1;
	 	}	
	} 		
	if((cadenaEncontrada != null)&&(numComas<2))
		return true; 	
	return false;
}

//------------------------------------------------------------------------------------------------
// Función que devuelve 'true' si un año es bisiesto
//------------------------------------------------------------------------------------------------
function compruebaBisiesto(Anno){
	var siglo= parseInt(Anno.substring(0,2));
    	var decada= parseInt(Anno.substring(2,4));
    	if (decada%4==0){
      		if(decada==0 && siglo%4==0)
          		return true;
      		else if (decada!=0)
          		return true;
    	}
	return false;
}

//------------------------------------------------------------------------------------------------
// Función que devuelve 'true' si una fecha es correcta
//------------------------------------------------------------------------------------------------
function testFecha(Anno,Mes,Dia){
	var hoy= new Date();
	var annoSys=hoy.getYear();
	//se hace la comprobacion siguiente porque en el IExplorer getYear devuelve el año completo
	//mientras que en el Netscape devuelve los años desde el 1900
	if(annoSys<200)
		annoSys+=1900;
	if(Mes.charAt(0) == '0')
		Mes = Mes.charAt(1);
	if(Dia.charAt(0) == '0')
		Dia = Dia.charAt(1);
	var dia= parseInt(Dia);
	var mes= parseInt(Mes);
	if( mes==2 && 0<dia && dia<=28 )
      		return true;
	else if ( mes==2 && dia==29 ){
      		if (compruebaBisiesto(Anno))
        		return true;
      		else
        		return false;
	}  	
	else if((mes==1 || mes ==3 || mes ==5 || mes ==7 || mes ==8 || mes ==10 || mes ==12)&& (0<dia) && (dia<32))
      		return true;
	else if ((mes==4 || mes ==6 || mes ==9 || mes ==11)&& (0<dia) && (dia<31))
	      	return true;
	else
        	return false;
}



//------------------------------------------------------------------------------------------------
//Función que devuelve si existe un radio de un grupo seleccionado.
// cadena: nombre del grupo
// numeroRadios: nº de radios del grupo
//------------------------------------------------------------------------------------------------
function marcadoAlgunRadio(cadena,numeroRadios)
{
  var marcadoAlguno=false;
  for (i=0;i<numeroRadios;i++)
  {
    if (eval(""+cadena+"["+i+"].checked")==true)
    {
      marcadoAlguno=true;
      break;
    }    
  }

  return marcadoAlguno;
}

//------------------------------------------------------------------------------------------------
//Función que sólo deja teclear numeros.
//------------------------------------------------------------------------------------------------
function quitaCaracteres(celda)
{
	if (celda.value && !((navigator.appName == "Netscape") && (parseInt(navigator.appVersion) == 4)))
	{
		var estado = false;
		var cadenaNumero = celda.value;
		var alphaCheck = " abcdefghijklmnñopqrstuvwxyzABCDEFGHIJKLMNÑOPQRSTUVWXYZ-";
		alphaCheck = alphaCheck + "ºª\\!\"·$%&()=?¿¡'|@#¬/";
		alphaCheck = alphaCheck + "`^[*+]¨´{Ç}<>,.-_:;";
		alphaCheck = alphaCheck + "áéíóúÁÉÍÓÚäëïöüÄËÏÖÜàèìòùÀÈÌÒÙâêîôûÂÊÎÔÛ";
	
		for (i=0; i<cadenaNumero.length; i++)
		{
			if (alphaCheck.indexOf(cadenaNumero.charAt(i)) != -1)
			{
				cadenaNumero = cadenaNumero.substring(0,i) + cadenaNumero.substring(i+1);
				estado = true;
			}
		}
		if (estado)
			celda.value=cadenaNumero;
	}
}

//------------------------------------------------------------------------------------------------
//Función que no deja teclear números.
//------------------------------------------------------------------------------------------------
//Función que devuelve 'true' si la cadena pasada tiene sólo letras españolas.
function soloLetras(cadena){
	//p.e: O'Donell lo de por válido. Elimino la ' de cadena y lo dejo en cadenaAux.	

	
	var patron = /^[a-zA-Z\á\é\í\ó\ú\Á\É\Í\Ó\Ú\Ü\ü\Ñ\ñ\''\º\ª\-\+\_\,\Ç\s\.\/]+$/;
	var cadenaEncontrada = cadena.match(patron);
	if(cadenaEncontrada != null)
		return true;		
	return false;
}
//------------------------------------------------------------------------------------------------
//Función que compueba email
//------------------------------------------------------------------------------------------------

function tiene(cadena)
{
	for (i=0; i<cadena.length; i++)
	{
		if (cadena.charAt(i)=='@'){
			return true;
			}
	}	
	return false	
}

function validaEmail(cadena)
{
	var patron=/^[A-Za-z][A-Za-z0-9_.-]*@[A-Za-z0-9_.-]+\.[A-Za-z0-9_.-]+[A-za-z]$/;
	

	var cadenaEncontrada = cadena.match(patron);
	if(cadenaEncontrada != null)
		return true;		
	return false;
}

//------------------------------------------------------------------------------------------------
//Función que devuelve true si la fecha es menor o igual a la actual.
//------------------------------------------------------------------------------------------------
function fechaMenorIgualActual(anno,mes,dia)
{
	var fechaActual = new Date();
	var annoActual = fechaActual.getFullYear();
	var mesActual = fechaActual.getMonth()+1 ;
	var diaActual = fechaActual.getDate();

	if ((anno>annoActual) ||
		((anno==annoActual) && (mes>mesActual)) ||
		((anno==annoActual) && (mes==mesActual) && (dia>diaActual)))
	{
		return false;
	}
	else 
	{
		return true;
	}
}
function fechaMayorIgual16(anio, mes, dia)
{
	var fechaActual = new Date();
	var annoActual = fechaActual.getFullYear();
	var mesActual = fechaActual.getMonth()+1 ;
	var diaActual = fechaActual.getDate();
	
	edad = annoActual - anio;
	if((edad<16) || ((edad==16)&& (mesActual<mes)) ||
	((edad==16) && (mesActual==mes) && (diaActual<dia)))
	{
		return false;
	}
	else
	{
		return true;
	}
	
}

function fechaActual(anno,mes,dia)
{
	var fechaActual = new Date();
	var annoActual = fechaActual.getFullYear();
	var mesActual = fechaActual.getMonth()+1 ;
	var diaActual = fechaActual.getDate();
	var diferencia = diaActual-dia;
	if ((anno==annoActual) && (mes==mesActual) && (diferencia>1))
	{
		return false;
	}
	else 
	{
		return true; 
	}
}


//------------------------------------------------------------------------------------------------
//Función que devuelve true si la cuenta corriente es correcta.
//------------------------------------------------------------------------------------------------
function validaCC(entidad,sucursal,dc,cuenta)
{
		 		 /**
		 		  * Validación de los datos introducidos
		 		  * 
		 		  * Validación general y llamada a la comprobación de cuenta corriente
		 		  *
		 		 */
		 	
       		 var str_error = "";
       		 var arrCC = new Array(entidad, sucursal,dc,cuenta);
       		 		 
		 		 /*
		 		  * Comprobar la cuenta corriente introducida
		 		 */
		 		 if (!checkDC(arrCC[0]+arrCC[1],arrCC[3],arrCC[2]))
					return false;
		 		  // end validate()
		 		 
		 		 /**
		 		  * Filtrado de los valores introducidos en los campos de texto
		 		  * 
		 		  * Sólo permite introducir números, y cambia el estilo del campo si ha sido completado
		 		  * hasta el máximo de su longitud.
		 		  *
		 		  * IN: object objecto Campo sobre el que realizar el filtrado
		 		 */
		 		 function filter(field)
		 		 {
       		     
		 		 		 /*
		 		 		  * Eliminar todos los caracteres no numéricos del campo
		 		 		 */
     		 		 field.value = field.value.replace(/\D/,"");
		 		 
     		 		 /*
     		 		  * Si el campo se ha completado hasta su maxima extensión cambiar su estilo
     		 		 */
        		 if (field.getAttribute("maxlength") == field.value.length)
        		 		 field.setAttribute("class","completo");
        		 else
        		 		 field.setAttribute("class","incompleto");

		 		 } // end filter()
		 		 
		 		 /**
		 		  * Mostrar el código fuente del documento actual
		 		  *
		 		  * IN: bool onNewWindow Abrir en nueva ventana
		 		 */
		 		 function viewSource(onNewWindow)
		 		 {
		 		 		 
		 		 		 if (onNewWindow == true)
		 		 		 		 window.open("view-source:"+document.location.href,"Source");
		 		 		 else
		 		 		 		 document.location = "view-source:"+document.location.href;
		 		 		 		 
		 		 } // end viewSource()
		 		 		 
		 		 /**
		 		  * Validación de una cuenta corriente
		 		  * 
		 		  * Comprueba un número de cuenta corriente
		 		  *
		 		  * IN:  cc1		  string		  Primeros ocho dígitos de la cuenta corriente (entidad.oficina)
		 		  * IN:  cc2  string  Últimos diez dígitos de la cuenta corriente  (#cuenta)
		 		  * IN:  dc   string  Dígitos de control
		 		  * OUT:      bool    ¿Cuenta válida? 
		 		 */
		 		 function checkDC(cc1,cc2,dc)
		 		 {
            
		 		 		 /*
		 		 		  * Comprobar que los datos son correctos
		 		 		 */
     		 		 //if (!(cc1.match(/^\d{8}$/) && cc2.match(/^\d{10}$/) && dc.match(/^\d{2}$/) )) return false;
       		     
		    		 var arrWeights = new Array(1,2,4,8,5,10,9,7,3,6);		 // vector de pesos
    		 		 var dc1=0, dc2=0;    		 		 
       		     
    		 		 /*
    		 		  * Cálculo del primer dígito de control
    		 		 */
   		 		     for (var i=7;i>=0;i--)
   		 		     {
						dc1 += arrWeights[i+2] * cc1.charAt(i);
   		 		     	 
    		 		 }	
    		 		 dc1 = 11 - (dc1 % 11);
  		 		     if (11 == dc1) dc1 = 0;
   		 		     if (10 == dc1) dc1 = 1;
       		     
   		 		     /*
   		 		      * Cálculo del segundo dígito de control
   		 		     */
   		 		     for (i=9;i>=0;i--)
   		 		     { 	
   		 		      	dc2 += arrWeights[i] * cc2.charAt(i);
   		 		      	
    		 		 }   
    		 		 dc2 = 11 - (dc2 % 11);
   		 		     if (11 == dc2) dc2 = 0;
    		 		 if (10 == dc2) dc2 = 1;
       		     
    		 		 /*
    		 		  * Comprobar la coincidencia y delvolver el resultado
    		 		 */
     		 		 return (10*dc1+dc2 == dc);		 // Javascript infiere tipo entero para dc1 y dc2
  		     
		 		 } // end checkDC()
	return true;		 		 
}



//------------------------------------------------------------------------------------------------
//Función que devuelve true si la fecha desde es menor o igual fecha hasta.
//------------------------------------------------------------------------------------------------
function fechaMenorIgualHasta(anno,mes,dia,anno2,mes2,dia2)
{
	//alert("LE  LLEGA  :   "+dia+"/"+mes+"/"+anno+" --- " +dia2+"/"+mes2+"/"+anno2);
	if ((anno>anno2) ||
		((anno==anno2) && (mes>mes2)) ||
		((anno==anno2) && (mes==mes2) && (dia>dia2)))
	{
		return false;
	}
	else 
	{
		return true;	
	}
}

//************************************************************************************************
//***************************VALIDAR NIF/NIE******************************************************
//************************************************************************************************
//------------------------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------------------------
function validarNum(cosa)
{
  for(f=0;f<cosa.length;f++) 
  {
	if(cosa.charCodeAt[f]<48||cosa.charCodeAt[f]>57)
	{
	  return false;
	}
	else
	{
	  return true;
	}
  }
}


//------------------------------------------------------------------------------------------------
//Función que dice si el campo solo tiene dígitos del 0 al 9.
//------------------------------------------------------------------------------------------------
function esNumero(campo)
{
  esValido=false;
  arrayCaracteresPermitidos = new Array('0','1','2','3','4','5','6','7','8','9');
  for (f = 0; f < campo.length; f++)
  {     
 	caracterRecibido=campo.charAt(f);
	esValido=false;
	for(x=0; x<arrayCaracteresPermitidos.length;x++)
	{			
	  //y ahora comparo
	  if(caracterRecibido==arrayCaracteresPermitidos[x])
	  {
		esValido = true;
		break;
	  }
	}
	if(!esValido)// Si el caracter recibido coincide con alguno del array será true.
	{
 	  return false;
	  break;
	}
  }
  if(!esValido)// Si el caracter recibido coincide con alguno del array será true.
  {
	return false;
  }
  else return true;	
}



//------------------------------------------------------------------------------------------------
//Función que rellena a ceros los  blancos de la izquierda
//------------------------------------------------------------------------------------------------
//Función que rellena a ceros los  blancos de la izquierda
function rellenar(contenido,longitudcampo)
{
  var relleno=contenido.length;
  var finaltotal='';
  for (var z=0;relleno<longitudcampo;relleno++)
  {
	finaltotal='0'+finaltotal;	
  }
  return finaltotal+contenido;
}


//------------------------------------------------------------------------------------------------
//Función que valida si un NIF es correcto. Uso en NIF y NIE.
//------------------------------------------------------------------------------------------------
function validarNIF(dni,letra) 
{
  var valida=true;
  var tabla=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');
  var esnum = esNumero(dni);
  if(esnum==false)
  {
    valida=false;
//    alert("Valor del campo NIF/NIE es incorrecto");
    return valida;
  }
  if(!validarNum(dni))
  { 
    valida=false;
//    alert("Valor del campo NIF/NIE es incorrecto"); 
    return valida;
  }
  if(valida) 
  {
	var num=dni%23;
	if(letra.toUpperCase()!=tabla[num]) 
	{
	  valida=false;
//	  alert("Valor del campo NIF/NIE es incorrecto");
	  return valida;
	}
  }	
  return valida;
}



//------------------------------------------------------------------------------------------------
//Función que valida si el NIF/NIE (tipoDocumento+identificador) es correcto.
//------------------------------------------------------------------------------------------------
function validarNIFNIE(campoTipoDocumento,campoIdentificador)
{
  var ok=true;
  campoIdentificador.value=campoIdentificador.value.toUpperCase();//pone en la casilla a mayúsculas
  var opcion=campoTipoDocumento.selectedIndex;//opción de la select
  if (opcion==0)//NIF (d..dl) --> concatenar luego IPF=D+NIF
  {
	var dni=campoIdentificador.value.substring(0,campoIdentificador.value.length-1);
	var letra=campoIdentificador.value.substring(campoIdentificador.value.length-1,campoIdentificador.value.length);
	if (dni.length<=8){ //El DNI es de 8 numeros o menos
		ok=validarNIF(dni,letra);
		if (ok)
		{
		  campoIdentificador.value= rellenar(campoIdentificador.value,'9');//Rellenar con ceros por delante
		}
   } else {
	   	ok=false;
		  }
  }

  else if (opcion==1)//NIE (Xd..dl) --> concatenar luego IPF=E+NIE
  {
  	if ((campoIdentificador.value.length<9) || (campoIdentificador.value.length>10))
  	{
  		ok=false;
  	} else if (campoIdentificador.value.charAt(0) == 'x' || campoIdentificador.value.charAt(0) == 'X')
	{
	  var dni=campoIdentificador.value.substring(1,campoIdentificador.value.length-1);
	  var letra=campoIdentificador.value.substring(campoIdentificador.value.length-1,campoIdentificador.value.length);
	  if (dni.length==8 && dni.charAt(0)=="0")
	  {
	  	ok = false;
	  } else {
		  ok=validarNIF(dni,letra);
		  if (ok)
		  {
		    var dniv=campoIdentificador.value.substring(1,campoIdentificador.value.length);
			//campoIdentificador.value= 'X'+rellenar(dniv,'9');//Rellenar con ceros por delante hasta 9 y poner la X					
		  }
	  }
	}
	else
	{
  	  ok=false;
	}	
  }

  if (ok)
  {
    return true;
  }
  else 
  {
    return false;
  }

}
//************************************************************************************************
//***************************FIN VALIDAR NIF/NIE**************************************************
//************************************************************************************************

//------------------------------------------------------------------------------------------------
//Función que devuelve 'true' si la cadena pasada contiene un numero de Telefono correcto para España:
//	solo admiten numeros de 9 dígitos y el primero debe ser 9, 8 o un 6.
//------------------------------------------------------------------------------------------------
function validaTelf(cadena) {
	if (!soloNumeros(cadena))
		return false;	
	if (cadena.length != 9)
		return false;	
	var cadtmp = cadena.substring(0,1);
	if ( (cadtmp != '9') &&  ( cadtmp != '6') && (cadtmp != '8') )
		return false;	
	return true;
} 

//------------------------------------------------------------------------------------------------
//Función que valida si un número de la seguridad social es correcto.
//------------------------------------------------------------------------------------------------
//Función que valida si un número de la seguridad social es correcto.
function validarNass(campo)
{
  
  campo= rellenar(campo,'12');//Rellenar con ceros por delante	
 
  var longitudnass=campo.length;
  var tercer=campo.substring(2,3);

  var sindc= campo.substring(0,10);
  var correcto = false;	
	
  if(longitudnass < '12'  )
  {
//	alert("Valor del campo Nº Seguridad Social es incorrecto");
	correcto=false;
  }
  else
  {	
	if(isNaN(campo))
	{
//	  alert("Valor del campo Nº Seguridad Social es incorrecto");
	  correcto=false;
	}
	else
	{
	  if( tercer=='0')
	  {				
		var izquierdo= sindc.substring(0,2);
		var derecho= sindc.substring(3,10);
		var numcompleto= izquierdo+derecho;
		var resto=(numcompleto%97);
		var dosultimos=campo.substring(10,12);	
		if (Number(dosultimos) == Number(resto))		
		{
		  correcto=true;
		}
		else 
		{
//		  alert("Valor del campo Nº Seguridad Social es incorrecto");
//alert(resto);
		  correcto=false;
		}
	  }
	  else
	  {
		if (tercer=='1')
		{		
		  var numcompleto= sindc.substring(0,10);
		  var resto=(numcompleto%97);
		  var dosultimos=campo.substring(10,12);
		  if (Number(dosultimos) == Number(resto))		
		  {
			 correcto=true;
		  }
		  else 
		  {
//		    alert("Valor del campo Nº Seguridad Social es incorrecto");
//alert(resto);
		    correcto=false;
		  }
		}
		else
		{
//		  alert("Valor del campo Nº Seguridad Social es incorrecto");
		  correcto=false;
		}
	  }
    }
  }
  return correcto;
}


//--------------------------------------------------------------------------------------


//Función que devuelve 'true' si la cadena pasada contiene un CODIGO POSTAL correcto para España.
function validaCP(cadena) {
	var numero = 0;
	if (soloNumeros(cadena))
	{
		numero = parseInt(cadena,10);
		if ((numero >= 53000) || (numero < 1000))
			return false;
		else 
			return true;
	}
	else 
		return false;
}


function validaCtaCotizacion(cta) {
  var prv = cta.substring(0,2)
  var num = cta.substring(2,9)
  var dig = cta.substring(9,11)
  var multiplier = ((num / 1000000) < 1) ? 1000000 : 10000000; //Si el nº empieza por 
  tmp0 = (prv * multiplier) + (num * 1.0);//Provincia más patronal.Lo del num es cutre pero vale para pasar de string a num.
  tmp1 = tmp0 / 97; //Dividimos entre 97
  tmp1 = parseInt (tmp1); //Pasamos el resultado a entero.
  tmp1 *= 97; //Lo multiplicamos por 97
  var resTmp = tmp0 - tmp1;
  //var resStr = new String (resTmp);
  var res = ((resTmp / 10) < 1) ? "0" + resTmp : resTmp ;
  return (res==dig);
}


function str_replace(search, replace, subject) {
    // http://kevin.vanzonneveld.net
    // +   original by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
    // +   improved by: Gabriel Paderni
    // +   improved by: Philip Peterson
    // +   improved by: Simon Willison (http://simonwillison.net)
    // +    revised by: Jonas Raoni Soares Silva (http://www.jsfromhell.com)
    // +   bugfixed by: Anton Ongson
    // +      input by: Onno Marsman
    // +   improved by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
    // +    tweaked by: Onno Marsman
    // *     example 1: str_replace(' ', '.', 'Kevin van Zonneveld');
    // *     returns 1: 'Kevin.van.Zonneveld'
    // *     example 2: str_replace(['{name}', 'l'], ['hello', 'm'], '{name}, lars');
    // *     returns 2: 'hemmo, mars'
 
    var f = search, r = replace, s = subject;
    var ra = r instanceof Array, sa = s instanceof Array, f = [].concat(f), r = [].concat(r), i = (s = [].concat(s)).length;
 
    while (j = 0, i--) {
        if (s[i]) {
            while (s[i] = s[i].split(f[j]).join(ra ? r[j] || "" : r[0]), ++j in f){};
        }
    };
 
    return sa ? s : s[0];
}

function IsValidTime(timeStrtotal) { 


timeStr = timeStrtotal.value; 

if (timeStr.length != 5) {
	alert("No es un formato valido hh:mm"); 
	timeStrtotal.focus(); 
	return false; 
}

matchArray = timeStr.split(":",2);

if (matchArray.length != 2)  {
	alert("No es un formato valido hh:mm"); 
	timeStrtotal.focus(); 
	return false; 
}


hour = parseInt(matchArray[0])
minute = parseInt(matchArray[1]) 


if (isNaN(hour) || isNaN(minute)) {
	alert("No es un formato valido hh:mm"); 
	timeStrtotal.focus(); 
	return false; 
}

if (hour < 0 || hour > 23) { alert("La hora debe estar entre 0 y 23 "); timeStrtotal.focus(); return false; } 
if (minute<0 || minute > 59) { alert ("Minutos deben estar entre 0 y 59."); timeStrtotal.focus(); return false; } 

//timeStrtotal.value = hour.toString() + ":" + minute.toString()
return true; 
}