if (navigator.appName == 'Netscape') 
{
    window.captureEvents(Event.KEYPRESS);
    window.captureEvents(Event.KEYDOWN);
}


/**--------------------------------------------------------------------------------------
//Nombre     : chkNumFormat
//Descripcion: Funcion que comprueba que el contenido de un campo es numerico
               en caso afirmativo comprobamos el si el formato del numero es correcto
//             formateandolo en caso contrario.
//Parametros : el campo cuyo valor queremos validar.
------------------------------------------------------------------------------------------**/
function chkNumFormat(valor)
{
    if (!isNuM(valor))
     {
            alert("No puede introducir caracteres alfanuméricos en ese campo");
    return false;
     }
     else 
     {
     
       if (valor.indexOf(",")!=-1)
       {

    if(!isFormated(valor.substring(0,valor.indexOf(",")) ) )
            {
                  numeroFormateado=formatNum(valor.substring(0,valor.indexOf(",")));
                  valor=numeroFormateado+valor.substring(valor.indexOf(","),valor.length);
            }            
       }
       else
       {
            if(!isFormated(valor))
{
               valor=formatNum(valor);
}    
       }
  
     }
     return true;
}

/**--------------------------------------------------------------------------------------
//Nombre     : formatNum
//Descripcion: Funcion que formatea los formatea el valor que le llega como parametro con
               puntos de miles devolviendo el numero formateado.
//Parametros : numero que queremos formatear.
------------------------------------------------------------------------------------------**/
function formatNum(num)
{  
   num = String(num);
   var esNegativo = false;
   esNegativo=(num[0]=="-");
   if (esNegativo) num = num.substr(1,num.length);
   
   // Si el numero tiene decimales, entonces llamo a la funcion 
   // que formatea el numero con decimales 
   if (num.lastIndexOf(",")!=-1){
   	   resultado="";
	   dec=num.substring(num.lastIndexOf(","),num.length);
	   num=num.substring(0,num.lastIndexOf(","));
	   
	   while(num.length>3)
	   {    
	        aux=num.substring(num.length-3,num.length);
	        num=num.substring(0,num.length-3);
	        resultado="."+aux+resultado;        
	   }
	   if (num=="") num=0;
	   if (esNegativo)
	   	return resultado="-"+num+resultado+dec;
	   else return resultado=num+resultado+dec;
   }      
   else {
	   resultado="";
	   	   
	   while(num.length>3)
	   {     
	        aux=num.substring(num.length-3,num.length);
	        num=num.substring(0,num.length-3);
	        resultado="."+aux+resultado;        
	   }
	   if (esNegativo)
	        return resultado="-"+num+resultado;                 
	   else return resultado=num+resultado;                 
   } 
}

/**--------------------------------------------------------------------------------------
//Nombre     : formatNumDec
//Descripcion: Funcion que formatea el valor que le llega como parametro con
               puntos de miles y decimales devolviendo el numero formateado.
//Parametros : numero que queremos formatear.
------------------------------------------------------------------------------------------**/

function formatNumDec(num)
{
   var esNegativo = false;
   esNegativo=(num[0]=="-");
   if (esNegativo) num = num.substr(1,num.length);
   
   // Si el numero no tiene decimales, entonces llamo a la funcion 
   // que formatea el numero sin decimales 
	   resultado="";
	   dec=num.substring(num.lastIndexOf(","),num.length);
	   num=num.substring(0,num.lastIndexOf(","));
	   
	   while(num.length>3)
	   {
	        aux=num.substring(num.length-3,num.length);
	        num=num.substring(0,num.length-3);
	        resultado="."+aux+resultado;        
	   }
	   if (esNegativo)
	        return resultado="-"+num+resultado+dec;
	   else return resultado=num+resultado+dec;
}


/**--------------------------------------------------------------------------------------
//Nombre     : unformatNum
//Descripcion: Funcion que desformatea el valor que le llega como parametro con
               puntos de miles devolviendo el numero sin los dichosos puntos.
               500.000 --->>>    500000
//Parametros : numero que queremos formatear.
------------------------------------------------------------------------------------------**/
function unformatNum (num) {	
   
   if (num.indexOf(".")!=-1){        	
      aux = "";	
      for (var i=0;i<num.length;i++) {
      	  if (num.charAt(i)!=".")
      	      aux = aux + num.charAt(i);			  
      }
      return aux;
   }    
   else 
       return num;
}
/**--------------------------------------------------------------------------------------
//Nombre     : redondea2decimales
//Descripcion: Funcion que redondea a 2 decimales el valor recibido (strin con coma o numero con punto)
               14.035----->14,04 (ojo con coma)
               Devuelve el nuevo numero con coma decimal y puntos de miles;  
//Parametros : numero que queremos formatear.
------------------------------------------------------------------------------------------**/

function redondea2decimales (num) {
   
   num=pointToComma(num);
   
   var contador=0;
   numero=new Array();
   numero=num;
   var ent;
   var dec=new Array();
   
   for(var i=0;i<numero.length;i++)
   {
   	if(numero[i]==",")
   	{
   		contador=1;
   	}
   }
   if(contador==1)
   {
   	ent=num.substring(0,num.lastIndexOf(","));
   	
 	dec=num.substring(num.lastIndexOf(",")+1,num.length);
   	
   	if(ent=="")
   	{
   		ent=0;
   	}
   }
   else
   {
   	return formatNumDec(num + "," +"0"+"0");
   }
   
   if(num==0)
   {
   	return formatNumDec(num + "," +"0"+"0");
   }
   else
   {
	   if(dec.length>2)
	    {
	   	if(parseInt(dec[2],10)>4)
	   	{
	   		aux1=parseInt(dec[0],10);
	   		
	   		aux=parseInt(dec[1],10);
	   		
	   		var decaux=0;
	   		decaux=aux+1;
	   		if(decaux==10)
	   		{
	   			aux1=aux1+1;
	   			if(aux1==10)
	   			{
	   				ent=parseInt(ent,10)+1;
	   				aux1=0;
	   			}
	   			decaux=0;
	   		}
	      	}
	   	else
	   	{
  	   		aux1=dec[0];
			decaux=dec[1];
	   		
	   	}
	    }
	   else
	    {
	    	if(dec.length==1)
	    	{
	    		aux1=dec[0];
	    		decaux=0;
	    		
	    	}
	      	else
	      	{
	      		aux1=dec[0];
	      		decaux=dec[1];
	      		
	      	}
	    }
  }
    return formatNumDec(ent + "," + aux1+decaux);
}
/**--------------------------------------------------------------------------------------
//Nombre     : redondea2decimalesBIS
//Descripcion: Funcion que redondea a 2 decimales el valor recibido (strin con coma o numero con punto)
               14.035----->14,04 (ojo con coma)
               Devuelve el nuevo numero con coma decimal y puntos de miles;  
//Parametros : numero que queremos formatear.
------------------------------------------------------------------------------------------**/

