var m_strMensaje = '';


/*////////////////////////////////////////////////////////////////////////
/ Declaración:	getObj
/ Misión:		recuperar la referencia a un objeto HTML
/ Entrada:		p_strNombreElemento	: nombre e id del elemento
/ Retorno:		el objeto HTML
/ Observaciones:Para Internet Explorer y Netscape 6 funciona, para Netscape 4 devuelve NULL
////////////////////////////////////////////////////////////////////////*/
function getObj( p_strNombreElemento ) {
	var oElemento;
	
	if (document.getElementById) {
		//se captura el elemento por su ID.
		oElemento = window.document.getElementById( p_strNombreElemento );
		

	} else if (document.all) {
		//se captura como elemento de la coleccion de Document, por nombre
		oElemento = window.document.all[ p_strNombreElemento ];

	} 
	else if (document.layers)	{
		//para Netscape 4, se captura por nombre siempre y cuando esté en EL FORM
		oElemento = window.document.forms['MainForm'].elements[ p_strNombreElemento ];
		//oElemento = p_strNombreElemento;
	}
	return oElemento;
}

function getAttribute( p_objElemento, p_strAtributo ) {
	if (document.getElementById) {
		
		return p_objElemento.getAttribute( p_strAtributo );
		
	} else if (document.layers)	{
		var strFuente = p_objElemento;
		
		strFuente = p_objElemento.formato;
		return strFuente;
		/*
		var intP1 =	strFuente.indexOf( p_strAtributo );
		if( intP1 != -1 ) {
			intP1 += p_strAtributo.length;
		}
		
		return intP1;
		*/
	}
}




//Función simple para submitir el Form de una página a otra página ASP
function submitirForm( action ) {
	window.document.MainForm.Method = "POST";
	window.document.MainForm.action = action;
	window.document.MainForm.submit();
}


function validarDatos( elementos ){

/*******************************************************************
Función para VALIDAR los ELEMENTOS de un FORMULARIO
Variables:
	i 		    : contador para recorrer los elementos del formulario
	formato		: texto, numero, decimales, etc.
	elementos   : son todos los elementos que contiene el formulario
*******************************************************************/

	var i;
	var formato;
	var requerido;
	var nombre;
	var nombreDia;
	var nombreMes;
	var nombreAno;
	var precision;
	
		
	
	for( i=0; i<elementos.length; i++) {
		
		requerido = elementos[i].getAttribute( "requerido" );
		
		if( (requerido == null) || (requerido == "") || (requerido == "0") ||(requerido == "no") ) {
			if( (elementos[i].value == "") || (elementos[i] == null) ) continue;
		}
		
		formato = elementos[i].getAttribute( "formato" );
		if( (formato == "") || (formato == null) )
			continue;
		else
			formato = formato.toLowerCase();
				
		switch ( formato ) {
			/* Preguntamos si el texto no es numérico */
			case "numero":   
							 precision = elementos[i].getAttribute("precision");
							 prec = elementos[i].value;
							 if( esNumero(elementos[i].value) ){ 
								prec = elementos[i].value.indexOf(".");
								if( prec == -1 ) prec = elementos[i].value.indexOf(",");
								if( prec != -1 ) {
									if( precision < (elementos[i].value.length - (prec+1)) )
										return elementos[i].id;
								}
							 } else {
								return elementos[i].id;
							 }
							 break;
											
			case "euro":
							precision = 2
							 prec = elementos[i].value;
							 if( esNumero(elementos[i].value) ){ 
								prec = elementos[i].value.indexOf(".");
								if( prec == -1 ) prec = elementos[i].value.indexOf(",");
								if( prec != -1 ) {
									if( precision < (elementos[i].value.length - (prec+1)) )
										return elementos[i].id;
								}
							 } else {
								return elementos[i].id;
							 }
							 break;
			/* Preguntamos si el texto es numérico */
			case "texto":    if( !isNaN( elementos[i].value ) ) {
							    return elementos[i].id;
							 }
							 break;
							  
			case "fecha":	
						    nombre = elementos[i].id.toLowerCase();
							if( (nombre.indexOf("dia") == 0) || (nombre.indexOf("ano") == 0) || (nombre.indexOf("ano") == 0) ) {
								nombreDia = "dia_" + nombre.split("_")[1];
								nombreMes = "mes_" + nombre.split("_")[1];
								nombreAno = "ano_" + nombre.split("_")[1];
								if (!validarFecha( getObj( nombreDia ), getObj( nombreMes ), getObj( nombreAno ) ) ) {
									return nombre;
								}
							}	
						  break;

			
			case "nif":   if(!validarNIF( elementos[ i ] )) { 
			                 return elementos[ i ].id;
			              }
				          break;
				          
			case "alfanumerico": if (requerido== "si" && elementos[i].value == "")
									return elementos[i].id;
				          break;
			
			case "email":
					var strCont = elementos[i].value;
					var intArroba = strCont.indexOf('@');
					var intPunto = strCont.lastIndexOf('.');
					var intApostrofe = strCont.lastIndexOf("'");
					if( (intApostrofe!= -1) ||(intArroba == -1 || intPunto == -1) || (intArroba > intPunto) || (intArroba == 0 || intPunto == strCont.length-1 ) || (intArroba+1 == intPunto) ) {
						return elementos[i].id;
					}
				break;
				
			
		}//Fin del switch
	}//Fin del For
	
	return true;
 
}//Fin de la función validarDatos

/***************************************************************
 Función para comprobar la precision de un número
 Parámetros:
	elemento:		elemento a comprobar
 Variables	
****************************************************************/
//function comprobarPrecision( elemento ){
//	alert(elemento.indexOf(,));

//}






/*''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' 
' Declaración:		comprobarTipoDocumento()
' Misión:			Función que llama a validarNIF sólo si el tipo de documento es NIF
' Entrada:			-p_tipoDocumento:    Tipo del documento (NIF, NIE, CIF).
'					-p_documento:        El objeto documento.
' Salida:		    N/A
' Retorno:			N/A
' Efectos:			N/A
' Observaciones:	N/A
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''*/

function comprobarTipoDocumento (strDocumentType, strDocID) {
	
	//Declaración de variables
	
	//Comprobamos que el documento no vaya vacío
	if (strDocID.value == "") {
		m_strMensaje = 'Debe especificar un valor para el ' + strDocumentType.value.toUpperCase();
		return;
	}

	//Validamos en función del tipo de documento
	switch (strDocumentType.value.toUpperCase()) {
		case 'NIF':
			//Se valida el NIF
			if (!validarNIF(strDocID)){
				return;
			}
			break;
			
		case 'NIE':
			//Se valida el NIE
			if (!validarNIE(strDocID)){
				return;
			}
			break;
	
		case 'CIF':
			//Se valida el CIF
			if (!validarCIF(strDocID)) {
				return;	
			}
			break;
	}
	
	//Lo convertimos a mayúsculas
	strDocID.value = strDocID.value.toUpperCase();
	
	
	//Todo bien
	return (true);
	
}