function redondea2decimalesBIS (num) {
   
   num=pointToComma(num);
   ent=num.substring(0,num.lastIndexOf(","));
   dec=num.substring(num.lastIndexOf(",")+1,num.length);
   if(ent=="")
   {
   	return formatNumDec(num + "," +"0"+"0");
   }
   else
   {
	   if(dec.length>2)
	    {
	   	if(parseInt(dec[2],10)>4)
	   	{
	   		aux=parseInt(dec[1],10);
	   		var decaux=0;
	   		decaux=aux+1;
	      	}
	   	else decaux=dec[1];
	    }
	   else
	    {
	    	if(dec.length==1) decaux=0;
	      	else decaux=dec[1];
	    }
  }
    return formatNumDec(ent + "," + dec[0]+decaux);
}


/**--------------------------------------------------------------------------------------
//Nombre     : pointToComma
//Descripcion: Funcion que formatea el valor introducido sustituyendo los puntos por comas
                14.56 --->>>  14,56
               Devuelve el nuevo numero;  
//Parametros : numero que queremos formatear.
------------------------------------------------------------------------------------------**/

function pointToComma (num) {
   num = new String(num);
   if (num.indexOf(".")!=-1){        	
       return num.substring(0,num.lastIndexOf(".")) + "," + num.substring(num.lastIndexOf(".")+1,num.length);
   }    
   else 
       return num;    
}

/**--------------------------------------------------------------------------------------
//Nombre     : commaToPoint
//Descripcion: Funcion que formatea el valor introducido sustituyendo las comas por puntos
                14,56 --->>>  14.56
               Devuelve el nuevo numero;  
//Parametros : numero que queremos formatear.
------------------------------------------------------------------------------------------**/

function commaToPoint (num) {
   num = new String(num);	
   if (num.indexOf(",")!=-1) {       	
       	if (parseInt(num.substring(0,num.lastIndexOf(",")),10)==0){
		return "0." + num.substring(num.lastIndexOf(",")+1,num.length);
	}
 	else  return num.substring(0,num.lastIndexOf(",")) + "." + num.substring(num.lastIndexOf(",")+1,num.length);
   }    
   else 
       return num;    
}


/**--------------------------------------------------------------------------------------
//Nombre     : isFormated
//Descripcion: Funcion que valida si un numero que recibe como parametro tiene o no punto
//   de miles. Esta funcion es llamada por chkNumFormat para validar si ha de invocar
//         a formatNum o no. Devolvera true en caso de que el numero tenga algun punto
//      decimal, o false en caso contrario.
//Parametros : numero que queremos comprobar.
------------------------------------------------------------------------------------------**/

function isFormated(num)
{
   ok=false;
   for(i=0;i<=num.length;i++)
   {
     if (num.charAt(i)==".")
         ok=true;   
   }   
   return ok;
}

/**--------------------------------------------------------------------------------------
//Nombre     : isNumFormated
//Descripcion: Funcion que comprueba si un numero esta o no bien formateado con punto de miles.
//   Tambien comprobara si los tiene, en caso de no tenerlos devolvera true, si los 
//   tiene comprobara que esten perfectamente formateados devolviendo true en caso
//   afirmativo y false en caso contrario.  
//Parametros : numero que queremos comprobar.
------------------------------------------------------------------------------------------**/

function isNumFormated(num)
{
   
   ok=true;
   for(i=0;i<=num.length;i++)
   {
     if (num.charAt(i)==".")
         ok=false;   
   }
   
   if(!ok)
   {
     array =num.split(".");     
     for(i=0;i<=array.length-1;i++)
     {
        if((i==0 && array[i].length>3) || (i!=0 && array[i].length!=3))
             return false;
     }
   }
   
   return true;
}

/**--------------------------------------------------------------------------------------
//Nombre     : isNum
//Descripcion: Funcion que comprueba si el valor recibido es un numero
//Parametros : numero que queremos comprobar.
------------------------------------------------------------------------------------------**/

function isNuM(num)
{
  c=0;
  for(i=0;i<=num.length;i++)
  {
    //Ultima modificación: (29/06/2000, Eva C.) que admita numeros negativos, es decir,
    // el primer caracter del numero puede ser un guion "-"
    if(isNaN(num.charAt(i)) && num.charAt(i)!="." && num.charAt(i)!="," && num.charAt(0)!="-")
    {
       return false;
    }

    if(num.charAt(i)==",")
    {
         c++;
    } 
  }
  if (c>1)
  {
    return false;
  }
  if (c==1)
  {
    if (!isNumFormated(num.substring(0,num.indexOf(","))))
       return false;
  }
  if (c==0)
  {
    if(!isNumFormated(num))
       return false;
  }
  return true;
}
/************************************************************************
//Validaciones de fechas
************************************************************************/
// Obtiene la fecha de hoy

function getTodayDate()
{
  var d, s= new String("");
  d = new Date();
  s += d.getDate() + "/";
  s += (d.getMonth()+ 1) + "/";
  s += d.getFullYear();
  return(s);
}

// retorna true si la diferencia de las fechas  es mayor de 18 
function fechasesmenor18 (fechacar, fechanac)
	{
	var dianac,mesnac,yearnac,diacar,mescar,yearcar,restayear;

	dianac = getDia (fechanac);
	mesnac = getMes (fechanac);
	yearnac = getYear (fechanac);
	
	diacar = getDia (fechacar);
	mescar = getMes (fechacar);
	yearcar = getYear (fechacar);

	restayear=yearcar-yearnac;
	
	if (parseInt(restayear,10)>18)
		return false;		
	else if (parseInt(restayear,10)==18) 
			if (parseInt(mescar,10)>parseInt(mesnac,10))
				return false;
			else if (parseInt(mesnac,10)==parseInt(mescar,10))
					if (parseInt(diacar,10)>=parseInt(dianac,10))
						return false; 	
	return true;		
}

// Comprueba que el formato de una fecha sea:
// dd/mm/yyyy
// Devuelve true si se cumple el formato
// o false en otro caso
//
    function chkMaskFecha( str ){
exp= /^\d{1,2}\/\d{1,2}\/\d{2,4}$/;
if(!exp.test(str))
           return false;
        else
           return true;
     }

// Recibe una fecha y nos devuelve el dia
// 
function getDia( str ){

var dia="";
var posIni=0;
var posFin=0;
    
posFin=str.indexOf("/");
dia=str.substring(posIni,posFin);

return (dia);
     
     }

// Recibe una fecha y nos devuelve el mes
//

     function getMes( str ){

var mes="";
var posIni=0;
var posFin=0;

posFin=str.indexOf("/");
posIni=posFin;
posFin=str.lastIndexOf("/");
mes=str.substring(posIni+1,posFin);

return (mes);

     }

// Recibe una fecha y nos devuelve el ano
//
     function getYear( str ){

var year="";
var posIni=0;

posIni=str.lastIndexOf("/");
year=str.substring(posIni+1,str.length+1);

return (year);

     }

// Comprueba la longitud de un ano
// Si el formato de este es "aa" lo pasamos a "aaaa"
// Devuelve el ano

function chkFormatoYear( str ){

  var Year;
  if (str.length==2)
          {
Year=parseInt(str,10);
if (Year>=0 && Year<49)
{
Year=Year+2000;
}
else
{
Year=Year+1900;
}
   }
   else
   {
Year=parseInt(str,10);
   }

   return Year;

}

// Comprueba que una fecha sea correcta
// Devuelve true si la fecha es correcta y false en caso contrario 
//
//
function chkFechaOk(str)
      {
  var Dia;
  var Mes;
  var Year;

  Year=getYear(str);
  Mes=parseInt(getMes(str),10);
  Dia=getDia(str);
  Year=chkFormatoYear(Year);

   if((Mes==1) || (Mes==3) || (Mes==5) ||(Mes==7) ||(Mes==8) ||(Mes==10) ||(Mes==12))
   {
		if(Dia<=0 || Dia>31)
			{return false;}
   }
   else if((Mes==4) ||(Mes==6) ||(Mes==9) ||(Mes==11))
   {
		if(Dia<=0 || Dia>30)
			{return false;}
   }
   else if(Mes==2)
   {
		if((Year%4==0)&&(Year%100!=0)||(Year%400==0))
		{
			if(Dia<=0||Dia>29)
				{return false;}
		}
		else
		{
			if(Dia<=0||Dia>28)
				{return false;}
		}
   }
   else
   {return false;}  
   
   return true;
 }

//  Crea dos objetos de tipo Date de javascript con las fechas que le llegan y
//  llama a la funcion que valida si una es menor que la otra
//  devuelve true si la primera fecha es menor que la segunda
//  o false en caso contrario
//

function chkEsMenor (fechaIni,fechaFin)
{
fechaIniAux=new Date();
fechaFinAux=new Date();

if ( ( !chkFechaOk(fechaIni) )|| ( !chkFechaOk(fechaFin) ) )
{
     return false;
}
else
{
	
fechaIniAux.setMonth(getMes(fechaIni)-1);
fechaIniAux.setDate(getDia(fechaIni));
fechaIniAux.setYear(getYear(fechaIni));

fechaFinAux.setMonth(getMes(fechaFin)-1);
fechaFinAux.setDate(getDia(fechaFin));
fechaFinAux.setYear(getYear(fechaFin));

/* ESTO LO HE CAMBIADO PARA VER SI FUNCIONA 
fechaIniAux.setDate(getDia(fechaIni));
fechaIniAux.setMonth(getMes(fechaIni)-1);
fechaIniAux.setYear(getYear(fechaIni));

fechaFinAux.setDate(getDia(fechaFin));
fechaFinAux.setMonth(getMes(fechaFin)-1);
fechaFinAux.setYear(getYear(fechaFin));
*/

if (!chkRangoFechasMenor (fechaIniAux,fechaFinAux))
{
return false;
}

}
return true;

}

////////////////////////////////////////////////////////////////////////////////
// Nombre Función: fechasDiferenciaEnDias
// Parámetros:     fechaIni -- es la fecha inicial
//                 fechaFin -- es la fecha final
//                 numdias -- es un entero que indica un número de días
// Descripción:    la función compara las fechas y determina si el 
//                 número de días en que se diferencian es mayor que
//                 al número de días pasados como parámetro.
//                 Se almacenan las fechas de entrada en fechas auxiliares
//                 de tipo Date(), que son restadas dando como resultado
//                 el número de milisegundos de diferencia.
//                 Este número se convierte en días y se redondea al entero
//                 menor más cercano.
//				   Si la diferencia es mayor que numdias, devuelve false
//
//  Julio/2002    (Oscar Hernández Caballero)
///////////////////////////////////////////////////////////////////////////////
function fechasDiferenciaEnDias (fechaIni,fechaFin, numdias) {
  
  if ( (!chkFechaOk(fechaIni)) || (!chkFechaOk(fechaFin)) )
  {
       return false;
  }

  fechaIniAux=new Date();
  fechaFinAux=new Date();

  
  
  fechaIniAux.setMonth(getMes(fechaIni));
  fechaIniAux.setDate(getDia(fechaIni));
  fechaIniAux.setYear(getYear(fechaIni));

  fechaFinAux.setMonth(getMes(fechaFin));
  fechaFinAux.setDate(getDia(fechaFin));
  fechaFinAux.setYear(getYear(fechaFin));
  
  //alert ("fechaIniAux="+fechaIniAux.getTime());
  //alert ("fechaFinAux="+fechaFinAux.getTime());
  
  var tiempoRestante = fechaFinAux.getTime() - fechaIniAux.getTime();
  var dias = Math.abs(Math.floor(tiempoRestante / (1000 * 60 * 60 * 24)));
  
  if (dias > numdias) {
  //alert(dias + " días de diferencia");
   return false;
  }
  //alert(dias + " días de diferencia");
  return true;
 
  
}
/////////////////////////////////////////////////////////////



// Comprueba que una fecha sea menor que la otra
// Devuelve true si la primera fecha es menor que la segunda
// o false en caso contrario
//


function chkRangoFechasMenor(fechaIni,fechaFin){

       if ((fechaFin-fechaIni)>0)

return true;
else

return false;

}


//  Crea dos objetos de tipo Date de javascript con las fechas que le llegan y
//  llama a la funcion que valida si una es mayor que la otra
//  devuelve true si la primera fecha es mayor que la segunda
//  o false en caso contrario
//

function chkEsMayor (fechaIni,fechaFin)
{
fechaIniAux=new Date();
fechaFinAux=new Date();

if ( ( !chkFechaOk(fechaIni) )|| ( !chkFechaOk(fechaFin) ) )
{
     return false;
}
else
{

fechaIniAux.setMonth(getMes(fechaIni)-1);
fechaIniAux.setDate(getDia(fechaIni));
fechaIniAux.setYear(getYear(fechaIni));

fechaFinAux.setMonth(getMes(fechaFin)-1);
fechaFinAux.setDate(getDia(fechaFin));
fechaFinAux.setYear(getYear(fechaFin));

/* ESTO LO HE MODIFICADO 

fechaIniAux.setDate(getDia(fechaIni));
fechaIniAux.setMonth(getMes(fechaIni)-1);
fechaIniAux.setYear(getYear(fechaIni));

fechaFinAux.setDate(getDia(fechaFin));
fechaFinAux.setMonth(getMes(fechaFin)-1);
fechaFinAux.setYear(getYear(fechaFin));
*/

if (!chkRangoFechasMayor (fechaIniAux,fechaFinAux))
{
return false;
}

}
return true;

}

// Comprueba que una fecha sea menor que la otra
// Devuelve true si la primera fecha es mayor que la segunda
// o false en caso contrario
//


function chkRangoFechasMayor(fechaIni,fechaFin){

       if ((fechaIni-fechaFin)>0)

return true;
else

return false;

}


// Recibe una fecha y la pasa a formato dd/mm/yyyy
// Devuelve la fecha con el formato indicado
//

function getFormatOk (str) {

var Dia;
var Mes;
var Year;

Dia=getDia(str);
Mes=getMes(str);
Year=getYear(str);

if (parseInt(Dia,10)<10 && Dia.charAt(0)!="0")
{
Dia="0"+Dia;
}

if (parseInt(Mes,10)<10 && Mes.charAt(0)!="0")
{
Mes="0"+Mes;
}

Year = chkFormatoYear(Year);

return (Dia+"/"+Mes+"/"+Year);

}


function chkSonIguales(fechaIni,fechaFin){
   return (!chkEsMayor(fechaIni,fechaFin) && !chkEsMenor(fechaIni,fechaFin));
}


function cambiaFecha(dia,mes,year,cajafecha)	
{
	cajafecha.value = dia + "/" + mes + "/" + year		
}