//Función que valida un CIF
function validarCIF (strDocID) {
	
	//Declaración de variables
	var vntTemp;
	var primeraLetra;
	var ultimaLetra;
	var parteNumerica;
	var strDocument = "";
	
	
	//Un NIE debe de empezar por la letra X o Y
	if (strDocID.value.charAt(0).toUpperCase() == 'X' || strDocID.value.charAt(0).toUpperCase() == 'Y'){
		m_strMensaje = 'El primer dígito del CIF no puede ser X o Y.'
		return;
	}
	
	//Comprobamos que el primer digito del CIF sea una letra
	if(esEntero(strDocID.value.charAt(0))) {
		m_strMensaje = 'El CIF no es correcto.'
		return;
	}
	
	//Validamos la longitud del documento. Debe de tener 9 posiciones
	if (strDocID.value.length != 9 ) {
		m_strMensaje = 'El CIF debe de tener 9 dígitos.'
		return;
	}
	
	
	//Nos guardamos el primer caracter del CIF
	primeraLetra = strDocID.value.charAt(0).toUpperCase();
	primeraLetra = primeraLetra.toString();
	
	//Nos guardamos el carcater de control
	ultimaLetra = strDocID.value.charAt(8).toUpperCase();
	
	//Nos guardamos la parte numérica
	parteNumerica = strDocID.value.substring(1,8);
	
	//Comprobamois la primera letra del CIF, dependiendo del grupo el Caracter de Control será Numérico o Caracter
	if (AuxEstaEnGrupo(primeraLetra.toUpperCase(),"ABCDEFGHJUV")) {
		//*******************************
		//Entidades Jurídicas Nacionales		
		//*******************************
		//A: Sociedades anónimas
		//B: Sociedades de responsabilidad limitada
		//C: Sociedades colectivas
		//D: Sociedades comanditarias
		//E: Comunidades de bienes y herencias yacentes
		//F: Asociaciones cooperativas
		//G: Asociaciones
		//H: Comunidades de propietarios en régimen de propiedad horizontal
		//J: Sociedades civiles, con o sin personalidad jurídica
		//U: Uniones temporales de Empresas
		//V: Otros tipos no definidos en el resto de claves
		
		//Se calcula el caracter de control
		return AuxVerificaPersonaJuridica(parteNumerica, ultimaLetra, true);
	
	} else if (AuxEstaEnGrupo(primeraLetra.toUpperCase(),"NW")) {
		//*******************************
		//Entidades Jurídicas Extranjeras		
		//*******************************
		//N: Entidad Extranjera 
		//W: Establecimiento permanente de entidad no residente en territorio español
		
		//Se calcula el caracter de control
		return AuxVerificaPersonaJuridica(parteNumerica, ultimaLetra, false);
		
	} else if (AuxEstaEnGrupo(primeraLetra.toUpperCase(),"P")) {
		//*******************************
		//Corporaciones Locales	
		//*******************************
		//P: Corporaciones locales
		
		//Se calcula el caracter de control
		return AuxVerificaPersonaJuridica(parteNumerica, ultimaLetra, false);
		
	} else if (AuxEstaEnGrupo(primeraLetra.toUpperCase(),"QR")) {
		//************************************************************
		//Organismos de la Administración y Congregaciones Religiosas
		//************************************************************
		//Q: Organismos públicos
		//R: Congregaciones e instituciones religiosas
		
		//Se calcula el caracter de control
		return AuxVerificaPersonaJuridica(parteNumerica, ultimaLetra, false);
		
	} else if (AuxEstaEnGrupo(primeraLetra.toUpperCase(),"S")) {
		//************************************************************
		//Órganos del Estado
		//************************************************************
		//S: Órganos de la administración del Estado y de las Comunidades Autónomas
		
		//Se calcula el caracter de control
		return AuxVerificaPersonaJuridica(parteNumerica, ultimaLetra, false);
		
	} else {
		//Si no es ninguno de los anteriores
		return;
	}
}



//Función que valida un NIE
function validarNIE (strDocID) {
	
	//Declaración de variables
	var vntTemp;
	var primeraLetra;
	var strDocument = "";
	
	
	//Un NIE debe de empezar por la letra X o Y
	if (strDocID.value.charAt(0).toUpperCase() != 'X' && strDocID.value.charAt(0).toUpperCase() != 'Y'){
		m_strMensaje = 'El primer dígito del NIE debe ser X o Y.'
		return;
	}
	
	//Validamos la longitud del documento. Debe de tener 9 posiciones
	if (strDocID.value.length != 9 ) {
		m_strMensaje = 'El NIE debe de tener 9 dígitos.'
		return;
	}
	
	//Nos guardamos el primer caracter del NIE
	primeraLetra = strDocID.value.charAt(0).toUpperCase();
	primeraLetra = primeraLetra.toString();
	
	//Comprobamos qué letra es.	
	if (primeraLetra.toUpperCase() == "X") {
		strDocument = strDocID.value.substring(1,8);
	} else if (primeraLetra.toUpperCase() == "Y") {
		strDocument = strDocID.value.substring(0,8).replace('Y','1').replace('y','1');
	} else {
		strDocument = strDocID.value.substring(1,8);
	}
	
	
	//Obtenemos la letra de control del documento y comprobamos si es la correcta
	return AuxVerificaPersonaFisica(strDocument, strDocID.value.charAt(8).toUpperCase());
	
}




/************************************************************************
Función para comprobar que el N.I.F. sea correcto							
Variables:
	valorNIF	 : contiene el valor del NIF introducido pasado a mayúsculas
	mensaje      : contiene el mensaje de error de NIF incorrecto
	LETRAS		 : contiene las letras posibles del NIF
	letraNIF	 : contiene la letra del NIF introducido
	numeros		 : contiene el valor numérico del NIF
	resto		 : operaciones
	letra		 : operaciones  
**************************************************************************/

function validarNIF( elemento ) {
	
	if ( elemento.value != "" ) {
		elemento.value = elemento.value.toUpperCase();
		var valorNIF = elemento.value;
		var mensaje = 'NIF incorrecto';
		var LETRAS = 'TRWAGMYFPDXBNJZSQVHLCKE';
		var letraNIF = valorNIF.substring(valorNIF.length-1, valorNIF.length)
		if ( LETRAS.indexOf( letraNIF ) != -1 ) {
			var numeros = valorNIF.substring( 0, valorNIF.length-1 )
			var resto = numeros%23
			var letra = LETRAS.substring( resto, resto+1 )
			if (letra == letraNIF ) 
				return true;
		}
	}
}

/************************************************************************
Función para VALIDAR las FECHAS de un FORMULARIO
Variables:
	mensaje 	: variable para mostrar mensaje de error
	dia 		: parámetro que le paso a la función con el valor del día 
	mes         : parámetro que le paso a la función con el valor del mes
	ano         : parámetro que le paso a la función con el valor del año
**************************************************************************/
function validarFecha(dia, mes, ano) {
	var requerido;
	
	requerido = dia.getAttribute( "requerido" );

	var i;
	if( mes.length == 12 ){ i = 1; }else{ i = 0; };
	
	//alert(mes.id + ' ' + i );
	
	if( (mes.selectedIndex + i == 4 || mes.selectedIndex + i == 6 || mes.selectedIndex + i == 9 || mes.selectedIndex + i == 11) && (dia.selectedIndex + i < 1 || dia.selectedIndex + i > 30) ) {
		return false;
	}
	if( (ano.value%4)==0 && ( (ano.value%100 != 0) || (ano.value%400 == 0) )) {
	    //Aquí entramos si el año es BISIESTO
	    if( mes.selectedIndex + i == 2 && (dia.selectedIndex + i < 1 || dia.selectedIndex + i > 29) ){
			return false;
		}
	} else { 
		//Aquí entramos si el año no es BISIESTO
		if( mes.selectedIndex + i ==2 && (dia.selectedIndex + i <1 || dia.selectedIndex + i > 28) ){
			return false;
		}
	  }
	return true;
}//Fin de la función validarFecha




/************************************************************************
Función para MOSTRAR u OCULTAR un elemento HTML
Parámetros:
	elemento 	: el ID del elemento en el documento HTML
	mostrar 	: booleano para mostrar u ocultar
**************************************************************************/
function mostrarElemento( elemento, mostrar ) {
	var oElement = getObj( elemento );
	if( mostrar == true) {
		oElement.style.visibility = "visible";
		if(IE4 || IE5){
			oElement.style.display = "inline";
		}
		else{
			oElement.style.display = "";
		}	
	} else {
		oElement.style.visibility = "hidden";
		oElement.style.display = "none";	
	}
}

/************************************************************************
Función para MOSTRAR u OCULTAR un elemento HTML
Si el elemento está oculto se muestra, y si es visible, se oculta
Parámetro:
	elemento 	: el ID del elemento en el documento HTML
**************************************************************************/
function mostrarElemento2( elemento ) {
	var oElement = getObj( elemento );
	if( oElement.style.visibility == "hidden" ) {
		oElement.style.visibility = "visible";
		if(IE4 || IE5){
			oElement.style.display = "inline";
		}
		else{
			oElement.style.display = "";
		}	
	} else {
		oElement.style.visibility = "hidden";
		oElement.style.display = "none";	
	}
}