function calcularEdad(cumple){

todaysTime = new Date();
birthTime = new Date(cumple);

todaysYear = todaysTime.getFullYear()
todaysMonth = todaysTime.getMonth()
todaysDate = todaysTime.getDate()
todaysHour = todaysTime.getHours()
todaysMinute = todaysTime.getMinutes()
todaysSecond = todaysTime.getSeconds()
birthYear = birthTime.getFullYear()
birthMonth = birthTime.getMonth()
birthDate = birthTime.getDate()
birthHour = birthTime.getHours()
birthMinute = birthTime.getMinutes()
birthSecond = birthTime.getSeconds()

if ((todaysYear / 4) == (Math.round(todaysYear / 4))) {
   countLeap = 29}
else {
     countLeap = 28}

if (todaysMonth == 2) {
   countMonth = countLeap}
else {
     if (todaysMonth == 4) {
        countMonth = 30}
     else {
        if (todaysMonth == 6) {
           countMonth = 30}
        else {
           if (todaysMonth == 9) {
              countMonth = 30}
           else {
              if (todaysMonth == 11) {
                 countMonth = 30}
              else {
                 countMonth = 31}}}}}


if (todaysMinute > birthMinute) {
   diffMinute = todaysMinute - birthMinute
   calcHour = 0}
else {
   diffMinute = todaysMinute + 60 - birthMinute
   calcHour = -1}
if (todaysHour > birthHour) {
   diffHour = todaysHour - birthHour + calcHour
   calcDate = 0}
else {
   diffHour = todaysHour + 24 - birthHour  + calcHour
   calcDate = -1}
if (todaysDate > birthDate) {
   diffDate = todaysDate - birthDate + calcDate
   calcMonth = 0}
else {
   diffDate = todaysDate + countMonth - birthDate  + calcDate
   calcMonth = -1}
if (todaysMonth > birthMonth) {
   diffMonth = todaysMonth - birthMonth + calcMonth
   calcYear = 0}
else {
   diffMonth = todaysMonth + 12 - birthMonth + calcMonth
   calcYear = -1}
diffYear = todaysYear - birthYear + calcYear

if (diffMinute == 60) {
   diffMinute = 0
   diffHour = diffHour + 1}
if (diffHour == 24) {
   diffHour = 0
   diffDate = diffDate + 1}
if (diffDate == countMonth) {
   diffDate = 0
   diffMonth = diffMonth + 1}
if (diffMonth == 12) {
   diffMonth = 0
   diffYear = diffYear + 1}
  
   
  if ((diffDate==6 && diffMonth>0) || (diffDate>6) )
      diffYear=diffYear+1;
  
  return diffYear;
} 


function fechapasado(fechatexto)
{
var fecha;
var hoy;
hoy = new Date();
fecha=new Date();
fecha.setMonth(getMes(fechatexto)-1);
fecha.setDate(getDia(fechatexto));
fecha.setYear(getYear(fechatexto));
if (fecha - hoy < 0)
  return true;
else 
  return false;
}


function validaCuenta(cuenta)
{
	var partes;
	partes = cuenta.split("/");
	if (partes.length != 4)
		return false;
	else
		return EsDCCorrecto(partes[0],partes[1],partes[2],partes[3]);	
}

function EsDCCorrecto(entidad, sucursal, dc, cc)
{
	var sucesion1 = new Array(4,8,5,10,9,7,3,6);
	var sucesion2 = new Array(1,2,4,8,5,10,9,7,3,6);
	var S1 = entidad + sucursal;
	var S2 = cc;
	var DCALCULADO = 0;
	var CCALCULADO = 0;

	if(entidad=="0000")
	{   
		alert("Los datos bancarios no son correctos.", "");
		return false;
	}		
	if( (S1.length + S2.length + 2) != 20)
	{
		alert("Faltan cifras en los datos de la entidad bancaria.", "");
		return false;
	}	

	for (var i = 0; i < sucesion1.length; i++)
		DCALCULADO += new Number(S1.charAt(i)) * sucesion1[i];

	var modulo = DCALCULADO % 11;
	modulo = modulo - 11;
	DCALCULADO = modulo - (modulo * 2);
	
	if(DCALCULADO == 10)
		DCALCULADO = 1;
	if(DCALCULADO == 11)
		DCALCULADO = 0;

	for (var i = 0; i < sucesion2.length; i++)
		CCALCULADO += new Number(S2.charAt(i)) * sucesion2[i];

	var modulo2 = CCALCULADO % 11;
	modulo2 = modulo2 - 11;
	CCALCULADO = modulo2 - (modulo2 * 2);
	
	if(CCALCULADO == 10)
		CCALCULADO = 1;
	if(CCALCULADO == 11)
		CCALCULADO = 0;

	if( (DCALCULADO == new Number(dc.charAt(0)) ) && (CCALCULADO == new Number(dc.charAt(1)) ) )
		return true;
	else
	{
		alert("Los datos bancarios no son correctos");
		return false;
	}
}