/*********************************************************************
Función para insertar una imagen de tipo bullet al lado de un objeto
Parámetros:
		elemento	: ID del objeto en HTML
**********************************************************************/
function marcarElemento( elemento ) {

	var domain = "http://" + window.location.toString().split("//")[1].split("/")[0] + "/";
	//multitarificador.reale.es
	if(domain.indexOf('multitarificador.reale.es') > 0 ) {
		var strColor = '#FA2A2A';
		var strColor2 = 'RGB(250, 42, 42)';
	}else{
		if(window.location.toString().indexOf('id_broker=75') > 0 ) {
				var strColor = '#FFE4B1' ;
				var strColor2 = 'RGB(255, 228, 177)';
		}else{
			if(window.location.toString().indexOf('id_broker=72') > 0 ) {
				var strColor = '#FFE4B1' ;
				var strColor2 = 'RGB(255, 228, 177)';
			}else{
				var strColor = '#D29717' ;
				var strColor2 = 'RGB(210, 151, 23)';
			}
		}
	};
	
	//marcar la caja de texto y pintar el bullet
	elemento = getObj( elemento );
	
	//Hay que comprobar en mayúsculas, porque el lo convierte a minúsuclas
	if( elemento.style.backgroundColor.toUpperCase() != strColor && elemento.style.backgroundColor.toUpperCase() != strColor2 ) {
		if (m_strMensaje != '' ) {
			mostrarMensaje( m_strMensaje );
			m_strMensaje = '';
		} else {
			mostrarMensaje( 'Error de datos en el campo ' + elemento.getAttribute( 'desc' ) );
		}
		elemento.style.backgroundColor =strColor;
		//elemento.style.color ='white';
		//Se pone la posición en absolute para que nos devuelva la posicion absoluta.
		if(!elemento.disabled)
			elemento.focus();
		else
			elemento.scrollIntoView(true);
	} else {
		elemento.style.backgroundColor = '';
		//elemento.style.color ='black';
		mostrarMensaje( '' );
	}
	
}

/**********************************************************************
Función para mostrar un texto en el área de mensajes
Parámetros:
		mensaje	:	el texto a mostrar
**********************************************************************/
function mostrarMensaje( mensaje ) {
	
	var oElemento = getObj( 'mensaje' );
	if( oElemento != null ) {
		if( oElemento.tagName.toLowerCase() == 'input' )
			oElemento.value = mensaje;
		else
			oElemento.innerHTML = mensaje;
	}
	
	if( mensaje != '' ) alert( mensaje );
}

/*********************************************************************
Función para habilitar o desabilitar un elemento
Parámetros :
		elemento	:	id del elemento a habilitar o deshabilitar
		habilitar	:	valor booleano
*********************************************************************/
function habilitarElemento( elemento, habilitar ) {
	elemento = getObj( elemento );
	
	if( habilitar )
		elemento.enabled = true;
	else
		elemento.enabled = false;
}

/*******************************************************************
Función para hacer un 'ROLLOVER'. cambia la Clase del objeto
de xx_OUT a xx_OVER donde xx es lo que sea.
Si el elemento en cuestión es un TD, se ejecuta sobre su .PARENT, que
se supone que es el TR
No hay parámetros.
*******************************************************************/
function cambiarClase() {
	var objeto = window.event.srcElement;
	
	if( objeto.tagName == 'TD' ) 
		objeto = objeto.parentElement;

	var clase = objeto.className;
	var i = clase.indexOf('_OUT');
	if( i == -1 ) {
		i = clase.indexOf('_OVER');
		if( i != -1) objeto.className = ( clase.substring(0, i) + '_OUT' );
	} else {
		objeto.className = ( clase.substring(0, i) + '_OVER' );
	}
}

/*************************************************************************
 Variables:
     anterior:  variable de página que guarda el último elemento pinchado
**************************************************************************/
var anterior = null;
function seleccionarFila() {
	var objeto = window.event.srcElement;
	while( objeto.tagName != 'TR' )
		objeto = objeto.parentElement;
	
	var clase = objeto.className;
	if( clase.indexOf( '_SELECTED' ) != -1 ) return;

	var i = clase.indexOf( '_OVER' );
	if( i == -1 ) i = clase.indexOf( '_OUT' );
	
	if( i == -1 ) {
		objeto.className = ( clase + '_SELECTED' );
	} else {
		objeto.className = ( clase.substring(0, i) + '_SELECTED' );
	}
	if( anterior != null ) {
		anterior.className = ( anterior.className.substring(0, anterior.className.indexOf( '_SELECTED' ) ) + '_OUT' );	
	}
	anterior = objeto;
}

function esNumero( numero ) {
	
	var longitud = numero.length;
	var caracter;
	var encontrado = false;
	
	if( longitud == 0 ) return false;
	
	for(var i=0; i<longitud; i++) {
		caracter = numero.substr( i, 1);
		switch( caracter ) {
			case '0':
			case '1':
			case '2':
			case '3':
			case '4':
			case '5':
			case '6':
			case '7':
			case '8':
			case '9':
			case '0':
				break;

			case '.':
			case ',':
				if( encontrado == true )
					return false;
				else
					if( (i == 0) || (i == longitud-1) )
						return false;
					else
						encontrado = true;
				break;

			default:
				return false;
				break;
		}
	}
	return true;
}

function DameMesANumero(mes){
	
	switch (mes){
		case 'Enero':mes = 1;
					break;
		case 'Febrero':mes = 2;
					break;
		case 'Marzo':mes = 3;
					break;
		case 'Abril':mes = 4;
					break;
		case 'Mayo':mes = 5;
					break;
		case 'Junio':mes = 6;
					break;
		case 'Julio':mes = 7;
					break;
		case 'Agosto':mes = 8;
					break;
		case 'Septiembre':mes = 9;
					break;
		case 'Octubre':mes = 10;
					break;
		case 'Noviembre':mes = 11;
					break;
		case 'Diciembre':mes = 12;
					break;
		case '-' : mes = '-';
					break;
		default:mes = '';	
	}	
	return(mes)
}

function DameMesANumeroPT(mes){
	
	switch (mes){
		case 'Janeiro':mes = 1;
					break;
		case 'Fevereiro':mes = 2;
					break;
		case 'Março':mes = 3;
					break;
		case 'Abril':mes = 4;
					break;
		case 'Maio':mes = 5;
					break;
		case 'Junho':mes = 6;
					break;
		case 'Julho':mes = 7;
					break;
		case 'Agosto':mes = 8;
					break;
		case 'Setembro':mes = 9;
					break;
		case 'Outubro':mes = 10;
					break;
		case 'Novembro':mes = 11;
					break;
		case 'Dezembro':mes = 12;
					break;
		default:mes = '';				
	}	
	return(mes)
}



/*******************************************************************************************
* Declaración:	  function FormularioBorrar
* Misión:		  Borrar un formulario
* Entrada:		  p_objForm - Elementos del form que queremos borrar
* Retorno:		  N/A
* Observaciones:  N/A
********************************************************************************************/

function FormularioBorrar( p_objForm ) {
	var strImput;	
	var intC;
	for (intC=1; intC < p_objForm.length; intC++) {
		switch (p_objForm[intC].type) {
			case 'text':  //Cajas de Texto (No se incluyen los HIDDEN
				p_objForm[intC].value = '';
			case 'select-one': //Combos
				//p_objForm[intC].selectedIndex = '0';
				p_objForm[intC].value = '';
		}
	}	
	p_objForm.reset;
}



/*''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
' Declaración:	CambiarCombo
' Misión:		Cambia los valores de los combos de Franquicia y Tipo Seguro
				para evitar incongruencias
' Entrada:		p_objCombo - Combo sobre el que hemos pinchado
				strCombo  - String que contiene una referencia para saber
				            sobre que combo he pinchado
' Salida:		N/A
' Retorno:		N/A
' Efectos:		N/A
' Observaciones:  Los daos de Tipo Seguro vienen de una tabla, en el momento
				  que se añadan más registros a la tabla y el campo
				  Todo Riesgo Sin Franquicia la función hará mal las validaciones	
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''*/

function CambiarCombo () {
		
		
		
		if (window.document.MainForm.vehiculo_nuevo.value != '2' && window.document.MainForm.vehiculo_nuevo.value != '3') {
			if (window.document.MainForm.companya_actual.value == '')
				window.document.MainForm.companya_actual.selectedIndex = '0';
				window.document.forms['MainForm'].dia_fechaseguroactual.selectedIndex = 0;
				window.document.forms['MainForm'].mes_fechaseguroactual.selectedIndex = 0;
				window.document.forms['MainForm'].ano_fechaseguroactual.selectedIndex = 0;
		}	
		if (window.document.MainForm.tipo_seguro.value != '4' ) 
			window.document.MainForm.franquicia.value = '0';
		if (window.document.MainForm.tipo_seguro.value == '4' && window.document.MainForm.franquicia.value == '0') 
			window.document.MainForm.franquicia.value = '25000';	
		if (window.document.MainForm.companya_actual.value == '') 
			window.document.MainForm.tipo_seguro_actual.value = '';		
		if (window.document.MainForm.companya_actual.value != '' && window.document.MainForm.tipo_seguro_actual.value == '') 
			window.document.MainForm.tipo_seguro_actual.value = '1';			  
		if (window.document.MainForm.tipo_seguro.value <= '2' ){	
			window.document.MainForm.valor_accesorios.disabled = true;
			window.document.MainForm.valor_accesorios.value = '';
		}
		else
			window.document.MainForm.valor_accesorios.disabled = false;
}


function FechasBlancoComprobar() {
	
	var strFechas;
	var strAtributos;
	var intC;
	var x, y;
	//Nos guardamos todos los combos de la página
	
	if( !IE5 && !NS6 ) return true;
	
	strFechas = window.document.MainForm.all;
	
	for ( intC=0; intC < strFechas.length; intC++ ) {
		//Si es una fecha hacemos la comprobacion
		if ( strFechas[intC].getAttribute('formato') == 'fecha' || strFechas[intC].getAttribute('formato') == 'fecha2' ) {
			//Si es vacío corregimos al 'USUARIO'
			if ( strFechas[intC].value == '' && strFechas[intC].disabled != true ) {
				mostrarMensaje('El campo ' + strFechas[intC].getAttribute('desc') + ' está vacío');
				//alert('El campo ' + strFechas[intC].getAttribute('desc') + ' está vacío');
				//Hay que comprobar en mayúsculas, porque el lo convierte a minúsuclas
				if( strFechas[intC].style.backgroundColor.toUpperCase() != '#FA2A2A' ) {
					strFechas[intC].style.backgroundColor = '#FA2A2A';
				}	
				strFechas[intC].scrollIntoView(true);
				return false;
			} else{
				if ( strFechas[intC].id != 'dia_fechaefecto' && strFechas[intC].id != 'mes_fechaefecto' && strFechas[intC].id != 'ano_fechaefecto') {
				strFechas[intC].style.backgroundColor = 'white';	
				continue; //Si el combo no está blanco continuamos
				} else {
					continue;
				}
			}
		}
	}
	return true;
}	


function EsFechaMayor(dia1,mes1,ano1,dia2,mes2,ano2){
	
	mes1 = parseInt(DameMesANumero(mes1))
	mes2 = parseInt(DameMesANumero(mes2))
		
	var diferencia;
	
	if(ano1 > ano2)
		if (mes1 > mes2)
			diferencia = ano1 - ano2;
		else
			if (mes1 < mes2)
				diferencia = ano1 - ano2 -1;
			else
				if(dia1 >= dia2)
					diferencia = ano1 - ano2;
				else
					diferencia = ano1 - ano2 -1;
	else
		if (ano1 < ano2) 
			diferencia = -1;
			
		else 
			if (ano1 == ano2)
				if (mes1<mes2)
					
					diferencia = -1;
				else 
					if (mes1>mes2)
						diferencia = 0;
					else 
						if ((dia1>dia2) || (dia1==dia2))
								diferencia = 0;
						else diferencia = -1;
	
	return diferencia

}


function DameMesANumero(mes){
	var mesNumerico
	switch (mes){
		case "Enero":mesNumerico = 1;
					break;
		case "Febrero":mesNumerico = 2;
					break;
		case "Marzo":mesNumerico = 3;
					break;
		case "Abril":mesNumerico = 4;
					break;
		case "Mayo":mesNumerico = 5;
					break;
		case "Junio":mesNumerico = 6;
					break;
		case "Julio":mesNumerico = 7;
					break;
		case "Agosto":mesNumerico = 8;
					break;
		case "Septiembre":mesNumerico = 9;
					break;
		case "Octubre":mesNumerico = 10;
					break;
		case "Noviembre":mesNumerico = 11;
					break;
		case "Diciembre":mesNumerico = 12;
					break;
		case "-" : mesNumerico = "-";
					break;
		default:mesNumerico = '';				
	}	
	return(mesNumerico)
}

function DateAdd(timeU,byMany,dateObj) {
	var millisecond=1;
	var second=millisecond*1000;
	var minute=second*60;
	var hour=minute*60;
	var day=hour*24;
	var year=day*365;

	var newDate;
	var dVal=dateObj.valueOf();
	switch(timeU) {
		case "ms": newDate=new Date(dVal+millisecond*byMany); break;
		case "s": newDate=new Date(dVal+second*byMany); break;
		case "mi": newDate=new Date(dVal+minute*byMany); break;
		case "h": newDate=new Date(dVal+hour*byMany); break;
		case "d": newDate=new Date(dVal+day*byMany); break;
		case "y": newDate=new Date(dVal+year*byMany); break;
	}
	return newDate;
}

/*''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' 
' Declaración:		DameDiasDiferencia(p_diaMayor,p_mesMayor,p_anoMayor,p_diaMenor,p_mesMenor,p_anoMenor)
' Misión:	Funcion que devuelve los dias de diferencia que hay entre dos fechas.		
' Entrada:			p_diaMayor: dia1 formato dd
'					p_mesMayor: mes1 formato mm
'					p_anoMayor: año1 formato aaaa
'					p_diaMenor: dia2 formato dd
'					p_mesMenor: mes2 formato mm
'					p_anoMenor: año2 formato aaaa
' Salida:		    N/A
' Retorno:			Número de dias de diferencia, si es negativo es que la fecha 2º es mayor
' Efectos:			N/A
' Observaciones:	N/A
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''*/
function DameDiasDiferencia(p_diaMayor,p_mesMayor,p_anoMayor,p_diaMenor,p_mesMenor,p_anoMenor){
    
    var FechaMayor = new Date(p_anoMayor,p_mesMayor - 1,p_diaMayor);
	var FechaMenor = new Date(p_anoMenor,p_mesMenor - 1,p_diaMenor);
    
    var diferencia = FechaMayor.getTime() - FechaMenor.getTime();
	var DiferenciaDias = Math.floor(diferencia/1000/60/60/24);
	   
    return DiferenciaDias;
}//function


/*'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
' Declaración:	DimeAnosDiferencia()
' Misión:		Devuelve la diferencia en años de dos fechas
' Entrada:		p_Dia1 - dia de la primera fecha
'				p_Mes1 - mes de la primera fecha
'				p_Ano1 - año de la primera fecha
'				p_Dia2 - dia de la segunda fecha
'				p_Mes2 - mes de la segunda fecha
'				p_Ano2 - año de la segunda fecha
' Salida:		N/A
' Retorno:		Diferencia en años
' Efectos:		N/A
' Observaciones:	La primera fecha debe ser la más antigua
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''*/
function DimeAnosDiferencia(p_Dia1, p_Mes1, p_Ano1, p_Dia2, p_Mes2, p_Ano2) {
    var intTemp;

	//Comprobación de datos numéricos
    if( isNaN(p_Dia1) || isNaN(p_Mes1) || isNaN(p_Ano1) || 
        isNaN(p_Dia2) || isNaN(p_Mes2) || isNaN(p_Ano2) ) {
            intTemp = 0;
    } else {
		//calcular los años
        intTemp = parseInt(p_Ano2) - parseInt(p_Ano1);
        
        //restar un año en función del mes
        if( parseInt(p_Mes2) < parseInt(p_Mes1) ) {
			intTemp = intTemp - 1;
   
        //si los meses son iguales, restar un año en función del día
        } else {
			if( parseInt(p_Mes2) == parseInt(p_Mes1) ) {
				if( parseInt(p_Dia2) < parseInt(p_Dia1) ) {
					intTemp = intTemp - 1;
				}//if
        	}//if
    	}//if
        
	}//if
	return( intTemp );
}//function