function letradeldni(numerito)
{
var nifs = 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 pentera = Math.floor(numerito / 23);
var indiceNIF = numerito - (pentera * 23);	
return(nifs[indiceNIF]);      	
}


 function desformatearAMonedaVB (num) {	   	
		aux = "";	
		for (var i=0;i<num.length;i++) {
      	  car = num.charAt(i);
      	  if (car !=".")
      	      aux = aux + num.charAt(i);			  
		}	
		return aux;

}


 function desformatearAMoneda (num) {	   	
		aux = "";	
		for (var i=0;i<num.length;i++) {
      	  car = num.charAt(i);
      	  if (car !=".")
      	     if (car == ",")      	     
      	      aux = aux + ".";
      	     else
      	      aux = aux + num.charAt(i);			  
		}
		if (isNaN(aux))
			return false;
		else	
			return aux;

}
 
 
 function formatearAMoneda(num)
 {		
 	num = num + "";
 	if (isNaN(num))
		return false;
 	else if (num.indexOf("-")!= -1)
 		return false;
 	else
 	{
	   resultado="";
	   pospunto = num.indexOf(".");
	   if (pospunto == -1)
			dec = "" ;
	   else	{
			dec=num.substring(pospunto+1,num.length);			
			num=num.substring(0,pospunto);
			
			//redondeo de la parte decimal
			if (dec.length > 2)
				{				
				if (dec.charAt(2) > 4)	
					{
					fin = true;
					dec = (dec.substring(0,2) * 1) + 1
					}				
				else
					dec = dec.substring(0,2)
				}
				dec = "," + dec;	
			}
	   
	 //formateo de la parte entera  
	   while(num.length>3)
	   {
	        aux=num.substring(num.length-3,num.length);
	        num=num.substring(0,num.length-3);
	        resultado="."+aux+resultado;        
	   }
	   
	   
	   return resultado=num+resultado+dec;
 	}
 } 




 function monedaNS(e,caja,maxentera)
 { 
	cambio();
	alert (e.which);
	if (e.which == 8)
		{
		caja.value = caja.value.substring(0,caja.value.length-1);
		valor = caja.value;
		}			 
	else if (e.which == 188)
		valor = caja.value + ",";
	else		
		valor = caja.value + String.fromCharCode(e.which);
	valor = desformatearAMoneda(valor);
	if (valor != false)
		{
		pospunto = valor.indexOf(".");
		if (!((pospunto == valor.length -4)&&(pospunto != -1))) //si no es el tercer decimal
			{
			if (((pospunto == -1)&&(valor.length <= maxentera))||((pospunto != -1)&&(pospunto <= maxentera))) //si no se pasa en el maximo de numeros enteros
				{
				valor = formatearAMoneda(valor);
				if (valor != false)
					caja.value = valor;
				}	
			}
		}	
	return false;			
 }


 function moneda(caja,maxentera)
 { 
	cambio();
	if ((window.event.keyCode != 9)&&(window.event.keyCode != 13))
	{
		if (window.event.keyCode == 8)
			{
			caja.value = caja.value.substring(0,caja.value.length-1);
			valor = caja.value;
			}			 
		else if (window.event.keyCode == 188)
			valor = caja.value + ",";
		else if ((window.event.keyCode > 95)&&(window.event.keyCode < 106))
			valor = caja.value + (window.event.keyCode-96) + "";
		else 	
			valor = caja.value + String.fromCharCode(window.event.keyCode);
		valor = desformatearAMoneda(valor);
		if (valor != false)
			{
			pospunto = valor.indexOf(".");
			if (!((pospunto == valor.length -4)&&(pospunto != -1))) //si no es el tercer decimal
				{
				if (((pospunto == -1)&&(valor.length <= maxentera))||((pospunto != -1)&&(pospunto <= maxentera))) //si no se pasa en el maximo de numeros enteros
					{
					valor = formatearAMoneda(valor);
					if (valor != false)
						caja.value = valor;
					}	
				}
			}		
		window.event.returnValue = false;	
		window.event.cancelBubble = true;
	}
 } 
 
 
 function alfabetico(){
  cambio();
  valor = window.event.keyCode; 
  if (valor != 32)
	{
	if (
		((valor < 65)||(valor > 122)||((valor > 90)&&(valor < 97))) &&
		(valor != 209)&&
		(valor != 241)&&		
		(valor != 233)&&
		(valor != 225)&&
		(valor != 237)&&
		(valor != 243)&&
		(valor != 250)&&
		(valor != 193)&&
		(valor != 201)&&
		(valor != 205)&&
		(valor != 211)&&
		(valor != 218)
		)
		{
			window.event.returnValue=false;	
			window.event.cancelBubble = true;    	
		}	
	}	
		   
 } 
 
 function numerico(){
  cambio();
  valor = window.event.keyCode; 
  if ((valor < 48)||(valor > 57))
	   {
	   window.event.returnValue=false;
	   window.event.cancelBubble = true;
	   }
	   	      
 }
 
 function alfanumerico()
 {
 cambio();
 valor = window.event.keyCode;
 if (
	  (valor==63)|| 
      (valor==34)|| 
      (valor==39)||
      (valor==38)      
     )
     {     
	 window.event.returnValue=false;	   
	 window.event.cancelBubble = true;
	 }
  }
 
function alfanumericoNS(e)
 {
 cambio();
 valor = e.which;
 if (
	  (valor==63)|| 
      (valor==34)|| 
      (valor==39)||
      (valor==38)      
     )
     {     
	 return false;
	 }
  }
 
 
var hacambiado = false;
	
function cambio()
{
	hacambiado = true;
}

 
function limites(caja,nombrecaja,maximo,minimo,final)
{
	if (hacambiado)
	{
		valor = 0;
		if (caja.value.length > 0)
		{
			valor = desformatearAMoneda(caja.value)* 1;
		}		
		if (maximo.length > 0)
		 {
			maximo = maximo* 1;
			if (valor > maximo)
			{
				alert("El campo " + nombrecaja + " solo admite valores hasta un máximo de " + formatearAMoneda(maximo) + " " + final);							
				caja.focus();
				caja.value= caja.value + "";
				hacambiado = false;
				return false;	
			}
		 }	
		if (minimo.length > 0)
		 {
			minimo = minimo* 1;	
			if (valor < minimo)
			{
				alert("El campo " + nombrecaja + " solo admite valores desde un mínimo de " + formatearAMoneda(minimo) + " " + final);				
				caja.focus();
				caja.value= caja.value + "";
				hacambiado = false;
				return false;												
			}
		 }
	}	 
} 

function rellenaDescripcion(caja,final)
{
	var descripcion;
	var campodescripcion;
	var strfinal = '';
	if (caja.value != '')
	{
		if (final != null)
			strfinal = strfinal + final;
		campodescripcion = eval("caja.form.descr_" + caja.name);
		descripcion = "";
		descripcion = descripcion + caja.value
		if (strfinal != '')
		  	descripcion = descripcion + ' ' + final;
 		campodescripcion.value = descripcion;
 	}
}

function rellenaDescripcionesSelect(select, final)
{
	var i;
	var descripcion;
	var campodescripcion;
	var strfinal = '';
	if (final != null)
		strfinal = strfinal + final;
	campodescripcion = eval("select.form.descr_" + select.name);
	descripcion = "";
	for (var i=0;i<select.options.length;i++) {
      	  if (select.options[i].selected)
      		{
      			if (descripcion != '')
      				descripcion = descripcion + ', ';
      			descripcion = descripcion + select.options[i].text;	
      			if (strfinal != '')
      				descripcion = descripcion + ' ' + final;
      		}
		}
	campodescripcion.value = descripcion;
}

function rellenaDescripcionesSelectMultiple(select)
{
	var i;
	var descripcion;
	var campodescripcion;
	campodescripcion = eval("select.form.descr_" + select.name);
	descripcion = "";
	select = eval("select.form._d_" + select.name);
	for (var i=0;i<select.options.length;i++) {
      	if (descripcion != '')
      		descripcion = descripcion + '&#?|';
      	descripcion = descripcion + select.options[i].text+' ';	
	}
	campodescripcion.value = descripcion;
}

function rellenaDescripcionesRadios(campo)
{
	var i;
	var campodescripcion;	
	campodescripcion = eval("campo.form.descr_" + campo.name);
	var camporadios;	
	camporadios = eval("campo.form." + campo.name + "radio");
	descripcion = "";
	for (var i=0;i<camporadios.length;i++) {
      	  if (camporadios[i].checked)
      		{      			
      			campo.value= camporadios[i].value;
      			campodescripcion.value= camporadios[i].text;	
      			break;
      		}
		}
}
 
function rellenaFecha(dia,mes,year,cajafecha)	
{
	cajafecha.value = dia + "/" + mes + "/" + year;	
}
 
 function aMayus(caja)
 {
 caja.value = caja.value.toUpperCase();
 }
 

//valida el si el parametro es un nif correcto o una tarjeta de residencia correcta
function validaNIFTR(nif)
	{
		if (nif.length< 2)
			return false;
		primera = nif.charAt(0);
		if (isNaN(primera))
		{
			if (nif.length < 3)
				return false;
			mayuscula = primera.toUpperCase();
			if ((mayuscula != 'K')&&(mayuscula != 'L')&&(mayuscula != 'X'))
				return false;	
			numero = nif.substring(1,nif.length-1);
		}
		else
			numero = nif.substring(0,nif.length-1);
		if (isNaN(numero))
			return false;		
		letra = nif.toUpperCase().charAt(nif.length-1);			
		if (letra != letradeldni(numero))
			return false;  	
		return true;		
	} 