/*''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' 
' Declaración:		DimeDescProvincia()
' Misión:	Devuelve la descripción de la provincia
' Entrada:			p_varIDProvincia - código válido de 1 a 52
' Salida:		    N/A
' Retorno:			Nombre de la provincia
' Efectos:			N/A
' Observaciones:	N/A
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''*/
function DimeDescProvincia( p_varIDProvincia ) {

	var arr_P = new Array(53);
	arr_P[1] = 'ALAVA';
	arr_P[2] = 'ALBACETE';
	arr_P[3] = 'ALICANTE';
	arr_P[4] = 'ALMERIA';
	arr_P[5] = 'AVILA';
	arr_P[6] = 'BADAJOZ';
	arr_P[7] = 'BALEARES';
	arr_P[8] = 'BARCELONA';
	arr_P[9] = 'BURGOS';
	arr_P[10] = 'CACERES';
	arr_P[11] = 'CADIZ';
	arr_P[12] = 'CASTELLON';
	arr_P[13] = 'CIUDAD REAL';
	arr_P[14] = 'CORDOBA';
	arr_P[15] = 'LA CORUÑA';
	arr_P[16] = 'CUENCA';
	arr_P[17] = 'GERONA';
	arr_P[18] = 'GRANADA';
	arr_P[19] = 'GUADALAJARA';
	arr_P[20] = 'GUIPUZCOA';
	arr_P[21] = 'HUELVA';
	arr_P[22] = 'HUESCA';
	arr_P[23] = 'JAEN';
	arr_P[24] = 'LEON';
	arr_P[25] = 'LERIDA';
	arr_P[26] = 'LA RIOJA';
	arr_P[27] = 'LUGO';
	arr_P[28] = 'MADRID';
	arr_P[29] = 'MALAGA';
	arr_P[30] = 'MURCIA';
	arr_P[31] = 'NAVARRA';
	arr_P[32] = 'ORENSE';
	arr_P[33] = 'ASTURIAS';
	arr_P[34] = 'PALENCIA';
	arr_P[35] = 'LAS PALMAS';
	arr_P[36] = 'PONTEVEDRA';
	arr_P[37] = 'SALAMANCA';
	arr_P[38] = 'TENERIFE';
	arr_P[39] = 'CANTABRIA';
	arr_P[40] = 'SEGOVIA';
	arr_P[41] = 'SEVILLA';
	arr_P[42] = 'SORIA';
	arr_P[43] = 'TARRAGONA';
	arr_P[44] = 'TERUEL';
	arr_P[45] = 'TOLEDO';
	arr_P[46] = 'VALENCIA';
	arr_P[47] = 'VALLADOLID';
	arr_P[48] = 'VIZCAYA';
	arr_P[49] = 'ZAMORA';
	arr_P[50] = 'ZARAGOZA';
	arr_P[51] = 'CEUTA';
	arr_P[52] = 'MELILLA';

	var strValor = '';
	if( !isNaN( p_varIDProvincia ) ) {
		if( p_varIDProvincia > 0 && p_varIDProvincia < 53 ) {
			var ind = new Number( p_varIDProvincia );
			strValor = arr_P[ ind ];
		}
	}
	
	return( strValor );
}//function


function DimeDescCodigoPostal( codigo4 )
{
	var arr_PT = new Array(9999);
	arr_PT[1000] = 'LISBOA';
	arr_PT[4000] = 'PORTO';
	arr_PT[4490] = 'POVOA DE VARZIM';

	var strValor = '';
	if( !isNaN( codigo4 ) ) {
		if( codigo4 > 0 && codigo4 < 9999 ) {
			var ind = new Number( codigo4 );
			strValor = arr_PT[ codigo4 ];
		}
	}
	
	return( strValor );
}

/*''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' 
' Declaración:		ValidarCCC(p_Entidad, p_Oficina, p_DC, p_Cuenta)()
' Misión:			Función que valida el codigo cuenta contable.
' Entrada:			p_Entidad: Código entidad.
'					p_Oficina: Código oficina.
'					p_DC: Digito de control.
'					p_Cuenta: Número de cuenta.
' Salida:		    N/A
' Retorno:			true/false
' Efectos:			N/A
' Observaciones:	N/A
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''*/
function ValidarCCC(p_Entidad, p_Oficina, p_DC, p_Cuenta) {
	var Pesos = '01020408051009070306';
	var CCC = p_Entidad + p_Oficina + p_DC + p_Cuenta;
	var EntidadOficina = p_Entidad + p_Oficina;
	var PrimerDigitoOK = false;
	
	//TEMPORAL:primero validar que no sea la cuenta pirata
	//las cuentas piratas tienen todos los dígitos de la ccc iguales
	if( p_Cuenta == '1111111111' ) return(false);
	if( p_Cuenta == '2222222222' ) return(false);
	if( p_Cuenta == '3333333333' ) return(false);
	if( p_Cuenta == '4444444444' ) return(false);
	if( p_Cuenta == '5555555555' ) return(false);
	if( p_Cuenta == '6666666666' ) return(false);
	if( p_Cuenta == '7777777777' ) return(false);
	if( p_Cuenta == '8888888888' ) return(false);
	if( p_Cuenta == '9999999999' ) return(false);
	if( p_Cuenta == '0000000000' ) return(false);

	//primero validar la integridad de los parámetros
	if( isNaN(CCC) || ( (p_DC.length == 0) && (CCC.length < 18) ) || ( (p_DC.length > 0) && (CCC.length != 20) ) ) {
		return(false);
	}//if
	if( EntidadOficina == 0 ) {
		return(false);
	}//if
   
	//Primer digito de control
	var primerDigito = 0;
	var resultadoPrimerDigito = false;
	for( var i = 0; i < 8; i++ ) {
		primerDigito += Pesos.substring((i+2)*2,((i+2)*2)+2) * parseInt(EntidadOficina.charAt(i)-'0');
	}//if
	primerDigito = primerDigito % 11;
	if( !(primerDigito ==0 || primerDigito ==1) ) {
		primerDigito = 11 - primerDigito;
	}//if
	resultadoPrimerDigito = ( primerDigito == (CCC.charAt(8)-'0') );
	
	//Segundo digito de control
	var segundoDigito = 0;
	var resultadoSegundoDigito = false;
	
	for( i = 0; i < 10; i++ ) {
		segundoDigito += Pesos.substring(i*2,(i*2)+2) * (p_Cuenta.charAt(i) - '0')
	}//for
	segundoDigito = segundoDigito % 11;
	segundoDigito = 11 - segundoDigito ;
	if( segundoDigito > 9 )	segundoDigito = 11 - segundoDigito ;
	resultadoSegundoDigito = ( segundoDigito == (CCC.charAt(9)-'0') );

	//Si el codigo de cuenta no es válido mostramos un mensaje
	if (resultadoPrimerDigito == false || resultadoSegundoDigito == false) {
		m_strMensaje = 'Error en alguno de los campos de la cuenta bancaria.';
	}
	return (resultadoPrimerDigito == true && resultadoSegundoDigito == true );
}

/*******************************************************************
Función para mostrar la ayuda de un campo
El objeto que dispare esta función debe tener un atributo "campo"
No hay parámetros.
*******************************************************************/
function mostrarAyuda( nombre, tipo) {
	
	window.open( '../Comun/ayuda.asp?' + tipo + '=' + nombre, 'ayuda', 'resizable=no,scrollbars=yes,toolbar=no,menubar=no,status=no,width=380,height=320');
}//function


function PonerProvincia ( p_oProvincia ) {
	p_oProvincia.disabled = false;
	DimeDescProvincia( p_oProvincia.id );
}



/*******************************************************************
Función para desformatear los capitales. 
Si el usuario mete puntos, yo se los quito.
*******************************************************************/
function CapitalDesformatear( p_objCapital ) {
	if( !NS4 ) {
		if( p_objCapital ) {
			while ( p_objCapital.value.indexOf('.') != -1) {
				p_objCapital.value = p_objCapital.value.replace('.', '');
			}
		}
	}
}

function MostrarVentanaEspera( p_strTexto, p_strRutaRel ) {
	return false;
	/*
	var s;
	if( IE5 || IE4 )
	window.open( p_strRutaRel + 'Comun/VentanaEspera.asp?texto=Espere un momento mientras se cargan los datos de <b>' + p_strTexto + '</b>', 'VentanaEspera', 'scrollbars=no,toolbar=no,menubar=no,status=no,width=480,height=20,top=150,left=150');
	*/
}