function imprimir()
	{                              			
				window.print();    
    }
    
function imprimirdeclaracion()
	{
	          alert('Es necesario rellenar y enviar la Declaración de Salud firmada\nal apartado de correos 590 C.P. 28080 de MADRID para que tenga efecto.\nLa cumplimentación de esta declaración no supone la existencia de cobertura.\nEsta no será efectiva hasta la aceptación por parte de la compañía aseguradora\ny del pago de la prima.\nEn cuanto la compañía aseguradora le admita como asegurado\nle enviaremos la póliza a su domicilio');
			  window.print();		
    }
    
function nombreAleatorio()
{
        var numero = "" + Math.random();
        var nombre;

        nombre = numero.replace (".", "");
        return (nombre);
}


function fscVentana(strNVUrlPagina,intAncho,intAlto)
{     
	var pos_x, pos_y;
	var alto=window.screen.height;
 	var ancho=window.screen.width;
	pos_x = (ancho-intAncho)/2;
	pos_y = (alto-intAlto)/2-20;
  var strNombre = nombreAleatorio();		
  var strPaginaFinal ="../Includes/ventana.asp?urlContenido=";
  strPaginaFinal = strPaginaFinal + strNVUrlPagina;
  conf= window.open(strPaginaFinal,strNombre,"toolbar=no,location=no,directories=no,status=no,menubar=0,resizable=no,width="+intAncho+",height="+intAlto+",left="+pos_x+",top="+pos_y+"");  
}    

function popUp(strNVUrlPagina,intAncho,intAlto)
{     
	var pos_x, pos_y;
	var alto=window.screen.height;
 	var ancho=window.screen.width;
	pos_x = (ancho-intAncho)/2;
	pos_y = (alto-intAlto)/2-20;
  var strNombre = nombreAleatorio();		
  var strPaginaFinal ="../Includes/popUp.asp?urlContenido=";
  strPaginaFinal = strPaginaFinal + strNVUrlPagina;
  conf= window.open(strPaginaFinal,strNombre,"toolbar=no,location=no,directories=no,status=no,menubar=0,resizable=no,width="+intAncho+",height="+intAlto+",left="+pos_x+",top="+pos_y+"");  
}    

function popUpPresu(strNVUrlPagina,intAncho,intAlto)
{     
	var pos_x, pos_y;
	var alto=window.screen.height;
 	var ancho=window.screen.width;
	pos_x = (ancho-intAncho)/2;
	pos_y = (alto-intAlto)/2-20;
  var strNombre = nombreAleatorio();		
  var strPaginaFinal ="../Includes/popUpPresu.asp?urlContenido=";
  strPaginaFinal = strPaginaFinal + strNVUrlPagina;
  conf= window.open(strPaginaFinal,strNombre,"toolbar=no,location=no,directories=no,status=no,menubar=0,resizable=no,width="+intAncho+",height="+intAlto+",left="+pos_x+",top="+pos_y+"");
  
}
/**--------------------------------------------------------------------------------------
//Nombre     : navegador
//Descripcion: Funcion que obtiene el tipo de navegador.
//Retorno	 : Tipo de navegador
------------------------------------------------------------------------------------------**/
function navegador() {	
	//variables for browser type
	var Nscape; //netscape
	var XPlorer; //MS Explorer
	var Mzilla; //Mozilla
	var opera;	//Opera
	var webtv; //WebTV
	var icab;	//iCab
	var navegador;
	var sistema;
	var VersionNum;

	var detect = navigator.userAgent.toLowerCase();
	//Detect Browser
	opera = (detect.indexOf("opera") != -1);
	XPlorer = (!opera && detect.indexOf("msie") !=-1);
	webtv = (detect.indexOf("webtv") !=-1);
	icab = (detect.indexOf("icab") != -1);
	Nscape = (!opera && detect.indexOf("compatible") ==-1);

	//Dectect Version number
	VersionNum = navigator.appVersion.charAt(0);
	if (opera) VersionNum = detect.charAt(detect.indexOf('opera') + 6);
	if (XPlorer && (detect.indexOf("5.") != -1))
		VersionNum = 5;
	if (XPlorer && VersionNum < 3)
		VersionNum = 3;	
								
	if (Nscape && VersionNum > 4) { //if it is netscape 5 or larger, it is really Mozilla (Gecko)
		Nscape = false;
		Mzilla = true;
	}	

	if (XPlorer) 
		navegador="Explorer"		
	else if (Nscape)
		navegador="netscape"	
	else if (Mzilla)
		navegador="Mzilla"
						
	return (navegador+VersionNum);							
}

 
 // Funcion que introduce una nueva opcion en una select
// Si nuevo=true vacia la select, ecc mantiene los valores anteriores
/*function cargaKombo(sSelect,sTexto,sValue,nuevo) {
	//Para vaciar el kombo si es la primera vez. Se deja el mensaje inicial
	if (nuevo) sSelect.options.length=0
	sSelect.options[sSelect.options.length] = new Option(sTexto);
	sSelect.options[sSelect.options.length-1].value = sValue;
}*/
function cargaKombo(sSelect,sTexto,sValue,nuevo,sel) {
	//Para vaciar el kombo si es la primera vez. Se deja el mensaje inicial
	if (nuevo) sSelect.options.length=0
	sSelect.options[sSelect.options.length] = new Option(sTexto);
	sSelect.options[sSelect.options.length-1].value = sValue;
	//ASVInicio
	if (sel == "1"){
		sSelect.options[sSelect.options.length-1].selected=true;
	}
	//ASVFin
}
//Función que vacia un Kombo 
function vaciaKombo(sSelect) {
	sSelect.options.length=0;
}
//Función que desabilita un Kombo
function desabilitaKombo(sSelect) {
	sSelect.disabled=true;
}
//Funcion que carga un input de texto
function cargaTexto(sTextBox,sTexto) {
	sTextBox.value=sTexto;
}
function enfocar(sCampo) {
	sCampo.focus();
}	
////////////////////////////////////////////////////////////////////////////////
// Nombre Función: cargaKomboMultiple
// Parámetros:      
//                  
//                  
// Descripción:    la función introduce una nueva opción en una select múltiple
//                 Si nuevo=true vacia la select 
//
//  Julio/2002    (Oscar Hernández Caballero)
///////////////////////////////////////////////////////////////////////////////
// 
function cargaKomboMultiple(sSelect,sTexto,sValue,nuevo) {
	//Para vaciar el kombo si es la primera vez. Se deja el mensaje inicial
		
	if (nuevo) sSelect.options.length=0
	sSelect.options[sSelect.options.length] = new Option(sTexto, sValue);
	
}