/*''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' 
' Declaración:		function validarDocumento()
' Misión:			Validar el NIE
' Entrada:			valor  -  valor del NIE o CIF o NIF
' Salida:		    N/A
' Retorno:			true si es correcto, false si no lo es
' Efectos:			N/A
' Observaciones:	Formatos correctos: L-NNNNNNN-L o L-NNNNNNNN o NNNNNNNN-L
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''*/
function validarDocumento( valor ) {
	
	var strDocument;
	
	if ( valor == "" )return;  // esta en blanco
	if ( valor.length != 9 )return;  //Si no ocupa 9 caracteres ERROR
	
	
	valor = valor.toUpperCase();
	if(esEntero(valor.charAt(0))) {
		// Persona Fisica
		// <8 dígitos><letra adecuada> (NNNNNNNNL)
		return AuxVerificaPersonaFisica(valor.substring(0,8),valor.charAt(8));
	} else {
		var primeraLetra = valor.charAt(0);
		primeraLetra = primeraLetra.toString();		
		if(AuxEstaEnGrupo(primeraLetra,"KLMRXY")) {
			// Personas físicas (extranjeros, menores de edad, ...).
			// <letra><7 dígitos><letra adecuada>  
			
			//Los nuevos NIEs empezarán con las letras "Y" y "Z". 
			//Para la correcta validación de los nuevos documentos hay que sustituir las letras por dígitos de la siguiente forma 
			//Si la primera letra es una "X", se reemplazará la "X" por un "0". Ejemplo: X0078932L --> 00078932L
			//Si la primera letra es una "Y", se reemplazará la "Y" por un "1". Ejemplo: Y0078932X --> 10078932X
			//Si la primera letra es una "Z" (uso futuro, todavía no existen), se reemplazará la "Z" por un "2"
			
			if (primeraLetra.toUpperCase() == "X") {
				strDocument = valor.substring(1,8);
			} else if (primeraLetra.toUpperCase() == "Y") {
				strDocument = valor.substring(0,8).replace('Y','1');
			} else {
				strDocument = valor.substring(1,8);
			}
			    
			return AuxVerificaPersonaFisica(strDocument,valor.charAt(8));
		} else if(AuxEstaEnGrupo(primeraLetra,"ABCDEFGHJNZ")) {
                  // Persona jurídica -> CIF
                  // <letra><7 dígitos><número adecuado>
                  return AuxVerificaPersonaJuridica(valor.substring(1,8),valor.charAt(8),true);
		} else if(AuxEstaEnGrupo(primeraLetra,"PQS")) {
                	// Persona jurídica -> CIF
                  // <letra><7 dígitos><letra adecuada>
                  return AuxVerificaPersonaJuridica(valor.substring(1,8),valor.charAt(8),false);
		} else if(AuxEstaEnGrupo(primeraLetra,"T")) {
                  // Personas físicas: antigua targeta de residente (obsoleto?).
                  return esEntero(valor.substring(1));
		}
		return;
	}
	
	return;
}
	
	
	
/*''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' 
' Declaración:		function esEntero()
' Misión:			Comprobar si un valor es numerico
' Entrada:			p_valor  -  valor que queremos comprobar
' Salida:		    N/A
' Retorno:			true si es correcto, false si no lo es
' Efectos:			N/A
' Observaciones:	N/A
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''*/
function esEntero( p_valor ) {
	
	var intC;
	var strC;
    var digitos = "0123456789";
	for (intC = 0; intC < p_valor.length ; intC++)	{
		strC = p_valor.charAt(intC);
       	if (digitos.indexOf(strC) == -1) {
			return;
	}
	}
    return true;
	}
	


/*''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' 
' Declaración:		function AuxVerificaPersonaFisica()
' Misión:			Comprobar el Número del documento de la persona física
' Entrada:			p_intValor  -  valor del documento
'					p_strLetra  -  letra del documento
' Salida:		    N/A
' Retorno:			true si es correcto, false si no lo es
' Efectos:			N/A
' Observaciones:	Esta es una Función AUXILIAR de la función "validarDocumento()"
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''*/
function AuxVerificaPersonaFisica( p_intValor, p_strLetra ) {
	var aux = 0;
	var i = 0;
	for(i = 0; i < p_intValor.length; i++) {
		aux = aux + p_intValor.charAt(i);
		}
		
	if(!esEntero(aux)) return;
	aux = aux % 23;
	
	var posibles = 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");				
	return p_strLetra == posibles[aux];
	}


	
		
/*''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' 
' Declaración:		function AuxEstaEnGrupo()
' Misión:			Comprobar si la letra del documento está en un determinado grupo
' Entrada:			p_strLetra  -  letra del documento
'					p_strGrupo  -  grupo de letras sobre el que se hace la
'								   comprobación.
' Salida:		    N/A
' Retorno:			true si es correcto, false si no lo es
' Efectos:			N/A
' Observaciones:	Esta es una Función AUXILIAR de la función "validarDocumento()"
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''*/
function AuxEstaEnGrupo(letra,grupo) {	
	return (grupo.indexOf(letra) > -1);	
}
	
	

	
/*''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' 
' Declaración:		function AuxVerificaPersonaJuridica()
' Misión:			Comprobar el documento de la persona Jurídica.
' Entrada:			p_intNumero    -  numero del documento
'					p_strLetra     -  letra del documento
'					p_blnEsNumero  -  indica si el último digito será numero o letra
' Salida:		    N/A
' Retorno:			verdadero o falso
' Efectos:			N/A
' Observaciones:	Esta es una Función AUXILIAR de la función "validarDocumento()"
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''*/
function AuxVerificaPersonaJuridica( p_intNumero, p_strLetra, p_blnEsNumero) {	
	if(!esEntero( p_intNumero )) return;
	if( p_blnEsNumero ) {
		return p_strLetra == AuxCalculaDigito( p_intNumero );
		} else {
		return p_strLetra == AuxCalculaLetra( p_intNumero );
		}
		return;
	}





/*''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' 
' Declaración:		function AuxCalculaDigito()
' Misión:			Calcular el último digito del documento
' Entrada:			p_intNumero    -  numero del documento
' Salida:		    N/A
' Retorno:			un numero entre 0 y 9
' Efectos:			N/A
' Observaciones:	Esta es una Función AUXILIAR de la función "AuxVerificaPersonaJuridica()"
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''*/
function AuxCalculaDigito( p_intNumero ) {
	// numero = c0 c1 c2 c3 c4 c5 c6
	var suma = 0;        
	// c1 + c3 + c5.
	suma = p_intNumero.charAt(1)*1 + p_intNumero.charAt(3)*1 + p_intNumero.charAt(5)*1;
	// c0 + c0 sumado hasta obtener un solo dígito.
	suma = suma + AuxSumaHastaUnDigito(2 * p_intNumero.charAt(0));
	// c2 + c2 sumado hasta obtener un solo dígito.
	suma = suma + AuxSumaHastaUnDigito(2 * p_intNumero.charAt(2));
	// c4 + c4 sumado hasta obtener un solo dígito.
	suma = suma + AuxSumaHastaUnDigito(2 * p_intNumero.charAt(4));
	// c6 + c6 sumado hasta obtener un solo dígito.
	suma = suma + AuxSumaHastaUnDigito(2 * p_intNumero.charAt(6));
	suma = (10 - suma % 10) % 10;	

	return suma;
	
}


		
	
/*''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' 
' Declaración:		function AuxSumaHastaUnDigito()
' Misión:			Suma hasta obtener un num de un digito.
' Entrada:			p_intNumero    -  numero del documento
' Salida:		    N/A
' Retorno:			un numero entre 0 y 9
' Efectos:			N/A
' Observaciones:	Esta es una Función AUXILIAR de la función "AuxCalculaDigito()"
'					En este caso funciona porque lo máximo que le entrara sera 18 (9*2), 
'					para valores mayores deberia mejorarse.
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''*/
function AuxSumaHastaUnDigito( p_intNumero ) {
	p_intNumero = p_intNumero.toString();
	var resultado = 0;
	var i = 0;
	for(i = 0; i < p_intNumero.length; i++) {
		resultado = resultado + p_intNumero.charAt(i)*1;
        	}
	return resultado;
		}




	