///////////////////////////////////////////////////////////////////	
//funcion trim: Quita espacios en blanco:
///////////////////////////////////////////////////////////////////

	function trim(cadena) 
	{
		var result = "";
		var len = cadena.length;
		var pos = 0;
		var cero =0;
		while( pos < len ) {
			var word_char = cadena.substring( pos, pos + 1);
			if ( word_char == " " ) result = result ;
			else 	result = result +word_char; 
			pos = pos + 1;
		}	
		return result;
	}
 //****************************************************************/
 
 //&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
 //&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&FUNCIONES AUXILIARES DE VALIDACION DE NIF/CIF Y CUENTA BANCARIA&&&&&&&&&&&&&&&&&&&&
 //&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
 function validaDocumento(index,numero)
 {
 	if (index==0)
 	{		//DNI
 		var aux_dni=ValidaNIF(numero);
 		if (aux_dni=="")
 		{
 			return false;
 		}
 		else
 		{
 			return aux_dni
 		}			
 	}
 	else
 	{		//CIF
 		var aux_cif=ValidaCIF(numero);
 		if (aux_cif=="")
 		{
 			return false;
 		}
 		else
 		{
 			return aux_cif	
 		}	
 	}
 }
 /****************************************************************/	
 //Funcion que valida los nif de las personas, tanto extranjeros como 
 //españoles.
 function ValidaNIF(strEntrada)
 {	
 	var strNumero;
 	var strLetraInicial; 
    
 	strNumero = strEntrada;
 	strLetraInicial = strEntrada.substring( 0, 1);
 	strLetraInicial = strLetraInicial.toUpperCase();
    
 	if (strEntrada == "")
 	{
 		var T = "";	 
 		return T;			
 	}		 
 	else if (strLetraInicial == "T") 
 	{     
 		return  strEntrada.toUpperCase();
 	}	
			
 	//Se quitan los espacios en blanco:
 	strEntrada=trim(strEntrada)
	
 	if ("kKLX".indexOf(strLetraInicial)> 0) 	
 		strLetraInicial = strLetraInicial ;	
 	else
 	{    
 		strLetraInicial = "";		
 	}
 	//Elimina caracteres alfanuméricos
 	strNumero = ExtraeLetras(strEntrada);
    
 	//Quita ceros de la izquierda:
 	if (strNumero.substring( 0, 1) == "0")
 		strNumero=strNumero.substring( 1,strNumero.length)
    
 	//Acota tamaño de la parte numérica
 	var ilen =8 - strLetraInicial.length
 	if (strNumero.length >  ilen)
 	{
 		strNumero = strNumero.substring( 0,8 - strLetraInicial.length ); 
 	}
		
 	//strNumero = "00000000".substring( 8 - strLetraInicial.length - strNumero.length, 9 - strLetraInicial.length - strNumero.length) + strNumero;
 	var saux= strLetraInicial + strNumero + DC_Nif(parseInt(strNumero,10));

 	//while(saux.substring( 0, 1)=="0")
 	//	saux=saux.substring( 1, saux.length)
		
 	return 	saux
 }	
 /****************************************************************/	
 //funcion auxiliar1 de validacion de nif:
 function DC_Nif(lNumero) 
 {
 	var iResto; 	
 	var aux;
 	iResto = (lNumero % 23) + 1;
 	aux= "TRWAGMYFPDXBNJZSQVHLCKE".substring(iResto-1, iResto);
 	return aux ;
 }    
 /****************************************************************/	
//funcion auxiliar2 de validacion de nif:
 function ExtraeLetras(strEntrada) 
 {   
 	var Letras;
 	var len = strEntrada.length;
 	var aux;
 	var i;
 	i=0;
 	Letras = ""; 	      
 	while ( i <= len-1)
 	{        
 		aux = strEntrada.substring (i, i+1);
 	    if  (!isNaN(aux))
 		{
 	        Letras = Letras + aux;			
 		}		
 		i=i+1;		
 	}
 	return Letras;
 }
 /****************************************************************/	


 /****************************************************************/	
 function ValidaCIF(strEntrada)
 {
 	var strNumero; 
 	var strLetraInicial; 
 	var strDigitoControl; 

 	if ( strEntrada == "" )
 	{
 		return "";
 	}
	
 	//Se quitan los espacios en blanco:
 	strEntrada=trim(strEntrada)
			
 	//Se obtiene la letra inicial y se pone en mayusculas:
 	strLetraInicial = strEntrada.substring( 0, 1);
 	strLetraInicial = strLetraInicial.toUpperCase();
	
 	if ("aABCDEFGHPQS".indexOf(strLetraInicial)> 0) 
 	{
 		strNumero = ExtraeLetras(strEntrada.substring( 1,strEntrada.length));
 	    //Acota tamaño de la parte numérica
 	    if (strNumero.length > 7 )
 	        strNumero = strNumero.substring( 0,7); 
 		if  ("1234567890".indexOf( strEntrada.substring(strEntrada.length-1, strEntrada.length )) > 0 )
 	    {    
 			//El último carácter es un dígito. La sugerencia se utiliza con dígito.
 			return strLetraInicial + strNumero + DC_Cif (strNumero, strLetraInicial);
 		}
 		else 
 		{
 	        //El último carácter no es un dígito. La sugerencia se utiliza con la letra correspondiente.
 	        strDigitoControl = DC_Cif (strNumero, strLetraInicial);            
 			if ( "0123456789".indexOf( strDigitoControl) > 0 )
 	        {    
 				return strLetraInicial + strNumero + "jJABCDEFGHI".substring( strDigitoControl + 1,strDigitoControl + 2 );
 			}
 			else 
 			{
 	            return strLetraInicial + strNumero + strDigitoControl;
 			}
 	    }
 	}		
 	else 
 	    {
 		//Cif  NO VÁLIDO
 	    return "";
 		}	
 }
 /****************************************************************/	
 function DC_Cif(strEntrada , strLetraInicial ) 
 {
 	var i;
 	var iProducto;
 	var iFactor; 
 	var iSumatorio;
 	var strResultado;
 	//var len = strEntrada.length; 
 	var aux1;
 	var len2;

 	if (strEntrada != "")
 	{
 	    iFactor = 2;
 	    iSumatorio = 0;        
 	    i=1;
 		while (i  <= strEntrada.length)
 	    {	
 			iProducto = iFactor * strEntrada.substring(i-1,i);	           
 	        if (iProducto >= 10)
 			{
 	            // fix devuelve la parte entera	Math.ceil(x) Math.floor(
 				iProducto = Math.floor(iProducto / 10) + (iProducto % 10);
 	        }            
 	        iSumatorio = iSumatorio + iProducto;
 	        iFactor = (iFactor % 2) + 1;
 			i=i+1;
 	    }        
 		strResultado = 10 - (iSumatorio % 10); 
 	}	   	
 	else
 	    return "";
 	var aux1= strResultado.toString();
 	var len2=aux1.length;
 	if (len2> 1)
 		{	
 		var aux = strResultado.toString();
 		strResultado = aux.substring(len2-1,len2);
 		}
 	return strResultado;    
 }
 /****************************************************************/	
 /*
 Entrada: un nif o un cif correctos;
 Salida : F (indica persona física) si el primer carácter de la entrada es X, T o un número.
 		 J (indica persona jurídica) en otro caso.
 */
 function Tipo_Persona(cif_o_nif)
 {
 	/*
 	Entrada: un nif o un cif correctos;
 	Salida : F (indica persona física) si el primer carácter de la entrada es X, T o un número.
 			 J (indica persona jurídica) en otro caso.
 	*/
 	var caracter = cif_o_nif.charAt(0);
 	if (caracter == "X" || caracter == "T")
 		return "F";
 	else
 	{
 		if (isNaN(Number(caracter)))
 			return "J";
 		else
 			return "F";
 	}
 }
 /****************************************************************/	
 /*
 	Entrada: una cadena de texto
 	Salida: la cadena de texto sin los signos de puntuación que pudiera tener
 */
 function Quitar_signos_puntuacion(cadena)
 {
 	var cadena_salida = "";
 	var pos = 0;
 	while(pos < cadena.length ) {
 		var letra = cadena.substring( pos, pos + 1);
 		if ((letra == ",") || (letra == ".") || (letra == ";") || (letra == ":") || (letra == "_") || (letra == "-")) 
 			cadena_salida = cadena_salida;
 		else 	
 			cadena_salida = cadena_salida + letra; 
 		pos = pos + 1;
 	}
 	return cadena_salida;
 }
 /****************************************************************/		
 /*
 Entrada: una cadena que debe ser el nombre de una persona o empresa
 Salida: False si la cadena está consituida por sólo blancos o un único carácter o
 		un único carácter rodeado de blancos. A los signos de puntuación
 		no se les considera como carácter válido y se aplica las normas anteriores
 		al resto de la cadena)
 		True en caso contrario
 */
 function Nombre_correcto(nombre)
 {	
 	var nombre_aux;
 	nombre_aux = Quitar_signos_puntuacion(nombre);
 	if ((trim(nombre_aux).length < 2 ) || (nombre_aux.length == 1))
 		return false;
 	else
 		return true;
 }
 /****************************************************************/		
 /* 
 Entrada: un N.I.F. correcto
 Salida: el N.I.F. escrito con 8 dígitos y una letra. Se habrán añadido ceros a la izquierda
 		si el N.I.F. de entrada no tenía 8 dígito.
 */
 function Formatear_Nif(nif)
 {
 	var nif_aux = nif;
 	var numero; 
 	var letra;
 	numero = trim(ExtraeLetras(nif_aux));
 	letra = trim(nif_aux.substring(numero.length,nif_aux.length));
 	while(numero.length < 8)
 	{	numero = "0" + numero;		}
 	return numero + letra;
 }
 /****************************************************************/
 	
	
function onBlurTomadorNIF()
 {
     //NIF del tomador
 	var aux = validaDocumento(0,document.formTractores.tomadorNIF.value)
 	if (aux == false)
 	{
 		alert("Ha de rellenar correctamente el campo NIF del Tomador")
 		return false		
 	}
 	else
 	{
 		document.formTractores.tomadorNIF.value = aux
 	}
 }
////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////
// Nombre Función: valorASelect
// Parámetros:     objeto  - es el nombre del objeto select
//                 valor   - es el valor que le vamos a asignar al select 
//                  
//                  
// Descripción:    la función que recoge un objeto de tipo select y le asigna 
//                 el valor seleccionado
//                 
//  Enero/2003    (Oscar Hernández Caballero)
///////////////////////////////////////////////////////////////////////////////
 
function valorASelect (objeto, valor)
{
   for (i = 1; i<objeto.options.length; i++) {
		if ((objeto.options.item(i).value) == valor)  objeto.options.item(i).selected=true;
   }
}


 
////////////////////////////////////////////////////////////////////////////////
// Nombre Función: InsertarSelectMultiple
// Parámetros:     origen  - control select origen de los datos
//                 destino   - control select donde se insertaran los datos
//                  
// Descripción:    Copia los elementos seleccionados desde el origen hasta el destino
//                 
//  Febrero/2003    (Alberto Bracamonte)
///////////////////////////////////////////////////////////////////////////////
function InsertarSelectMultiple(origen,destino)
{
	var i,j;
	var opt,optBefore;
	var oHidden;

	if (origen.selectedIndex < 0) alert("Debe seleccionar una o más opciones en el origen");

	for(i=0; i < origen.length;i++)
	{
		opt = origen.options[i];
		if(opt.selected){
			optBefore = destino.options[0];
			for(j=0;(j < destino.length) && (optBefore.text != opt.text);j++,optBefore=destino.options[j]);
			if(j >= destino.length)
			{
				newOpt = new Option();
				newOpt.text= opt.text;
				newOpt.value= opt.value;
				destino.add(newOpt);
			}
		}
	}
	destino.selectedIndex=-1;
	origen.selectedIndex=-1;
	AsignaValorSelectMultiple(destino);
}

////////////////////////////////////////////////////////////////////////////////
// Nombre Función: EliminarSelectMultiple
// Parámetros:     origen  - control select origen de los datos
//                 destino   - control select donde se insertaran los datos
//                  
// Descripción:    Copia los elementos seleccionados desde el origen hasta el destino
//                 
//  Febrero/2003    (Alberto Bracamonte)
///////////////////////////////////////////////////////////////////////////////
function EliminarSelectMultiple(origen,destino)
{
	var i,j;
	var opt,optBefore;
	
	if (origen.selectedIndex < 0) alert("Debe seleccionar una o más opciones en el origen");
	for(i=0; i < origen.length;i++)
	{
		if(origen.options[i].selected){
			origen.removeChild(origen.options[i]);
			i--;
		}
	}
	origen.selectedIndex=-1;
	AsignaValorSelectMultiple(origen);
}

////////////////////////////////////////////////////////////////////////////////
// Nombre Función: AsignaValorSelectMultiple
// Parámetros:     cSelect  - Control select 
//                 valor   - es el valor que le vamos a asignar al select 
//                   
// Descripción:    Devuelve la concatenacion de los valores de cSelect
//                 
//  Febrero/2003    (Alberto Bracamonte)
///////////////////////////////////////////////////////////////////////////////
function AsignaValorSelectMultiple(cSelect)
{
	var sName,sValue;
	sName = new String();
	sName = cSelect.name;
	sName = sName.substring(3,sName.length);
	values = MM_findObj(sName);
	sValue="";
	for(i=0; i < cSelect.length ;i++){
		if (sValue =="") sValue = cSelect.options[i].value;
		else sValue = sValue + ", " + cSelect.options[i].value;
	}
	values.value = sValue;
}	

////////////////////////////////////////////////////////////////////////////////
// Nombre Función: mostrar
// Parámetros:     capa    - nombre de la capa a mostrar u ocultar
//                 si      - parametro que indica si se muestra o se oculta
//                   
// Descripción:    Muestra u oculta la capa pasada por parámetro
//                 
//  Febrero/2003    (Óscar Hernández Caballero)
///////////////////////////////////////////////////////////////////////////////
function mostrar(capa,si)
	{
		if (document.all)
			if (si) {
				//alert("window." + capa + ".style.display='block'");
				eval("window." + capa + ".style.display='block'");
			} else {
				eval("window." + capa + ".style.display='none'");
			}
	}
	
////////////////////////////////////////////////////////////////////////////////
// Nombre Función: Ampliar
// Parámetros:     capa    - nombre de la capa a mostrar u ocultar
//                 si      - parametro que indica si se muestra o se oculta
//                   
// Descripción: muestra u oculta la capa que se le pasa como parámetro dependiendo
//              del valor del checkbox de la capa
//
//  Noviembre/2003    (Óscar Hernández Caballero)
///////////////////////////////////////////////////////////////////////////////
function Ampliar(capa, formulario, campo) {
		var valor
		valor = eval("document." + formulario + "." + campo + ".checked");
		
		if (valor) { 
		  mostrar(capa,true);
		} else {
		  mostrar(capa,false);
		}
	}