/*''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' 
' Declaración:		function AuxCalculaLetra()
' Misión:			Calcula la letra del documento
' Entrada:			p_intNumero    -  numero del documento
' Salida:		    N/A
' Retorno:			una letra
' Efectos:			N/A
' Observaciones:	Esta es una Función AUXILIAR de la función "AuxVerificaPersonaJuridica()"
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''*/
function AuxCalculaLetra( p_intNumero ) {
	switch ( AuxCalculaDigito( p_intNumero ) ) {
		case 1:
			return "A";
			break;
		case 2:
			return "B";
			break;
		case 3:
			return "C";
			break;
		case 4:
			return "D";
			break;
		case 5:
			return "E";
			break;
		case 6:
			return "F";
			break;
		case 7:
			return "G";
			break;
		case 8:
			return "H";
			break;
		case 9:
			return "I";
			break;
		case 0:
			return "J";
			break;
		default:
			return "";
			break;
	}
	return "";
	} 
	
/*''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' 
' Declaración:		 CNum(valor)
' Misión:			Convierte una cadena a numérico con decimales.
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''*/
function CNum(valor){
	
	var valordecimal = 0;
	var ValorLocal;
		
	//Primero reemplazo los '.' por vacio, si es que no es numerico.
	//if (isNaN(valor)){
	//	ValorLocal = valor;
	//}else{
		ValorLocal = new String(valor);
	//}
	
	//ValorLocal = ValorLocal.replace('.',',');
	//Reemplazo las comas por punto pq es el simbolo decimal del JScript
	valordecimal = Math.round(parseFloat( ValorLocal.replace(',','.') ) * 100) / 100;
		
	if ( isNaN(valordecimal)) valordecimal = 0; 
	
	return valordecimal;
}

function PonerError (strDescError,strNombreCampo){
		m_strMensaje = strDescError;
		if (IE4 || IE5){
			elementoMarcado = '';
			marcarElemento( strNombreCampo);
			elementoMarcado = strNombreCampo;
		}else{
			alert(m_strMensaje);
		}
}
	
	
//Función que formatea la matrícula
function FormatRegistrationNumber(objRegistration) {
	
	//Declaración de variables
	var strTemp;
	var intC;
	var intLength;
	var strPatron;
	var strChar;
	
	strPatron = "ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890";
	strTemp = objRegistration.value;
	intLength  = strTemp.length;

	//Pasamos a mayúsculas
	strTemp = strTemp.toUpperCase();

	//Recorremos todos los caracteres
	for (intC=0;intC<=intLength;intC++) {
		//Guardamos el caracter
		strChar = strTemp.substr(intC, 1);

		//Si el caracter está en la cadena lo suprimimos			
		if (strPatron.indexOf(strChar) == -1) {
			while (strTemp.indexOf(strChar) != -1) {
				strTemp = strTemp.replace(strChar, '');
			}
		}
	}	

	objRegistration.value = strTemp;

}	

//Función que formatea la matrícula
function FormatRegistrationNumberPT(objRegistration) {
	
	//Declaración de variables
	var strTemp;
	var intC;
	var intLength;
	var strPatron;
	var strChar;
	
	strPatron = "ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890";
	strTemp = objRegistration.value;
	intLength  = strTemp.length;

	//Pasamos a mayúsculas
	strTemp = strTemp.toUpperCase();

	//Recorremos todos los caracteres
	for (intC=0;intC<=intLength;intC++) {
		//Guardamos el caracter
		strChar = strTemp.substr(intC, 1);

		//Si el caracter está en la cadena lo suprimimos			
		if (strPatron.indexOf(strChar) == -1) {
			while (strTemp.indexOf(strChar) != -1) {
				strTemp = strTemp.replace(strChar, '');
			}
		}
	}	
	//le ponemos el formato XX-XX-XX
	if (strTemp.length == 6)
	{
		strTemp = strTemp.substr(0,2) + "-" + strTemp.substr(2,2) + "-" + strTemp.substr(4,2);
	}
	objRegistration.value = strTemp;

}	


//Función Valida una fecha
function check_date(day,month,year){
	var checkstr = "0123456789";
	var Datevalue = "";
	var DateTemp = "";
	var seperator = ".";
	var leap = 0;
	var err = 0;
	var i;
   err = 0;
     
  /* year is wrong if year = 0000 */
   if (year == 0) {
      err = 20;
   }
   /* Validation of month*/
   if ((month < 1) || (month > 12)) {
      err = 21;
   }
   /* Validation of day*/
   if (day < 1) {
     err = 22;
   }
   /* Validation leap-year / february / day */
   if ((year % 4 == 0) || (year % 100 == 0) || (year % 400 == 0)) {
      leap = 1;
   }
   if ((month == 2) && (leap == 1) && (day > 29)) {
      err = 23;
   }
   if ((month == 2) && (leap != 1) && (day > 28)) {
      err = 24;
   }
   /* Validation of other months */
   if ((day > 31) && ((month == "01") || (month == "03") || (month == "05") || (month == "07") || (month == "08") || (month == "10") || (month == "12"))) {
      err = 25;
   }
   if ((day > 30) && ((month == "04") || (month == "06") || (month == "09") || (month == "11"))) {
      err = 26;
   }
   /* if 00 ist entered, no error, deleting the entry */
   if ((day == 0) && (month == 0) && (year == 00)) {
      err = 0;
   }

   if (err == 0) 
   	return(true);
   else 
      	return(false);
   
}



//Función que retorna el mes en Texto
function DameNumeroAMes(mes){
	
	switch (CNum(mes)){
		case 1:mes = 'Enero';
					break;
		case 2:mes = 'Febrero';
					break;
		case 3:mes = 'Marzo';
					break;
		case 4:mes = 'Abril';
					break;
		case 5:mes = 'Mayo';
					break;
		case 6:mes = 'Junio';
					break;
		case 7:mes = 'Julio';
					break;
		case 8:mes = 'Agosto';
					break;
		case 9:mes = 'Septiembre';
					break;
		case 10:mes = 'Octubre';
					break;
		case 11:mes = 'Noviembre';
					break;
		case 12:mes = 'Diciembre';
					break;
	}	
	return(mes)
}

//Función que pone ceros por la izquiera a una cadena
function ponerCerosIzq (strCadena, intTotalLength ) {

	//Declaración de variables
	var vntTemp;
	var vntValue;
	var intChar;
	var intC;
	
	//Obtenemos la longitud de la cadena
	vntTemp = strCadena.toString();
	vntTemp = vntTemp.length;


	//Comprobamos si la longitud de la cadena es mayor o igual que la longitud total
	if ( CNum(vntTemp) >= CNum(intTotalLength) ) {
		vntValue = strCadena;
	} else {
		
		//Le concatenamos los ceros hasta la longitud prefijada
		intChar = CNum(intTotalLength) - CNum(vntTemp);
		
		//Asignamos
		vntValue = strCadena;
		
		//Concatenamos
		for (intC=1;intC<=intChar;intC++) {
			vntValue = "0" + vntValue;	
		}
		
	}

	//Retornamos el valor
	return vntValue;

}



//Función para generar Errores
function GenerarError2 ( vntElemento, strMsgMessage, strMessage) {
	
	//Declaración de variables
	var objMessage;
	var objElement;
	var domain = "http://" + window.location.toString().split("//")[1].split("/")[0] + "/";
	//multitarificador.reale.es
	if(domain.indexOf('multitarificador.reale.es') > 0 ) {
		var strColor = '#FA2A2A';
	}else{
		if(window.location.toString().indexOf('id_broker=75') > 0 ) {
				var strColor = '#FFE4B1' ;
		}else{
			if(window.location.toString().indexOf('id_broker=72') > 0 ) {
				var strColor = '#FFE4B1' ;
			}else{
				var strColor = '#D29717' ;
			}
		}
	};
	
	
	//Si es un Explorer llamamos a marcarElemento
	if ( !NS4 ) {
		elementoMarcado = vntElemento;
		//Obtenemos la referencia del elemento
		objElement = getObj( vntElemento );
		
		if( objElement.style.backgroundColor.toUpperCase() != strColor ) {
			
			//Si el mensaje viene relleno, lo pintamos
			if (strMessage != '' ) {
				//Obtenemos la referencia del DIV del mensaje
				objMessage = getObj('mensaje');	
				objMessage.innerHTML = strMessage;
			} 
			
			//Pinamos el control y posicionamos la pantalla en el control
			objElement.style.backgroundColor = strColor;
			
			if(!objElement.disabled)
				objElement.focus();
			else
				objElement.scrollIntoView(true);
			
			//Sacamos el alert
			if (strMsgMessage != "") {
				alert(strMsgMessage);
			} else {
				if (strMessage != "" ){
					alert(strMessage);
				} else {
					alert('Error de datos en el campo ' + objElement.getAttribute( 'desc' ) );
				}
			}
		} else {
			objElement.style.backgroundColor = 'white';
			mostrarMensaje( '' );
		}
	} else {
		alert(strMsgMessage);
	}
}


//Resetea a "-- NO TIENE --" una fecha de carnet
function ChangeDriverLicDate(objControl, intSelected){

	//Declaración de variables
	var strName;
	var vntTemp;
	
	vntTemp = objControl.selectedIndex;
	vntTemp = objControl.options[vntTemp].value;
	
	//Si el value = -, entonces inicializamos todos los campos de la fecha
	if (vntTemp == "-"){
		
		//Obtenemos el nombre
		strName = objControl.name;
		
		//ahora nos quedamos con el tipo de figura "_carxxx"
		strName = strName.substr(3, (strName.length - 3));
		
		//Ahora inicializamos los controles
		try{
			window.document.forms['MainForm'].elements['dia' + strName].selectedIndex = intSelected;
		}catch(err){}
		window.document.forms['MainForm'].elements['mes' + strName].selectedIndex = intSelected;
		window.document.forms['MainForm'].elements['ano' + strName].selectedIndex = intSelected;
		
	}
	
}

function Trim(str)
{
	str = str.toString();
	while (1){
			if (str.substring(0, 1) != " "){
				break;
			}
			str = str.substring(1, str.length);
	}
	while (1){
		if (str.substring(str.length - 1,str.length) != " "){
			break;
		}
		str = str.substring(0, str.length - 1);
	}
	return str;
}

function checkname(strNombre,strApellido){
	var redigit=/[a-zA-Z+].*[a-zA-Z+]/;
	var strName = strNombre  + strApellido;
	if (strName.search(redigit)==-1) { 
		return(false);
	}else{
		return(true);
	}
}

//Realiza la conversión entre Kw/Cv y Cv/Kw
function ConvertirPotencia() {
	
	//Declaración de variables
	var Kw;
	var Cv;
	var VALOR_CV_KW = "0.736";	//1Cv = 0.736 Kw
	var resultado;
	var RegExPattern_Kw;
	var RegExPattern_Cv;
	var blnTemp;
	
	//Recuperamos los valores
	Kw = trim2(window.document.forms['MainForm'].kilovatios.value);
	Cv = trim2(window.document.forms['MainForm'].caballos_vapor.value);
	
	RegExPattern_Kw = /^\d*[0-9](|.\d*[0-9]|,\d*[0-9])?$/;
	RegExPattern_Cv = /^\s*\d+\s*$/;
	
	if (Kw == "" && Cv == "") {
		alert('Debe indicar al menos uno de los 2 valores.');	
		return;
	}else if (Kw != "" && Cv != "") {
		alert('Debe indicar un único valor para realizar la conversión.');	
		return;
	}
	
	//Validamos el formato de los Kw
	if (Kw != "" ) {
		blnTemp = RegExPattern_Kw.test(Kw);
		if (blnTemp == false) {
			alert('El formato de los kilovatios no es válido.');	
			return;
		}
	}
	
	//Validamos el formato de los CV
	if (Cv != "" ) {
		blnTemp = RegExPattern_Cv.test(Cv);
		if (blnTemp == false) {
			alert('El formato de los caballos de vapor no es válido. Indique un valor sin decimales.');	
			return;
		}
	}
	
	//Transformacion Kw --> Cv
	if (Kw != "" && Cv == "") {
		//Se reemplazan las comas por puntos
		Kw = Kw.replace(",", ".");
		resultado = Kw/VALOR_CV_KW;
		resultado = Math.round(resultado);	//Hay que redondear el resultado	
		resultado = resultado.toString();
		resultado = resultado.replace(".", ",");
		window.document.forms['MainForm'].caballos_vapor.value = resultado.substring(0,5);
	}
	
	//Transformacion Cv --> Kw
	if (Kw == "" && Cv != "") {
		resultado = Cv * VALOR_CV_KW;
		resultado = Math.round(resultado);	//Hay que redondear el resultado
		resultado = resultado.toString();
		resultado = resultado.replace(".", ",");
		window.document.forms['MainForm'].kilovatios.value = resultado.substring(0,5);
	}
	
}

//Borra los Caballos de vapor en el onKeyPress de los Kilovatios
function DeleteCv() {
	
	//Declaración de variables
	var vntTemp;
	
	vntTemp = trim2(window.document.forms['MainForm'].caballos_vapor.value);
	
	if (vntTemp != "") {
		window.document.forms['MainForm'].caballos_vapor.value = "";	
	}
	
}

//Borra los Kilovatios de vapor en el onKeyPress de los Caballos de vapor
function DeleteKw() {
	
	//Declaración de variables
	var vntTemp;
	
	vntTemp = trim2(window.document.forms['MainForm'].kilovatios.value);
	
	if (vntTemp != "") {
		window.document.forms['MainForm'].kilovatios.value = "";	
	}
}

function ValidarCodClienteSantander(cliente_santanderOf,tipo_documento_tomador){
	
	var vntTemp = window.document.forms['MainForm'].letra_cliente_santanderOf.selectedIndex;
	vntTemp = window.document.forms['MainForm'].letra_cliente_santanderOf.options[vntTemp].value;
	window.document.forms['MainForm'].cliente_santanderOf.value = vntTemp + window.document.forms['MainForm'].num_cliente_santanderOf.value;
	cliente_santanderOf.value = cliente_santanderOf.value.toUpperCase();
	var strClienteBanesto = cliente_santanderOf.value;
	var LETRAS = 'FJ';
	var NUMEROS = '0123456789'
	var letraNIF = strClienteBanesto.substring(0, 1)
	var numerosNIF = strClienteBanesto.substring( 1, strClienteBanesto.length )	
	var blnNumber = true;   
	
	//Comprobamos que tenga 10 caracteres
	if (strClienteBanesto.length!=10){
			m_strMensaje = 'Código cliente incorrecto.';
			GenerarError(window.document.forms['MainForm'].num_cliente_santanderOf.id, m_strMensaje); 
		return;	
	}
	//comprobamos la estructura del código
	for (intC = 0; intC < numerosNIF.length ; intC++)	{
			var strC = numerosNIF.charAt(intC);
      if (NUMEROS.indexOf(strC) == -1) {
      		blnNumber = false;
      }
	}	
		
	if ( LETRAS.indexOf( letraNIF ) == -1  || !blnNumber) {
		m_strMensaje = 'Código cliente incorrecto.';
		GenerarError(window.document.forms['MainForm'].num_cliente_santanderOf.id, m_strMensaje); 
		return;			
		
	}
	//comprobamos que corresponda con el 
	vntTempTipoDocumento = tipo_documento_tomador.selectedIndex;
	vntTempTipoDocumento = tipo_documento_tomador.options[vntTempTipoDocumento].value;
	if ((letraNIF == 'F' &&  vntTempTipoDocumento == 'CIF') || (letraNIF == 'J' &&  vntTempTipoDocumento != 'CIF')){
		m_strMensaje = 'Código cliente no corresponde con nif del tomador.';
		GenerarError(window.document.forms['MainForm'].letra_cliente_santanderOf.id, m_strMensaje); 
		return;		
	}
			
	//Todo bien 
	return true;
}

function changeFocusbyObejctLen(len,objectThis,objectfocus){
 	
 	if (event.keyCode==16 || (event.keyCode==9 && event.shiftKey)){
 		return;
 	};
 
 	var origen = window.document.getElementById(objectThis);
 	if (origen.value.length == len){
		window.document.getElementById(objectfocus).focus();
	}
}