/**
*  @fileOverview
* 
*  Este fichero contiene las funciones JavaScript comunes para toda aplicación.
* 
*  @author
*  @revision  02/07/2008 
*/


//DEF GRUPO DE FUNCIONES1  ///////////////////////////////////////////////////////////////////////////////////////////

/**
* Duda
* 
*/
function MM_swapImgRestore() {
  var i;
  var x;
  var a=document.MM_sr;
  
  for(i=0;a&&i<a.length&&(x=a[i])&&x.oSrc;i++) {
    x.src=x.oSrc;
  }
}

/**
* Duda
* 
*/
function MM_preloadImages() {
  var d=document;
  
  if(d.images) {    
    if(!d.MM_p) {
      d.MM_p=new Array();
    }
    
    var i;
    var j=d.MM_p.length;
    var a=MM_preloadImages.arguments;
    
    for(i=0; i<a.length; i++) {
      if (a[i].indexOf("#")!=0) {
        d.MM_p[j]=new Image;
        d.MM_p[j++].src=a[i];
      }
    }
  }
}

/**
* Duda
* 
*/
function MM_findObj(n, d) {
  var p;
  var i;
  var x;
  
  if(!d) {
    d=document;
  }
  if((p=n.indexOf("?"))>0&&parent.frames.length) {
    d=parent.frames[n.substring(p+1)].document;
    n=n.substring(0,p);
  }
  if(!(x=d[n])&&d.all) {
    x=d.all[n];
  }
  for (i=0;!x&&i<d.forms.length;i++) {
    x=d.forms[i][n];
  }
  for(i=0;!x&&d.layers&&i<d.layers.length;i++) {
    x=MM_findObj(n,d.layers[i].document);
  }
  return x;
}

/**
* Duda
* 
*/
function MM_swapImage() {
  var i;
  var j=0;
  var x;
  var a=MM_swapImage.arguments;
  document.MM_sr=new Array;
  
  for(i=0;i<(a.length-2);i+=3) {
    if ((x=MM_findObj(a[i]))!=null) {
      document.MM_sr[j++]=x;
      if(!x.oSrc) {
        x.oSrc=x.src;
      }
      x.src=a[i+2];
    }
  }
}


//DEF GRUPO DE FUNCIONES2 click sobre tablas  //////////////////////////////////////////////////////////////////

/**
* Duda
* 
*/
function clickTD(td) {
  td.children.tags('A')[0].click();
}

/**
* Duda
* 
*/
function overTD(td) {
  td.font.Color="red";
  td.bgColor="yellow";
  td.children.tags('A')[0].style.bgcolor="red";
}

/**
* Duda
* 
*/
function outTD(td) {
  td.style="boton";
}



// FUNCIONES PARA EL RELOJ DEL BOTON "ENVIAR" EN LOS MODELOS /////////////////////////////////////////////////////////

/**
* Funcion para Mostrar el Reloj cuando se pulsa el boton enviar en los modelos
* 
*/
function mostrar_reloj() { 
	parent.arriba.document.img_reloj.src='../../comun/images/scrollbar1.gif'; 
} 

/**
* Funcion para Ocultar el Reloj cuando se pulsa el boton enviar en los modelos
* 
*/
function ocultar_reloj() {
	if(parent.arriba.document.images.length > 0 ) {
		parent.arriba.document.img_reloj.src='../../comun/images/blanco.gif'; 
 	}
} 

/**
* Funciones para Mostrar la capa del reloj cuando se pulsa el boton enviar en los modelos
* 
*/
function mostrar_capa_reloj() { 
	NS4 = (document.layers) ? 1 : 0;
	if (NS4) {
		parent.arriba.document.layers['reloj'].visibility = "show";
	} else {
		parent.arriba.document.all['reloj'].style.visibility = "visible";
	} 
} 

/**
* Funciones para Ocultar la capa del reloj cuando se pulsa el boton enviar en los modelos
* 
*/
function ocultar_capa_reloj() { 
	NS4 = (document.layers) ? 1 : 0;
	if (NS4) {
		parent.arriba.document.layers['reloj'].visibility = "hide";
	} else {
		parent.arriba.document.all['reloj'].style.visibility = "hidden";
	}
}


// FUNCIONES PARA LA VENTANA DE ERROR ////////////////////////////////////////////////////////////////////////////////

/**
*  Funcion que  incorpora la imagen de la sirena y abre una nueva ventana de error.
* 
*  @param  mensaje Mensaje de error que se muestra en la Ventana.
*/
function error(mensaje) {
	var nueva = window.open ("","errores","width=316,height=100,scrollbars,alwaysRaised");
	nueva.document.open("text/html");
	nueva.document.write("<html><head><title>P?gina de Errores</title>");
	nueva.document.write("<LINK rel=stylesheet href=../comun/modelos.css>");
	nueva.document.write("<style>");
	nueva.document.write("BODY { margin: 0em }");
	nueva.document.write("</style>");

	nueva.document.write("</head>");
	nueva.document.write("<BODY>");
	nueva.document.write("<TABLE width=\"300\" border=\"0\" cellpadding=\"5\" class=\"datos\" cellspacing=\"0\">");
	nueva.document.write("<tr CLASS=\"seccion\"><td  colspan=\"2\">Descripci&oacute;n del Error</td></tr>");
	nueva.document.write("<tr CLASS=\"seccion\"><td  colspan=\"2\" class=\"casillas\">"+ mensaje+ "</td></tr>");
	nueva.document.write("<tr><td width=\"300\" colspan=\"2\"><CENTER>");
    nueva.document.write("<INPUT TYPE=\"BUTTON\" onClick=\"window.close()\"  value=\"   Cerrar   \"  class=\"boton2\" >");
    nueva.document.write("</center>");
	nueva.document.write("</td>");
    nueva.document.write("</tr>");
	nueva.document.write("</table>");
	nueva.document.write("</form>");
	nueva.document.write("</body>");
	nueva.document.write("</html>");
	nueva.document.close();
	nueva.focus();
}

/**
*  Funcion que  tras validar la funcion, envia  muestra de los errores
*/
function muestraVentanaError() {
	
	
	
	
	var nueva = window.open ("","errores1","width=316,height=300,scrollbars,alwaysRaised");
	var estilo   = "fila1" ;
	nueva.document.open("text/html");
	nueva.document.write("<HTML><HEAD><TITLE>P?gina de Errores</TITLE>");
	nueva.document.write("<LINK rel=stylesheet href=../comun/modelos.css>");

	nueva.document.write("<style>");
	nueva.document.write("BODY { margin: 0em }");
	nueva.document.write("</style>");
	nueva.document.write("</HEAD>");
	nueva.document.write("<BODY><FORM>");
	nueva.document.write("<TABLE width=\"300\" border=\"0\" cellpadding=\"5\" class=\"datos\" cellspacing=\"0\">");
	nueva.document.write("<tr CLASS=\"seccion\"><td  colspan=\"2\">Lista de datos obligatorios sin consignar</td></tr>");



	for (j=0;j<arrayErrores.length;j++) {
		
		if (arrayErrores[j]!="") {
			
			nueva.document.write("<TR>");
			nueva.document.write("<TD width=\"20\" class=\"" + estilo + "\">"  +  ( j + 1 )      +  "</TD>");
			nueva.document.write("<TD width=\"280\" class=\"" + estilo + "\">"  + arrayErrores[j] + "</TD>");
			nueva.document.write("</TR>");
			if ( estilo == "fila1" ) {
			   estilo = "fila2" ;
			} else {
			   estilo = "fila1" ;
			}
		}
	}
	
	nueva.document.write("<tr><td  colspan=\"2\"><CENTER>");
	nueva.document.write("<INPUT TYPE=\"BUTTON\" onClick=\"window.close()\"  value=\"   Cerrar   \"  class=\"boton2\" >");
	nueva.document.write("</center></td></tr>");
	nueva.document.write("</table>");
	nueva.document.write("</form>");
	nueva.document.write("</body>");
	nueva.document.write("</html>");
	nueva.document.close();
	
	// Inicializacion de variable.
	inicializaArray();
	camposIncompatibles = false;
	nueva.focus();
	
}

/**
*  Funcion que comprueba si el campo esta relleno, en caso contrario lo guarda en el array de errores
*
* @param    parametro   Cadena de entrada la cual evaluaremos si es la cadena vacia.  
* @param    nombre   Nombre del Error
* @return   {Boolean}  Devuelve si es correto o no que la cadena contenga algun numero
*/
function comprueba(parametro,nombre) {
	// Eliminamos los espacios en blanco del parametro
    var parametroSinEspacios= trimAll(parametro);
	
	if (estaVacia(parametro)) {
		arrayErrores [i] = nombre;
		i++;
		error = true;
	}
}

/**
*  Funcion que lanza la ventana de errores si fuese necesario
* 
*  @param    contieneErrores
*  @param    esPrimeraVez
*/
function ventanaErrores(contieneErrores,esPrimeraVez) {
	if (arrayMensajes.length > 0) {
		muestraVentanaErrores();
	}
}

/**
*  Funcion que lanza la ventana de errores a partir del arrayMensajes y arrayFocos
*
*/
function muestraVentanaErrores() {
	var nueva = window.open ("","ventanaErrores","width=316,height=300,scrollbars,alwaysRaised");
	var estilo   = "fila1" ;
	var j=0;
	var numeroErrores = (arrayMensajes.length);
	
	nueva.document.open("text/html");
	nueva.document.write("<HTML><HEAD><TITLE>P?gina de Errores</TITLE>");
    nueva.document.write("<LINK rel=stylesheet href=../comun/modelos.css>");
	nueva.document.write("<style>");
	nueva.document.write("BODY { margin: 0em }");
	nueva.document.write("</style>");
	nueva.document.write("</HEAD>");
	nueva.document.write("<BODY><FORM>");
	nueva.document.write("<TABLE width=\"300\" border=\"0\" cellpadding=\"5\" class=\"datos\" cellspacing=\"0\">");
	nueva.document.write("<tr CLASS=\"seccion\"><td colspan=\"2\">Lista de ERRORES</td></tr>");
	nueva.document.write("<tr CLASS=\"subseccion\"><td  colspan=\"2\">Pulse en la descripci&oacute;n " +
			"del error para situarse sobre el dato erroneo.</td></tr>");
	
	while( j < numeroErrores ) {
		if (arrayMensajes[j]!="") {
			nueva.document.write("<TR>");
			nueva.document.write("<TD width=\"40\" class=\""+estilo+"\">" +( j + 1 )+"</TD>");
			nueva.document.write("<TD width=\"260\" class=\""+estilo+"\">");
			nueva.document.write("<A href=\"");
			nueva.document.write("JavaScript:opener.focus();");
			nueva.document.write(arrayFocos[j]);
            nueva.document.write("\" alt=\"ir al error\">"); 
			nueva.document.write(arrayMensajes[j]);
			nueva.document.write("</A>");
			nueva.document.write("</TD>");
			nueva.document.write("</TR>");
			if ( estilo == "fila1" ) {
			   estilo = "fila2" ;
			} else {
			   estilo = "fila1" ;
			}
		}
	  j++;
	}
	nueva.document.write("<tr><td width=\"300\" colspan=\"2\"><CENTER>");
    nueva.document.write("<INPUT TYPE=\"BUTTON\" onClick=\"window.close()\"  value=\"   Cerrar   \"  class=\"boton2\" >");
    nueva.document.write("</center></td></tr>");
	nueva.document.write("</table>");
	nueva.document.write("</form>");
	nueva.document.write("</body>");
	nueva.document.write("</html>");
	nueva.document.close();
	nueva.focus();
}

/**
*  Funcion que lanza la ventana de errores a partir del arrayMensajes y arrayFocos
*
*/
function muestra() {
	muestraVentanaErrores();
}



// FUNCIONES DE COMPROBACIONES DE CADENAS ////////////////////////////////////////////////////////////////////////////

/**
*  Funcion que devuelve el primer caracter de una cadena
*
* @param  cadena   Cadena de entrada para obtener su primer caracter
* @return  caracter El primer caracter de la cadena de entrada
*/
function damePrimerCaracter(cadena) {
	var caracter;
	caracter = cadena.substring (0,1);
	return caracter;
}

/**
*  Funcion que comprueba si el numero tiene uno o dos digitos decimales
*
* @param  checkStr   Cadena de entrada  con el digito a evaluar
* @return  l_valido  {Boolean}  Devuelve si es correto o no que los posea una o dos cifras decimales
*/
function esDigitoPositivoDecimal(checkStr) {
	l_valido = (/^\d+$/.test(checkStr))||(/^\d*[\,]\d{1,2}$/.test(checkStr))
	return l_valido;
}

/**
*  Funcion que comprueba si el numero tiene como maximo tres digitos decimales
*
* @param  checkStr   Cadena de entrada  con el digito a evaluar
* @return  l_valido  {Boolean}  Devuelve si es correto o no que los posea tres cifras decimales
*/
function esDigitoPositivoTresDecimal(checkStr) {
	l_valido = (/^\d+$/.test(checkStr))||(/^\d*[\,]\d{1,3}$/.test(checkStr))
	return l_valido;
}

/**
*  Funcion que comprueba si la cadena de entrada es un numero
*
* @param  cadena   Cadena de entrada  con el digito a evaluar
* @return   {Boolean}  Devuelve si es correto o no que la cadena de entrada solo contiene digitos
*/
function esNumerico(cadena) {
	return (/^\d*$/.test(cadena)); 
}

/**
*  Funcion que comprueba si la cadena de entrada contiene algun numero
*
* @param     campo   Cadena de entrada  
* @return   {Boolean}  Devuelve si es correto o no que la cadena contenga algun numero
*/
function contieneNumero(campo) {
	var resultado = false;
	for (var i = 0; i < campo.length; i++) 	{
		var oneChar = campo.substring(i, i+1);
		if (oneChar > "0" && oneChar < "9") {
			resultado = true;
		}
	}
	return resultado;
}

/**
*  Funcion que comprueba si la cadena de entrada  contiene alguna letra
*
* @param     campo   Cadena de entrada  
* @return   {Boolean}  Devuelve si es correto o no que la cadena contenga alguna letra
*/
function contieneLetra(campo) {
  var resultado = false;
  for (var i = 0; i < campo.length; i++)  {
    var oneChar = campo.substring(i, i+1);
    if (oneChar < "0" || oneChar >"9")
    	resultado = true;
  }
  return resultado;
}

/**
*  Funcion que comprueba si la cadena de entrada  es la cadena vacia
*
* @param     parametro   Cadena de entrada  
* @return   {Boolean}  Devuelve si es vacia o no dicha cadena
*/
function estaVacia(parametro) {
	var resultado = false;
	if (parametro == null || parametro == "" )
	{
		resultado = true;
	}
	 return resultado;
}

/**
*  Funcion que convierte a mayusculas el contenido del campo 
*  que se recibe por parametro
*
*  @param     campo	Campo del formulario que se quiere convertir a mayusculas
*/
function convierteAMayusculas(campo) {		
	// Convertimos a mayusculas el valor introducido por el usuario
	document.getElementById(campo.name).value= campo.value.toUpperCase();	
}

// FUNCIONES PARA TRATAMIENTO DE IMPORTES ////////////////////////////////////////////////////////////////////////////

/**
*  Funcion que sustituye puntos por comas en un importe
*
* @param     importe   Importe de entrada  
* @return    Devuelve la cadena del importe ya sustituida.
*/
function sustituyeComaPorPunto(importe) {	
	return sustituyeXporY(importe,',','.')
}

/**
*  Funcion que sustituye comas por puntos en un importe
*
* @param     importe   Importe de entrada  
* @return    Devuelve la cadena del importe ya sustituida.
*/
function sustituyePuntoPorComa(importe) {
	
	return sustituyeXporY(importe,'.',',')
}

/**
*  Funcion que sustituye en la cadena importe, el valor de la subcadena
*  valX por la cadena valY.
*
* @param     importe Cadena de entrada.
* @param     valX Subcadena valX de la cadena importe  
* @param     valY Cadena valY que sustituira a valX dentro de Importe
* @return    Devuelve la cadena del importe ya sustituida.
*/
function sustituyeXporY(importe,valX,valY) {
	var pos = importe.indexOf(valX);
	var l_importe = importe;
	for(var i =0;(i < l_importe.length) && (pos!=-1);i++) {
		l_importe = l_importe.replace(valX,valY)
		pos = l_importe.indexOf(valX);
	}
	return l_importe
}

/**
*  Funcion que formatea una cantidad cuyo separador de decimales es el 
*  punto a el formato que utilizamos normalmente, el punto para los miles y la coma el decimal.
*  es decir el 1234.56 a 1.234,56, redondeando a dos decimales
* 
*  @param	cantidad	Cadena con la cantidad que queremos formatear.
*  @return  Devuelve dicha cantidad con el formato requerido.
*/
function formateaCantidad(cantidad) { 	
	//Redondeo a dos decimales
	nStr= (Math.round(cantidad * 100))/100;

	//Lo convierto en una cadena
	nStr += ''; 
    
	x = nStr.split('.');
    x1 = x[0]; 
	if(x.length > 1) {
		if(x[1].length > 1) {
			x2 =  x[1];
		} else {
			x2 =  x[1]+'0';
		}
	} else {
		x2 = '00';
	}
	
	var rgx = /(\d+)(\d{3})/; 
    while (rgx.test(x1)) { 
        x1 = x1.replace(rgx, '$1' + '.' + '$2'); 
    } 
    return x1+','+ x2; 
} 


// FUNCIONES PARA EL TRATAMIENTO DE FECHAS ///////////////////////////////////////////////////////////////////////////

/**
*  Funcion que comprueba si la fecha de entrada tieme el formato dd/MM/yyyy
*
* @param     fecha  Fecha objeto de la comprobacion 
* @return    Devuelve un boolean que indica si posee o no dicho formato
*/
function esFormatoFechaCorrecto (fecha) {
	return /^(\d{2})\/(\d{2})\/(\d{4})$/.test(fecha);
}

/**
*  Funcion que modifica una fecha con el formato dd/MM/yyyy por el formato yyyy/MM/dd
*
* @param     fechaSP  Fecha objeto de la modidicacion 
* @return    Devuelve la fecha con el nuevo formato.
*/
function getFechaFormatoEspanolAms(fechaSP) {
	var dias = fechaSP.substring(0,2);
	var meses= fechaSP.substring(3,5);
	var annos = fechaSP.substring(6);
	var fecha = new Date(annos,meses-1,dias);
	return fecha.valueOf();
}

/**
*  Funcion que modifica añade a una fecha tantos meses como indique el parametro num
*
* @param     fecha  Fecha objeto de la modidicacion.
* @param     num  	Numero de meses que se añaden a fecha.
* @return    Devuelve la fecha modificada.
*/
function addMonth(fecha,num) {
	dma=fecha.split("/",3);
  	if(dma.length==1) {
        dma=fecha.value.split("-",3);
    }
    ano=eval(dma[2]);
    mes=eval(dma[1])+eval(num);
    dia=eval(dma[0]);
    if(mes>12) {
        if(mes%12!=0) {
            ano=parseInt(ano+(mes/12));
        } else {
            ano=parseInt(ano+(mes/12)-1);
        }
        mes=mes%12;
    }
    if(diaMes(mes,ano)<dia) {
        dia=diaMes(mes,ano);
    }
    if(dia<10) {
        dia="0"+dia;
    }
    if(mes<10) {
        mes="0"+mes;
    }
    if(ano<10) {
        ano="0"+ano;
    }
    if(mes=='00') {
        mes='12';
    }
    
    fechaSumada=String(dia)+"/"+String(mes)+"/"+String(ano);
    return fechaSumada;
}

/**
*  Funcion que devuelve el numero de dias del mes que corresponda 
*  el paramentro de entrada. Ademas se solicita el año para comprobar 
*  si es bisiesto.
*
* @param     mes	Numero del mes que se solicita.
* @param     anno  	Año al que corresponde dicho mes.
* @return    Devuelve el numero de dias que posee el mes.
*/
function diaMes(mes,anno) {
	switch(mes) {
		case 2:
			if (esBisiesto(anno)) {
				return 29;
			} else {
				return 28;
			}
   			break;
  		case 4:
  		case 6:
  		case 9:
  		case 11: 
  			return 30; 
  			break;
  		default: 
  			return 31; 
  			break;
 	}
}

/**
*  Funcion que comprueba si el año que pasamos como parametro de 
*  entrada es o no bisiesto.
*
* @param     anno  	Año que queremos comprobar.
* @return    Devuelve un boolean dependiendo si el año es o no bisiesto.
*/
function esBisiesto(anno) {
	return (!resto(anno,4) && resto(anno,2000));
}


// FUNCIONES MATEMATICAS   ///////////////////////////////////////////////////////////////////////////////////////////

/**
*  Funcion que devuelve el resto de la division entera entre a y b.
*
* @param     a  Numero entero que representa el dividendo.
* @param     a  Numero entero que representa el divisor.
* @return    Devuelve el resto de la division entera.
*/
function resto(a,b) {
	return a-b*Math.floor(a/b); 
}

/**
*  Funcion que devuelve el numero decimal que recibe truncado al numero
*  de decimales indicados
*
* @param     valor    Numero decimal que se quiere truncar.
* @param     digitos  Numero de digitos decimales que se desea poseer.
* @return    Devuelve el valor truncado.
*/
function truncar(valor, digitos) {
	var operador = Math.pow(10,digitos);
	return  parseInt(valor * operador) / operador;
}

/**
*  Funcion que devuelve el numero decimal que recibe redondeado al numero
*  de decimales indicados
*
* @param     valor    Numero decimal que se quiere redondear.
* @param     digitos  Numero de digitos decimales que se desea poseer.
* @return    Devuelve el valor redondeado.
*/
function redondeo(importe, decimales) {
	var resultado = Math.round(importe * Math.pow(10,decimales));
	return resultado/Math.pow(10,decimales);
}


// FUNCIONES PARA EL TRATAMIENTO DE OBJETOS SELECT O COMBO   /////////////////////////////////////////////////////////

/**
*  Funcion que borra las opciones del objeto Tipo Select que recibe de entrada
*
* @param     select   Objeto Select del cual queremos borrar las opciones.  
* @return   Devuelve el obejto sin ninguna de las opciones
*/
function borrarContenidoSelect(select) {
	var i;
	if (select.type=="select-one") {
	   for (i = select.options.length; i >= 0; i--) {
		select.options[i] = null;
	   }
	}
}
/**
*  Funcion que carga en una lista de datos en un combo y 
*  selecciona la opcion que se le pase como parametro de entrada.
*
* @param     p_array    Listado de valores a cargar en el combo.
* @param     ob_combo   Combo en el que deseamos cargar los valores.
* @param     opcion     Opcion que deseamos cargar dentro del combo.
* @return    Devuelve el combo con la lista cargada y la opcion escogida.
*/
function cargarCombo(p_array,ob_combo,opcion) {
	var l_option = new Option("","");
    var selecccionado = 0;
    
	ob_combo.options[ob_combo.options.length] = l_option;
	
	for(var indice = 0;indice<p_array.length;indice+=2)	{
		var l_option = new Option(p_array[indice], p_array[indice+1]);
		ob_combo.options[ob_combo.options.length] = l_option;
		
		if(opcion == p_array[indice+1]) {
            selecccionado = (indice / 2)+1;
            //Seleccionado ser? indice / 2, ya que el array se recorre de dos en dos, le sumo uno por el elemento inicial
		}      
    }			
    ob_combo.options[selecccionado].selected = true
}

/**
*  Funcion que selecciona una opcion dentro del combo
*
* @param     ob_combo   Combo del que deseamos seleccionar el valor
* @param     valor      Valor que se desea seleccionar en el combo.
* @return    Devuelve el combo con la opcion escogida.
*/
function seleccionarOption(ob_combo,valor) {
	var noEncontrado = true;
	var j = ob_combo.options.length;

	while(noEncontrado && j>=1) {
        noEncontrado = !(ob_combo.options[j-1].value == valor);
        if(!noEncontrado) {
            ob_combo.options[j-1].selected = true;
        }
        j--;
    }
}


// MISCELANEA   ///////////////////////////////////////////////////////////////////////////////////////////

/**
*  DUDA
*/
function imprimirPDF() {
     enviar();
}

/**
*  DUDA
*/
function pagar() {
    if( document.forms[0].estado.value == 'validacion') {
        enviar();
    } else {
        parent.abajo.document.forms[1].submit();
    }
}

/**
*  DUDA
*/
function pagarModelosSinFrames() {
    if( document.forms[0].estado.value == 'validacion') {
		enviar();
    } else {
		document.forms[1].submit();
    }
}



/**
* Funcion que comprueba si el campo es un CIF correcto.
* 
* @param   cif  CIF de entrada para la comprobacion.
* @return  {Boolean}  Nos indica si el CIF recibido como parametro de entrada es correcto o no.
*/
function esCIF(cif) {
	var primerCaracter = damePrimerCaracter (cif);
	var resultado;
	primerCaracter = primerCaracter.toUpperCase();
	
	if (primerCaracter =="A" || primerCaracter =="B" || primerCaracter =="C" ||
		primerCaracter =="D" || primerCaracter =="E" || primerCaracter =="F" ||
		primerCaracter =="G" || primerCaracter =="H" || primerCaracter =="I" ||
		primerCaracter =="J" || primerCaracter =="S" || primerCaracter =="P" ||
		primerCaracter =="Q") {
			resultado = true;
	}else{
		resultado = false;
	}
	
	return resultado;
}

/**
* Funcion que comprueba que ademas de que el anagrama no esta vacio que tenga una longitud de 4
* 
* @param  anagrama Anagrama de entrada para la comprobacion
* @param  tipoAnagrama Tipologia del Anagrama de entrada para la comprobacion
*/
function compruebaAnagrama(anagrama,tipoAnagrama) {
	if (estaVacia(anagrama)) {
		arrayErrores [i] = tipoAnagrama;
		i++;
		error = true;
	}
}

/**
* Funcion que enlaza de froma dinamica un ancla de una ventana en otra 
* 
* @param  ancla
*/
function irA(ancla) {
  parent.abajo.document.location.hash=ancla ;
}

/**
 * Establece el foco en la tabla de los requisitos funcionales de la JSF de entrada a PLAGES, cuando el 
 * usuario hace click en el link de 'Requisitos para operar con la plataforma con certificado digital'.
 */
var requisitosVisible= false;
function estableceFoco(){
    if(requisitosVisible){
    	requisitosVisible= false;            	
    }else{                
        // Establecemo el foco en la tabla, si ésta existe (debe existir, de lo contrario 
        // mirar a ver que pasó)
        if(document.getElementById("tablaCertificados")){
            document.getElementById("tablaCertificados").focus();     	
        }
        
    	requisitosVisible= true;
    } 
}

/**
* Funcion que limita el tamaño de caracteres de entrada de un textarea
* 
* @param  field Campo objeto de la comprobacion
* @param  maxlimit Numero maximo de caracteres
* @param  anchoLinea Numero maximo de caracteres por linea
* @param  maxLineas Numero maxima de lineas
*/
function textCounter(field,maxlimit, anchoLinea, maxLineas) {
    if (field.value.length > maxlimit) {
        field.value = field.value.substring(0, maxlimit);
		alert("No se permiten más de "+maxlimit+" caracteres");
     }

	cuentaLineas(field, anchoLinea, maxLineas);

}

function textCounter(field,maxlimit) {
	if (field.value.length > maxlimit){
        field.value = field.value.substring(0, maxlimit);
     }
}


/**
* Funcion que cuenta el numero de lineas de una casilla de texto
* 
* @param  objText Anagrama de entrada para la comprobacion
* @param  longLinea Anagrama de entrada para la comprobacion
* @param  maxLineas Anagrama de entrada para la comprobacion
*/
function cuentaLineas(objText, longLinea, maxLineas) {
	var i=0, j=0;
	var numLineas=1;
	while(i<=objText.value.length) {

		if (objText.value.substring(i,i+1) == "\n") {
			numLineas++;
			j=0;
			i++;
		}

		j++;
		if(j > longLinea)
		{ 
		   numLineas++;
		   j=1;
		}
		i++;
       // alert(j);
    	if(numLineas > maxLineas)
		{
		  alert("Se ha superado el número máximo de lineas permitido. Reduzca el contenido del texto. ");
		  objText.value = objText.value.substring(0,i-2);
		}


	}
	return numLineas;
}

/**
*  Función que recibe dos nombres de casillas que representan dos check
*  en el formulario. El primer check lo marca a seleccionado y el segundo no.
*  
* 
*/

function bloquearDomFiscalOtrosDom(nombreCampoBloqueo,nombreCampoSinBloqueo){
	
	var formulario = document.forms[0];
	
	document.forms[0].elements[nombreCampoBloqueo].checked = true;
    document.forms[0].elements[nombreCampoSinBloqueo].checked = false;
    
}


/**
*  Función que recibe dos nombres de casillas que representan dos check
*  en el formulario. El primer check lo marca a seleccionado y el segundo no.
*  
* 
*/

function bloquearPresentadorSiEsSujPasivo(nombreCampoBloqueo,nombreCampoSinBloqueo){	
	var formulario = document.forms[0];
	formulario.elements[nombreCampoBloqueo].checked = true; 
	formulario.elements[nombreCampoSinBloqueo].checked = false;
}



//  FUNCIONES AÑADIDAS DE LA ELIMINACION EN VALIDACION.JS Y FUNCIONESCOMUNES.JS   ////////////////////////////////////

/**
*  Funcion que comprueba el campo NIF para saber si un sujeto debe rellenar solo el nombre 
*  y el apellido o si debe rellenar la razon social. 
* 
* @param  tipoSujeto 	Tipologia del sujeto al que realizaremos la comprobacion
* @param  nif 		 	Nif del sujeto 
* @param  apellido1  	Primer Apellido del sujeto
* @param  nombre	 	Nombre del sujeto	
* @param  razonSocial	Razon Social del sujeto
* @param  anagrama		Anagrama de la Razon Social del sujeto
*/
function validarSujeto (tipoSujeto,nif, apellido1, nombre, razonSocial,anagrama) {
	tipoNif = "";
	tipoIdentificacion = "";

	var primerCaracter = damePrimerCaracter (nif);
	primerCaracter = primerCaracter.toUpperCase();


	if (primerCaracter>="0" && primerCaracter<="9") {
		tipoIdentificacion = "Nif";
		tipoNif = "Español";
	} else {
		switch (primerCaracter)	{
			case "K":
				tipoIdentificacion = "Nif";
				tipoNif = "Español";
				break;
			case "L":
				tipoIdentificacion = "Nif";
				tipoNif = "Español";
				break;
			case "X":
				tipoIdentificacion = "Nif";
				tipoNif = "Extranjero";
				break;
			case "M":
				tipoIdentificacion = "Nif";
				tipoNif = "Extranjero";
				break;
		}
	}
	// COMPROBAMOS SI ES UN CIF
	if (tipoIdentificacion!="Nif") {
		if (primerCaracter =="A" || primerCaracter =="B" || primerCaracter =="C" ||
		primerCaracter =="D" || primerCaracter =="E" || primerCaracter =="F" ||
		primerCaracter =="G" || primerCaracter =="H" || primerCaracter =="I" ||
		primerCaracter =="J" || primerCaracter =="S" || primerCaracter =="P" ||
		primerCaracter =="Q") {
			tipoIdentificacion = "Cif"
		}
	}

	switch (tipoIdentificacion) {
		case "Nif":
			comprueba (apellido1,'Apellido1 del  ' + tipoSujeto);
			comprueba (nombre,'Nombre  ' + tipoSujeto);
			if (tipoNif =="Español") {
				if ( tipoSujeto == 'Solicitante') {
					if(formulario.igualSolCer == null || !formulario.igualSolCer.checked) {
						comprueba (anagrama,'Anagrama '+ tipoSujeto);
					}
				}
				if ( tipoSujeto!='Solicitante') {
					if(formulario.igualRepCer == null || !formulario.igualRepCer.checked) {
						comprueba (anagrama,'Anagrama '+ tipoSujeto);
					}				
				}


			}
			break;
		case "Cif":
		if (tipoSujeto == 'Representante') {
			comprueba(razonSocial,'El representante tiene que ser una persona física');
		} else {
			if (tipoSujeto == 'Solicitante') {
				comprueba(razonSocial,'Debe consignar la razón social del solicitante');
			}		
		}

			break;
		default:
	}
}

/**
*  Funcion que comprueba si es correcto el Codigo postal
* 
* @param  codigoPostal 		Codigo Postal al que realizaremos la comprobacion
* @param  tipoCodigoPostal 	Tipologia del codigo postal
* @param  codProvincia  	Codigo de la Provincia
*/
function compruebaCodigoPostal(codigoPostal,tipoCodigoPostal,codProvincia) {
	var resultado = false;
	if (!estaVacia(codigoPostal)) {
		if (contieneLetra(codigoPostal)) {
			arrayErrores [i] = "El Código Postal del " + tipoCodigoPostal + " contiene Letras";
			i++;
			error = true;
		}		
	} else {
			arrayErrores [i] = "El Código Postal del " + tipoCodigoPostal + " es obligatorio";
			i++;
			error = true; 
	}
}

/**
*  		DUDA
*/
function abrirVentanaMunicipios(valorProvincia,casilla) {
	url = "../comun/municipios.jsp?provincia=" + valorProvincia +"&casilla=" + casilla;
	if ( valorProvincia != '') {
		var nueva = window.open (url,'Provincias',"width=420,height=212,scrollbars,alwaysRaised");
	} else {
	  alert("Debe seleccionar una provincia antes de realizar la busqueda.");
	}
}


var casProvincia;
var casMunicipio;
var casLocalidad;
/**
*  Función que invoca a la función que carga el valor de la Localidad dependiendo de las casillas
*  que recibe como parametro 
* 
* @param  casillaProvincia 	Número de casilla de la Provincia
* @param  casillaMunicipio 	Número de casilla de la Municipio
* @param  casillaMunicipio 	Número de casilla de la Localidad
*/
function cargarLocalidades(casillaProvincia,casillaMunicipio,casillaLocalidad){ 
	
	casProvincia = casillaProvincia;
	casMunicipio = casillaMunicipio;
	casLocalidad = casillaLocalidad;
	
	setTimeout ('cargaLocalidades()', 500);
}

function cargaLocalidades()
	{   
		recargarCombos([casLocalidad], 'modelos.comun.AjaxComun.dameLocalidades',[$(casProvincia).value,$(casMunicipio).value]);
	}

/**
*  Función que carga el valor de los datos del catastro
*
*/	 
function cargaDatosCatastro(casillaRefCas, casillaFechaDevengo, casillaProvincia, casillaMunicipio, casillaLocalidad,
								casSiglas,casCalle,casNumero,casBloque,casEscalera,casPlanta,casPuerta,numBien){  
	
	// Si se ha seleccionado el check de datos del Catastro, cargamos los diferentes valores en las casillas
	// Si existe algun error a la hora de recuperar los datos del catastro mostraremos un div con el mensaje de error
	var div = 'DivErrorDatosCatastro'+numBien;

	// Cargamos los datos
	cargarCampo('campoErrorDatosCatastro'+numBien,'modelos.comun.AjaxComun.dameParametroDatosCatastro', [$(casillaRefCas).value,$(casillaFechaDevengo).value,'campoErrorDatosCatastro']);
	
	cargarCampo($(casillaProvincia).name,'modelos.comun.AjaxComun.dameParametroDatosCatastro', [$(casillaRefCas).value,$(casillaFechaDevengo).value,'Provincia']);
	cargarCampo($(casSiglas).name,'modelos.comun.AjaxComun.dameParametroDatosCatastro', [$(casillaRefCas).value,$(casillaFechaDevengo).value,'Siglas']);
	cargarCampo($(casCalle).name,'modelos.comun.AjaxComun.dameParametroDatosCatastro', [$(casillaRefCas).value,$(casillaFechaDevengo).value,'Calle']);
	cargarCampo($(casNumero).name,'modelos.comun.AjaxComun.dameParametroDatosCatastro', [$(casillaRefCas).value,$(casillaFechaDevengo).value,'Numero']);
	cargarCampo($(casBloque).name,'modelos.comun.AjaxComun.dameParametroDatosCatastro', [$(casillaRefCas).value,$(casillaFechaDevengo).value,'Bloque']);
	cargarCampo($(casEscalera).name,'modelos.comun.AjaxComun.dameParametroDatosCatastro', [$(casillaRefCas).value,$(casillaFechaDevengo).value,'Escalera']);
	cargarCampo($(casPlanta).name,'modelos.comun.AjaxComun.dameParametroDatosCatastro', [$(casillaRefCas).value,$(casillaFechaDevengo).value,'Planta']);
	cargarCampo($(casPuerta).name,'modelos.comun.AjaxComun.dameParametroDatosCatastro', [$(casillaRefCas).value,$(casillaFechaDevengo).value,'Puerta']);
	cargarCampo($(casillaMunicipio).name,'modelos.comun.AjaxComun.dameParametroDatosCatastro', [$(casillaRefCas).value,$(casillaFechaDevengo).value,'Municipio']);
	
	document.getElementById(div).style.display="block";
	
	casLocalidad = casillaLocalidad;
	casMunicipio = casillaMunicipio;
	casProvincia = casillaProvincia;
		
	setTimeout("cargaLocalidades()",4000);
}


/**
*  Función que carga el valor de los datos del catastro
*
*/	 

	function cargarDatosAutoliquidacion(casillaNumAuto, casillaNifSolicitante, casConcepto, casFechaDevengo, casCompetencia, casImportePrincipal,
			casFecha,casExpediente,numAutoliquidacion){  
		
		// Si se ha seleccionado el check de datos del Catastro, cargamos los diferentes valores en las casillas
		// Si existe algun error a la hora de recuperar los datos del catastro mostraremos un div con el mensaje de error
		var div = 'DivErrorDatosAutoliquidacion'+numAutoliquidacion;
	
		// Cargamos los datos
		cargarCampo('campoErrorAutoliquidacion'+numAutoliquidacion,'modelos.comun.AjaxComun.dameParametroDatosAutoliquidaciones', [$(casillaNumAuto).value,$(casillaNifSolicitante).value, 'campoErrorAutoliquidacion']);
		
		cargarCampo($(casConcepto).name,'modelos.comun.AjaxComun.dameParametroDatosAutoliquidaciones', [$(casillaNumAuto).value,$(casillaNifSolicitante).value, 'concepto']);
		cargarCampo($(casFechaDevengo).name,'modelos.comun.AjaxComun.dameParametroDatosAutoliquidaciones', [$(casillaNumAuto).value,$(casillaNifSolicitante).value, 'fechaDevengo']);
		cargarCampo($(casCompetencia).name,'modelos.comun.AjaxComun.dameParametroDatosAutoliquidaciones', [$(casillaNumAuto).value,$(casillaNifSolicitante).value, 'competencia']);
		cargarCampo($(casImportePrincipal).name,'modelos.comun.AjaxComun.dameParametroDatosAutoliquidaciones', [$(casillaNumAuto).value,$(casillaNifSolicitante).value, 'importePrincipal']);
		cargarCampo($(casFecha).name,'modelos.comun.AjaxComun.dameParametroDatosAutoliquidaciones', [$(casillaNumAuto).value,$(casillaNifSolicitante).value, 'fecha']);
		cargarCampo($(casExpediente).name,'modelos.comun.AjaxComun.dameParametroDatosAutoliquidaciones', [$(casillaNumAuto).value,$(casillaNifSolicitante).value, 'expediente']);
		
		
		document.getElementById(div).style.display="block";
	}
	
	function cargarDatosLiquidacion(casillaNumLiqui, casillaNifSolicitante, casillaNombreSolicitante, casillaAp1Solicitante, casillaAp2Solicitante, casImportePrincipal,
			casillaDemora, casillaParciales, liquidacion){  
		
		// Si se ha seleccionado el check de datos del Catastro, cargamos los diferentes valores en las casillas
		// Si existe algun error a la hora de recuperar los datos del catastro mostraremos un div con el mensaje de error
		var div = 'DivErrorDatosLiquidacion'+liquidacion;
	
		// Cargamos los datos																				
		cargarCampo('campoErrorLiquidacion'+liquidacion,'modelos.comun.AjaxComun.dameParametroDatosLiquidaciones', [$(casillaNumLiqui).value,$(casillaNifSolicitante).value, $(casillaNombreSolicitante).value,$(casillaAp1Solicitante).value, $(casillaAp2Solicitante).value,'campoErrorLiquidacion']);
		
		cargarCampo($(casImportePrincipal).name,'modelos.comun.AjaxComun.dameParametroDatosLiquidaciones', [$(casillaNumLiqui).value,$(casillaNifSolicitante).value, $(casillaNombreSolicitante).value,$(casillaAp1Solicitante).value, $(casillaAp2Solicitante).value,'importePrincipal']);
		cargarCampo($(casillaDemora).name,'modelos.comun.AjaxComun.dameParametroDatosLiquidaciones', [$(casillaNumLiqui).value,$(casillaNifSolicitante).value, $(casillaNombreSolicitante).value,$(casillaAp1Solicitante).value, $(casillaAp2Solicitante).value,'apremio']);
		cargarCampo($(casillaParciales).name,'modelos.comun.AjaxComun.dameParametroDatosLiquidaciones', [$(casillaNumLiqui).value,$(casillaNifSolicitante).value, $(casillaNombreSolicitante).value,$(casillaAp1Solicitante).value, $(casillaAp2Solicitante).value,'ingresosParciales']);
		
		
		document.getElementById(div).style.display="block";
	}
	


/**
 *   Funcion auxiliar de cargaDatosCatastro. Se encarga de recargar el combo de localidades
 *   una vez obtenidos los datos del bien
 *   
 * @param casMunicipio
 * @return
 */
function recargaLocalidades(casMunicipio) {
	
	casMunicipio.focus();
	
}


/**
*  		DUDA
*/
function compruebaAlgunoRelleno() {
	var	camposRepresentante = false;
	var parametro;

	for (var cont =0; cont < arrayRepresentante.length; cont++) {
		if (!camposRepresentante) {
			parametro = arrayRepresentante[cont];
	
			if(!estaVacia(parametro)) {
				camposRepresentante = true;
			}
		}
	}

	return camposRepresentante;
}

/**
*  		DUDA
*/
function compruebaAlgunoRelleno2() {
  	var	camposTitularIngreso = false;
	var parametro2;

	for (var cont =0; cont < arrayTitularIngreso.length; cont++) {
		if (!camposTitularIngreso) {
			parametro2 = arrayTitularIngreso[cont];

			if(!estaVacia(parametro2)){

				camposTitularIngreso = true;
			}
		}
	}

    return camposTitularIngreso;
}


/**
* Funcion que comprueba que todos los datos del sujeto estan rellenos
* 
* @param   nif			Nif del sujeto
* @param   apellido1	Primer apellido del sujeto
* @param   apellido2	Segundo apellido del sujeto
* @param   nombre		Nombre del sujeto
* @param   razonSocial	Razon Social del sujeto
* @param   tipoVia		Tipo de Via del domicilio del sujeto
* @param   nombreVia	Nombre de la via del domicilio del sujeto
* @param   numero		Numero del domicilio del sujeto
* @param   provincia	Provincia del domicilio del sujeto
* @param   municipio	Municio del domicilio del sujeto
* @param   codigoPostal	Codigo Postal del domicilio del sujeto
* @return  {Boolean}  Nos indica si los campos estan todos rellenos o no.
*/
function compruebaSujeto(nif, anagrama, apellido1, apellido2, nombre, razonSocial, tipoVia, nombreVia, numero, provincia, municipio, codigoPostal) {
	var	resultado = true;
	
	if (estaVacia(nif) && estaVacia(anagrama) && estaVacia(apellido1)
	&& estaVacia(nombre) && estaVacia(razonSocial) && estaVacia(tipoVia)
	&& estaVacia(nombreVia) && estaVacia(numero) && estaVacia(provincia)
	&& estaVacia(municipio) && estaVacia(codigoPostal)) {
		return false;
	}		
	return resultado;
}

/**
* Funcion que reemplaza las comas por los puntos en una cadena
* 
* @param   cadena  Cadena que se desea reemplazar.
* @return  La cadena de texto ya reemplazada.
*/
function pasaComaAPunto(cadena) {
	var cadena2;
	cadena2 = cadena.replace(',','.');
	return cadena2;
}

/**
* Funcion que reemplaza los puntos por las comas en una cadena
* 
* @param   cadena  Cadena que se desea reemplazar.
* @return  La cadena de texto ya reemplazada.
*/
function pasaPuntoAComa(cadena) {
	cadena = String(cadena);
	var cadena2;
	cadena2 = cadena.replace('.',',');
	return cadena2;
}

/**
* Funcion que selecciona dentro de una lista, el indice que contiene el valor recibo como parametro.
* 
* @param   lista   Lista de valores.
* @param   valor   Valor buscado.
* @return  La lista con la posicion del valor recibido.
*/
function seleccionarValorLista(lista,valor) {
    for (var i = 0; i < lista.options.length; i++) {
        if (lista.options[i].value == valor ) {
            lista.options.selectedIndex = i;
            // Con o sin esto???                        VAlidacion 701
            // lista.options[i].selected = true;
        }
    }
}

/**
* Funcion que comprueba si la cadena recibida como parametro es un numero.
* 
* @param   valor   Valor a comprobar.
* @return  El valor en caso de ser numerico y si no es asi 0.
*/
function esNumero(valor) {
	var resultado = valor;
	if (isNaN(valor)) {
		return 0;
	}
	return resultado;
}

/**
* Funcion que comprueba el formato de la cadena de entrada es numero correcto.
* 
* @param   valor   Valor a comprobar.
* @return  {Boolean}  Devuelve si el formato de la cadena es correcto o no lo es.
*/
function esFormatoNumericoCorrecto2(cadena) {
	var formatoCorrecto=true;
    var numeroComas = 0;
  
	for (var i=0;i<cadena.length;i++) {
		var oneChar = cadena.substring(i, i+1);   
		if (oneChar ==',') {
			numeroComas++;
    		if (numeroComas >1) {
    			formatoCorrecto = false;
    		}
   		} else {
      		if (oneChar < '0' || oneChar >'9') {
    			formatoCorrecto = false;
    		}
   		}
	}
	return formatoCorrecto;
}

/**
*  Funcion que comprueba el formato de la cadena de entrada es numero correcto.
* 
*  @param   valor   Valor a comprobar.
*  @return  {Boolean}  Devuelve si el formato de la cadena es correcto o no lo es.
*/
function esFormatoNumericoCorrecto(cadena) {
	var formatoCorrecto=true;
	var numeroComas = 0;
	for (var i=0;i<cadena.length;i++) {
		var oneChar = cadena.substring(i, i+1);
		if (oneChar ==',') {
			numeroComas++;
			if (numeroComas >1) {
				formatoCorrecto = false;
			}
		} else {
			if (oneChar < '0' || oneChar >'9') {
				formatoCorrecto = false;
			}
		}
	}
	if (!formatoCorrecto) {
      alert('El valor introducido es '+cadena+' y el formato numerico debe ser del tipo 9999,999');
	}
	return formatoCorrecto;
}


/**
*  Funcion que comprueba el formato de la cadena de entrada es numero correcto.Pero no lanza ningun alert
* 
*  @param   valor   Valor a comprobar.
*  @return  {Boolean}  Devuelve si el formato de la cadena es correcto o no lo es.
*/
function esFormatoNumericoCorrectoSinAviso(cadena) {
	var formatoCorrecto=true;
	var numeroComas = 0;
	for (var i=0;i<cadena.length;i++) {
		var oneChar = cadena.substring(i, i+1);
		if (oneChar ==',') {
			numeroComas++;
			if (numeroComas >1) {
				formatoCorrecto = false;
			}
		} else {
			if (oneChar < '0' || oneChar >'9') {
				formatoCorrecto = false;
			}
		}
	}
	//if (!formatoCorrecto) {
    //  alert('El valor introducido es '+cadena+' y el formato numerico debe ser del tipo 9999,999');
	//}
	return formatoCorrecto;
}



	
/**
*  Funcion que realiza una validacion del nombre o la razon social del solicitante.
* 
*/
function compruebaSolicitante() {
	error = false;
	var nif = parent.abajo.document.forms[0].h1c005_1.value;
	var anagramaSolicitante= parent.abajo.document.forms[0].h1c005_2.value;
	var apellido1Solicitante= escape (parent.abajo.document.forms[0].h1c006_1.value);
 	var apellido2Solicitante= escape (parent.abajo.document.forms[0].h1c006_2.value);
	var nombreSolicitante= escape (parent.abajo.document.forms[0].h1c006_3.value);
	var razonSocialSolicitante= escape (parent.abajo.document.forms[0].h1c006_4.value);
	validarSujeto ('Comprador',nif, apellido1Solicitante,nombreSolicitante, razonSocialSolicitante,anagramaSolicitante);

	if (error) {
		muestraVentanaError();
	}
}

/**
*  Función que controla el chequeado de todas las actuaciones
* 
*/
function controlChecksActuaciones() {
	
		if( document.forms[0].seleccionarTodo.checked) {

			for(var i = 0; i < document.forms[0].numeroAutorizaciones.value;i++) {
				
				var habilitado = eval('document.forms[0].codigo'+i+'.disabled == false');
				if(habilitado) {
					eval('document.forms[0].codigo'+i+'.checked = true');
				}
			}
		}else{
				for(var i = 0; i < document.forms[0].numeroAutorizaciones.value;i++) {
				
				var habilitado = eval('document.forms[0].codigo'+i+'.disabled == false');
				if(habilitado) {
					eval('document.forms[0].codigo'+i+'.checked = false');
				}
			}
		
		}
}

/**
*  Función que comprueba si esta rellena la casilla que recibe como parametro de entrada
* 
*/
function compruebaRellenoEjercicio(casilla) {
 var valor = eval('formulario.'+casilla+'.value');
 if(valor =="") {
  alert("Debe rellenar antes el ejercicio");
 }
}

/**
*  Función que abre la ventana de Descripcion para el codigo que recibe como parametro de entrada
* 
*/
function abrirVentanaDescripcion(codigo) {
		
		url = "../modelo230/descripciones.jsp?codigo=" + codigo;
		var nueva = window.open (url,'descripciones',"width=460,height=190,alwaysRaised");
		nueva.focus();
}



/**
*  Función que elimina el contenido de los campos que contiene el arry de entrada 'campos'
* 
*/	
function limpiaCampos(campos) {
	var numCampos= campos.length;		
	var cont;
	var campoActual;
	for(cont= 0; cont< numCampos; cont++) {
		campoActual= campos[cont];		
		document.getElementById(campoActual).value="";
	}
}

/**
*  Funcion que muestra las capas de los depositantes y/o beneficiarios, en funcion de si el usuario
*  los añadio. Esto ocurre a la hora de la recarga del modelo, una vez ha sido enviado al servlet
*/	
function muestraCapa(tipoSujeto, numSujeto){
	// Si el sujeto es un Depositante		
	if (tipoSujeto== 0){
		// Si el sujeto es el primer depositante
		if(numSujeto== 1){
			document.all("capaGarantizado1").style.display='block';				
			document.all['eliminarGarantizado'].style.display='inline';
			document.all['anadirGarantizado'].style.display='inline';
			// Actualizamos el valor del numero de garantizados extras existentes
			numGarantizados= 1;
		}
		// Si el sujeto es el segundo depositante
		if(numSujeto== 2){
			document.all("capaGarantizado2").style.display='block';
			document.all['eliminarGarantizado'].style.display='inline';
			document.all['anadirGarantizado'].style.display='inline';
			// Actualizamos el valor del numero de garantizados extras existentes
			numGarantizados= 2;
		}
		
		// Si el sujeto es el tercer depositante
		if(numSujeto== 3){
			document.all("capaGarantizado3").style.display='block';
			document.all['eliminarGarantizado'].style.display='inline';
			document.all['anadirGarantizado'].style.display='inline';
			// Actualizamos el valor del numero de depositantes extras existentes
			numGarantizados= 3;
		}
			// Si el sujeto es el cuarto depositante
		if(numSujeto== 4){
			document.all("capaGarantizado4").style.display='block';
			document.all['eliminarGarantizado'].style.display='inline';
			document.all['anadirGarantizado'].style.display='none';
			// Actualizamos el valor del numero de depositantes extras existentes
			numGarantizados= 4;
		}	
		
	}
	
	// Si el sujeto es un beneficiario
	if (tipoSujeto== 1){
		// Si el sujeto es el primer beneficiario
		if(numSujeto== 1){
			document.all("capaPropietario1").style.display='block';				
			document.all['eliminarPropietario'].style.display='inline';
			document.all['anadirPropietario'].style.display='inline';
			// Actualizamos el valor del numero de beneficiario extras existentes
			numPropietarios= 1;
		}
		// Si el sujeto es el segundo beneficiario		
		if(numSujeto== 2){
			document.all("capaPropietario2").style.display='block';
			document.all['eliminarPropietario'].style.display='inline';
			document.all['anadirPropietario'].style.display='inline';
			// Actualizamos el valor del numero de beneficiario extras existentes
			numPropietarios= 2;
		}
				// Si el sujeto es el tercer beneficiario		
		if(numSujeto== 3){
			document.all("capaPropietario3").style.display='block';
			document.all['eliminarPropietario'].style.display='inline';
			document.all['anadirPropietario'].style.display='inline';
			// Actualizamos el valor del numero de beneficiario extras existentes
			numPropietarios= 3;
		}	
					// Si el sujeto es el cuarto beneficiario		
		if(numSujeto== 4){
			document.all("capaPropietario4").style.display='block';
			document.all['eliminarPropietario'].style.display='inline';
			document.all['anadirPropietario'].style.display='none';
			// Actualizamos el valor del numero de beneficiario extras existentes
			numPropietarios= 4;
		}
		
	}	
}

/**
*  Funcion que controla que las casillas de aceptacion no esten ambas seleccionadas
* 
*/
function controlAceptacion(aceptacion) {
	if((aceptacion=='S') && formulario.h1c054.checked) {
		formulario.h1c054.checked = false;
	}
	if((aceptacion=='N') && formulario.h1c053.checked) {
		formulario.h1c053.checked = false;
	}
}

/**
*  Funcion que inicializa el array de errores con todos sus elementos a la cadena vacia.
* 
*/
function inicializaArray () {
	for (j=0; j < arrayErrores.length; j++) {
		arrayErrores[j]="";
	}
	i = 0;
}


/**
*  Funcion que comprueba si el campo esta relleno, en ese caso guarda el campo en el array
* 
*/
function compruebaSiRelleno (parametro,nombre) {
	if (!estaVacia(parametro)) {
		arrayErrores [i] = nombre;
		i++;
		error = true;
	}
}

/**
*  Funcion que a partir de un código de error devuelve un mensaje específico de ese error
* 
*/
function dameMensajeError(error) {
	
    var textoError="";
	
	if (error=="1")	{
		textoError="El Titular del Certificado no consta en el censo de contribuyentes";
	} else if (error=="2") {
		textoError="Debe introducir Apellidos Nombre del Sujeto Pasivo";
	} else if (error=="3") {
		textoError="El Titular del Certificado no es representante del Sujeto Pasivo";
	} else if (error=="4") {
		textoError="El Sujeto Pasivo no consta en el censo de contribuyentes";
	} else if (error=="5") {
		textoError="Debe indicar el tipo de CERTIFICACIÓN que solicita";
	} else if (error=="6") {
		textoError="NIF del Sujeto Pasivo incorrecto";
	} else if (error=="7") {
		textoError="Debe introducir el NIF del Sujeto Pasivo";
	} else if (error=="8") {
		textoError="Error al intentar obtener el certificado de deudas";
	}
	return textoError;
}

/**
*  Funcion que comprueba que los campos del depositante extra que haya anhadido el usuario
* 
*/ 
function compruebaCamposGarantizadosExtras() { 
	// Si esta visible el depositante extra 1, validamos los campos del mismo
	if (document.getElementById("capaGarantizado1").style.display!= "none") {
		// Recuperamos los campos del sujeto pasivo
		var nifGarantizado1          = formulario.h1c101_1.value;
		var anagramaGarantizado1     = formulario.h1c101_2.value;
		var apellido1Garantizado1    = formulario.h1c102_1.value;
		var apellido2Garantizado1    = formulario.h1c102_2.value;
		var nombreGarantizado1       = formulario.h1c102_3.value;
		var razonSocialGarantizado1  = formulario.h1c102_4.value;
	 	var tipoViaGarantizado1      = formulario.h1c103[formulario.h1c103.selectedIndex].text;
		var nombreViaGarantizado1    = escape(trimAll(formulario.h1c104.value));
		var numeroGarantizado1       = escape(trimAll(formulario.h1c105.value));
		var provinciaGarantizado1    = escape(formulario.h1c113[formulario.h1c113.selectedIndex].text);
		var municipioGarantizado1;
		
		if (formulario.h1c112.type == "select-one") {
			municipioGarantizado1    = formulario.h1c112[formulario.h1c112.selectedIndex].text;
		}else {
			municipioGarantizado1    = escape(trimAll(formulario.h1c112.value));
		}
	
		var codigoPostalGarantizado1 = formulario.h1c114.value;
		var codProvinciaGarantizado1 = formulario.h1c113[formulario.h1c113.selectedIndex].value;
		
		comprueba(nifGarantizado1, 'NIF del Depositante 2');			
		validarSujeto ('Depositante 2', nifGarantizado1, apellido1Garantizado1, nombreGarantizado1, razonSocialGarantizado1, anagramaGarantizado1, apellido2Garantizado1);
		comprueba (tipoViaGarantizado1, 'Tipo de V&iacute;a (Calle, Plaza, etc) del Depositante 2');
		comprueba (nombreViaGarantizado1, 'Nombre de la V&iacute;a (Calle, Plaza, etc) del Depositante 2');
		comprueba (numeroGarantizado1, 'N&uacute;mero de la V&iacute;a del Depositante 2');
		comprueba (provinciaGarantizado1, 'Provincia del Depositante 2');
		comprueba (municipioGarantizado1, 'Municipio del Depositante 2');
		compruebaCodigoPostal (codigoPostalGarantizado1, 'Depositante 2', codProvinciaGarantizado1);
	}
	
	// Si esta visible el garantizado extra 2, validamos los campos del mismo
	if (document.getElementById("capaGarantizado2").style.display!= "none") {
		// Recuperamos los campos del sujeto pasivo
		var nifGarantizado2          = formulario.h1c115_1.value;
		var anagramaGarantizado2     = formulario.h1c115_2.value;
		var apellido1Garantizado2    = formulario.h1c116_1.value;
		var apellido2Garantizado2    = formulario.h1c116_2.value;
		var nombreGarantizado2       = formulario.h1c116_3.value;
		var razonSocialGarantizado2  = formulario.h1c116_4.value;
	 	var tipoViaGarantizado2      = formulario.h1c117[formulario.h1c117.selectedIndex].text;
		var nombreViaGarantizado2    = escape(trimAll(formulario.h1c118.value));
		var numeroGarantizado2       = escape(trimAll(formulario.h1c119.value));
		var provinciaGarantizado2    = escape(formulario.h1c127[formulario.h1c127.selectedIndex].text);
		var municipioGarantizado2;
		
		if (formulario.h1c126.type == "select-one"){
			municipioGarantizado2    = formulario.h1c126[formulario.h1c126.selectedIndex].text;
		}else{
			municipioGarantizado2    = escape(trimAll(formulario.h1c126.value));
		}
	
		var codigoPostalGarantizado2 = formulario.h1c128.value;
		var codProvinciaGarantizado2 = formulario.h1c127[formulario.h1c127.selectedIndex].value;
		
		comprueba(nifGarantizado2, 'NIF del Depositante 3');			
		validarSujeto ('Depositante 3', nifGarantizado2, apellido1Garantizado2, nombreGarantizado2, razonSocialGarantizado2, anagramaGarantizado2, apellido2Garantizado2);
		comprueba (tipoViaGarantizado2, 'Tipo de V&iacute;a (Calle, Plaza, etc) del Depositante 3');
		comprueba (nombreViaGarantizado2, 'Nombre de la V&iacute;a (Calle, Plaza, etc) del Depositante 3');
		comprueba (numeroGarantizado2, 'N&uacute;mero de la V&iacute;a del Depositante 3');
		comprueba (provinciaGarantizado2, 'Provincia del Depositante 3');
		comprueba (municipioGarantizado2, 'Municipio del Depositante 3');
		compruebaCodigoPostal (codigoPostalGarantizado2, 'Depositante 3', codProvinciaGarantizado2);
	}
	
	// Si esta visible el garantizado extra 4, validamos los campos del mismo
	if (document.getElementById("capaGarantizado3").style.display!= "none") { 
		// Recuperamos los campos del sujeto pasivo
		var nifGarantizado3          = formulario.h1c129_1.value;
		var anagramaGarantizado3     = formulario.h1c129_2.value;
		var apellido1Garantizado3    = formulario.h1c130_1.value;
		var apellido2Garantizado3    = formulario.h1c130_2.value;
		var nombreGarantizado3       = formulario.h1c130_3.value;
		var razonSocialGarantizado3  = formulario.h1c130_4.value;
	 	var tipoViaGarantizado3      = formulario.h1c131[formulario.h1c131.selectedIndex].text;
		var nombreViaGarantizado3    = escape(trimAll(formulario.h1c132.value));
		var numeroGarantizado3       = escape(trimAll(formulario.h1c133.value));
		var provinciaGarantizado3    = escape(formulario.h1c141[formulario.h1c141.selectedIndex].text);
		var municipioGarantizado3;
		
		if (formulario.h1c140.type == "select-one"){
			municipioGarantizado3    = formulario.h1c140[formulario.h1c140.selectedIndex].text;
		}else{
			municipioGarantizado3    = escape(trimAll(formulario.h1c140.value));
		}
	
		var codigoPostalGarantizado3 = formulario.h1c142.value;
		var codProvinciaGarantizado3 = formulario.h1c141[formulario.h1c141.selectedIndex].value;
		
		comprueba(nifGarantizado3, 'NIF del Depositante 4');			
		validarSujeto ('Depositante 4', nifGarantizado3, apellido1Garantizado3, nombreGarantizado3, razonSocialGarantizado3, anagramaGarantizado3, apellido2Garantizado3);
		comprueba (tipoViaGarantizado3, 'Tipo de V&iacute;a (Calle, Plaza, etc) del Depositante 4');
		comprueba (nombreViaGarantizado3, 'Nombre de la V&iacute;a (Calle, Plaza, etc) del Depositante 4');
		comprueba (numeroGarantizado3, 'N&uacute;mero de la V&iacute;a del Depositante 4');
		comprueba (provinciaGarantizado3, 'Provincia del Depositante 4');
		comprueba (municipioGarantizado3, 'Municipio del Depositante 4');
		compruebaCodigoPostal (codigoPostalGarantizado3, 'Depositante 4', codProvinciaGarantizado3);
	}
	
	// Si esta visible el garantizado extra 5, validamos los campos del mismo
	if (document.getElementById("capaGarantizado4").style.display!= "none") {
		// Recuperamos los campos del sujeto pasivo
		var nifGarantizado4          = formulario.h1c143_1.value;
		var anagramaGarantizado4     = formulario.h1c143_2.value;
		var apellido1Garantizado4    = formulario.h1c144_1.value;
		var apellido2Garantizado4    = formulario.h1c144_2.value;
		var nombreGarantizado4       = formulario.h1c144_3.value;
		var razonSocialGarantizado4  = formulario.h1c144_4.value;
	 	var tipoViaGarantizado4      = formulario.h1c145[formulario.h1c145.selectedIndex].text;
		var nombreViaGarantizado4    = escape(trimAll(formulario.h1c146.value));
		var numeroGarantizado4       = escape(trimAll(formulario.h1c147.value));
		var provinciaGarantizado4    = escape(formulario.h1c155[formulario.h1c155.selectedIndex].text);
		var municipioGarantizado4;
		
		if (formulario.h1c154.type == "select-one") {
			municipioGarantizado4    = formulario.h1c154[formulario.h1c154.selectedIndex].text;
		}else {
			municipioGarantizado4    = escape(trimAll(formulario.h1c154.value));
		}
	
		var codigoPostalGarantizado4 = formulario.h1c156.value;
		var codProvinciaGarantizado4 = formulario.h1c155[formulario.h1c155.selectedIndex].value;
		
		comprueba(nifGarantizado4, 'NIF del Depositante 5');			
		validarSujeto ('Depositante 5', nifGarantizado4, apellido1Garantizado4, nombreGarantizado4, razonSocialGarantizado4, anagramaGarantizado4, apellido2Garantizado4);
		comprueba (tipoViaGarantizado4, 'Tipo de V&iacute;a (Calle, Plaza, etc) del Depositante 5');
		comprueba (nombreViaGarantizado4, 'Nombre de la V&iacute;a (Calle, Plaza, etc) del Depositante 5');
		comprueba (numeroGarantizado4, 'N&uacute;mero de la V&iacute;a del Depositante 5');
		comprueba (provinciaGarantizado4, 'Provincia del Depositante 5');
		comprueba (municipioGarantizado4, 'Municipio del Depositante 5');
		compruebaCodigoPostal (codigoPostalGarantizado4, 'Depositante 5', codProvinciaGarantizado4);
	}
	
	
}		

/**
*   Funcion que devuelve una cadena sin los espacios en blanco anteriores
*   y posteriores.
*/
function trimData(str) { 
	while (''+str.charAt(0) == ' ') {
		str = str.substr(1,str.length-1); 
	}
	while (''+str.charAt(str.length-1) == ' ') {
		str = str.substr(0,str.length-1);
	} 
	return str; 
}

/**
*  Duda
*/
function esconderBotonesSuperiores() {
    objeto = parent.arriba.document.getElementById('botonesLiq');
    if(objeto){
		objeto.style.display="none";
    }        
}


//  FUNCIONES DE scripts/funciones.js

/**
* Funcion muestra la capa cuyo identificador recibe por parametros
*/
function mostrar(capa){
		  document.getElementById(capa).style.display="block";
}

/**
* Funcion oculta la capa cuyo identificador recibe por parametros
*/
function ocultar(capa){
		  document.getElementById(capa).style.display="none";
}

/**
* Funcion oculta la capa cuyo identificador recibe por parametros
*/
function cambia(capa) {
	actual=document.getElementById(capa).style.display;
	if (actual=="block"){
		ocultar(capa);
	} else  {
		mostrar(capa);
	}
}

/**
* Funcion que calcula la letra correspondiente para el nif que recibe por parametros
*/
function letraDNI(n) {
	var d =(n/23);
	d = Math.floor(d);
	var e=d*23;
	var r=n-e;
	var res= "";
	
	if (r==0){
		res = "T";
	}
	if (r==1){
		res = "R";
	}
	if (r==2){
		res = "W";
	}
	if (r==3){
		res = "A";
	}
	if (r==4){
		res = "G";
	}
	if (r==5){
		res = "M";
	}
	if (r==6){
		res = "Y";
	}
	if (r==7){
		res = "F";
	}
	if (r==8){
		res = "P";
	}
	if (r==9){
		res = "D";
	}
	if (r==10){
		res = "X";
	}
	if (r==11){
		res = "B";
	}
	if (r==12){
		res = "N";
	}
	if (r==13){
		res = "J";
	}
	if (r==14){
		res = "Z";
	}
	if (r==15){
		res = "S";
	}
	if (r==16){
		res = "Q";
	}
	if (r==17){
		res = "V";
	}
	if (r==18){
		res = "H";
	}
	if (r==19){
		res = "L";
	}
	if (r==20){
		res = "C";
	}
	if (r==21){
		res = "K";
	}
	if (r==22){
		res = "E";
	}
	
	return res;
}  

/**
* Funcion que comprueba si el NIF es valido.
*/
function compruebaNIF(nif) {	
	
	var error=false;
	
	if(nif.length==0) {		
		return(false);
	}	
	if (nif.length!=9) {
		error=true;
	} else {
		var letras=0;
		var p;

		for (var i=0; i<nif.length; i++) {
			var ch = nif.substring (i, i+1);
      		
      		if ( (ch < "0" || ch > "9") && (ch < "a" || ch > "z") && (ch < "A" || ch > "Z") ){
				error=true;
			}

			if ( (ch >= "a" && ch <= "z") || (ch >= "A" && ch <= "Z") ) {
				if (i==0) {
					p=1;
				}
				if (i==nif.length-1) {
					p=0;
				}
					
				letras++;

				if(i>0 && i<(nif.length-1)){
					error=true;
				}
				letra=ch;
			}  
		}
		   
		if (letras!=1) {
			error=true;
		}
		var dni="";

		if (p==1) {
			dni=nif.substring(1,9);
			dni=letraDNI(dni)+dni;
		} else {
			dni=nif.substring(0,8);	
			dni=dni+letraDNI(dni);
		}
	      
		if (nif.toUpperCase()!=dni) {
			error=true;
		}
    }
	
	if (error){
		return(false);
	}	
	return true;	
}

/**
* Funcion que comprueba si el NIF es valido.
*/ 
function compruebaCIF(txt) { 
	
	if(txt.length==0) {				//por ahora CIF es opcional
		return(false);
	}
	
	var error=false;
    var Suma,Control;
    var Control;
    var n;
    var cif=""; 
    cif=txt.toUpperCase(); 
	var i=cif.length;
	
	if (i!=9) { 
		error=true;
	}
	//Si empieza por una X, es especial para extranjeros y lo tratamos como un nif,
	//sustituyendo la X por un cero.
	if (cif.charAt(0)=='X') {
		//ya no hay que comprobar nada más
		return(compruebaNIF('0'+cif.substr(1)));	
	}
	
	//comprueba que los 7 dígitos inermedios del CIF sean números 0-9
	for (j=1;j<i-1;j++) {
		var c = txt.charAt(j);
		if (c < "0" || c > "9") { 
	  		error=true;
			j=i-1;
	  	}
    }
	
	if(!error) {	       	
		//La letra inicial debe ser una de las posibles
		var posibles="ABCDEFGHKLMPQSX";
		var letra = cif.charAt(0);  
		//(ya sean 1 carácter al inicio y el resto numérico o 1 carácter al ppio, otro al final y el resto numérico)
		if (posibles.indexOf(letra)==-1){
			error=true;
		}

		//suma de los dígitos pares de los 7 intermedios
		Suma= eval(cif.charAt(2))+eval(cif.charAt(4))+eval(cif.charAt(6)); 
				
		for (n=1;n<8;n=n+2) {
			 //operamos con los 7 dígitos intermedios
			Suma=Suma+((2*eval(cif.charAt(n)))%10)+(Math.floor((2*eval(cif.charAt(n)))/10)); 
		}

		//hay error vale false
		if(!error){
			var posibles2= "SP";
			var control="JABCDEFGHI";
			
			if (posibles2.indexOf(letra)==-1){
				 //no se trata de una entidad estatal
		 
				//tratamiento del dígilto de control
				if (isNaN(cif.charAt(8))){
					//dígito de control es una letra
				  	if (cif.charAt(8) != String.fromCharCode(64+(10-(Suma%10)))){
				  		error=true;	
				  	}							
				}

				if ((Suma%10) ==0 ) {
					if (parseInt(cif.charAt(8)) != (Suma%10) && cif.charAt(8)!=control.indexOf(8)) { 
						error=true;
					}
				} else {
					if (parseInt(cif.charAt(8)) != (10 - (Suma%10))&& cif.charAt(8)==control.indexOf(8)) { 
						error=true;
					}
				}
			} else {
				//Control tipo letra en los casos especiales (comienzo en S o P)
				if (cif.charAt(8) != String.fromCharCode(64+(10-(Suma%10)))){
					error=true;
				}
			} 
			
			if(!error)
				return true;
			else
				return false;
		}
		else
			return false;
	}				   
	else
		return false;

}

/**
*  Funcion que comprueba si el numero o codigo de identificacion es correcto.
*/ 
function IDFiscal(txt) {
	var conf=false;
	conf=compruebaNIF(txt);
	 
	if (!conf){
		conf=compruebaCIF(txt);
	}
	 
	if (!conf) {
		alert("El número o código de identificación introducido no es correcto.");
		document.form1.dni.value="";
	}
}

/**
*	DUDA
*/ 
function puntos(number) {
	
	numberstring ="";
	var j=0 ;
	var i=0;
	while (number >= 1) { 
		numberstring = (Math.round(number-0.5) % 10) + numberstring;
	    number= number / 10;
	    j++;
	    if (number >= 1 && j==3) { 
			numberstring = "." + numberstring;
			j=0;
		}
	    i++;
	}
	
	numberstring=numberstring;
	return (numberstring);
}

/**
*	Funcion que convierte a texto la parte entera de un numero.
*/ 
function entera(texto){

    var texto2="";
	var x=texto.indexOf(",");
    if (x==-1) {
		x=texto.indexOf(".");
    }
    
    if (x==-1) {		
	    texto2=texto;
    } else {
     	for(i=0;i<x;i++)
	      texto2=texto2+texto.charAt(i);  
	}
	return (texto2);
}

/**
*	Funcion que convierte a texto la parte decimal de un numero.
*/ 
function decimal(texto){

	var texto2="";
	var x=texto.indexOf(",");
	var y=texto.length;
	var z;
	
    if (x==-1) {
		x=texto.indexOf(".");
    }
    if (x==-1){		
		texto2="";
    } else {
		if (x+3>y){
			var z=y;
		} else {
			z=x+3;
	   		for(i=x+1;i<z;i++){
		   		texto2=texto2+texto.charAt(i); 
	   		} 
	   }
	return (texto2);
	}
}

/**
*	Funcion que convierte un numero decimal a una cantidad en euros formateada correctamente.
*/ 
function puntoseuros(texto){

	var tentera=entera(texto);
	var tdecimal=decimal(texto);
	var resultado=puntos(tentera);
	if (tdecimal!=""){
		resultado=resultado+","+tdecimal;
	}
	return (resultado);
}

/**
*	Funcion que convierte un numero decimal separado por punto, 
* 	a otro separado por coma.
*/
function puntocoma(numero){

	var resul="";
	var x=numero.indexOf(".");
	var y=numero.length;
    if (x==-1) {
	    resul=numero;
    } else {
		for(i=0;i<x;i++) {
		   resul=resul+numero.charAt(i);
		} 
		resul=resul+",";
 		for(i=x+1;i<y;i++) {
		   resul=resul+numero.charAt(i);
 		} 
	}
	return resul;	
}

/**
*	Funcion que convierte un numero decimal separado por coma, 
* 	a otro separado por punto.
*/
function comapunto (numero){

	var resul=""
	var x=numero.indexOf(",")
	var y=numero.length
    if (x==-1)
	    resul=numero;
	else {
		for(i=0;i<x;i++)
		   resul=resul+numero.charAt(i); 
		resul=resul+".";
 		for(i=x+1;i<y;i++)
		   resul=resul+numero.charAt(i); 
	}
	return resul;	
}


//  FUNCIONES DE scripts/ventanas.js

/**
*	Funcion que carga en una ventana de web CEH
*/
function ventana_webceh(url) {
	window.opener.document.location="http://www.juntadeandalucia.es/economiayhacienda/"+url;
	self.blur();
}

/**
*	Funcion que abre una ventana para que se elija un documento de una lista
*/
function AbrirVentana(url,nombre,winwidth,winheight) {
	x=((screen.width)-winwidth)/2;
	y=((screen.height)-winheight)/2;
	if (url=="#") { 
		alert("Por favor, elija un documento de la lista desplegable");
	} else{
		NewWindow=window.open(url,nombre,'left='+x+',top='+y+',toolbar=no,location=no,directories=no,status=no,menubar=no,scrollbars=no,resizable=yes,copyhistory=no,width='+winwidth+',height='+winheight)
	}
}

/**
*	Funcion que abre una ventana con scroll
*/
function AbrirVentana_scroll(url,nombre,winwidth,winheight) {
    x=((screen.width)-winwidth)/2;
	y=((screen.height)-winheight)/2;
	NewWindow=window.open(url,nombre,'left='+x+',top='+y+',toolbar=no,location=no,directories=no,status=no,menubar=no,scrollbars=yes,resizable=yes,copyhistory=no,width='+winwidth+',height='+winheight);
}

/**
*	Funcion que abre una ventana con scroll y barra
*/
function AbrirVentana_scroll_barras(url,nombre,winwidth,winheight) 
{
    x=((screen.width)-winwidth)/2;
	y=((screen.height)-winheight)/2-50;
	NewWindow=window.open(url,nombre,'left='+x+',top='+y+',toolbar=yes,location=no,directories=no,status=yes,menubar=no,scrollbars=yes,resizable=yes,copyhistory=no,width='+winwidth+',height='+winheight);
}

/**
*	Funcion que abre una ventana con sun grafico
*/
function Abre_ventana(titulo,ruta,ima,winwidth,winheight) {

	ima2=ruta+ima; 
    x=((screen.width)-winwidth)/2;
	y=((screen.height)-winheight)/2;

 	var ventana = window.open('','esta','width='+winwidth+',height='+winheight+',left='+x+',top='+y+',scrollbars=yes');
	ventana.document.writeln("<HTML>"+"<HEAD>"+"<title>" + titulo + "</title>"+"</HEAD>"+"<body bgcolor='#ffffff' leftmargin='0' topmargin='3' marginwidth='0' marginheight='3' onLoad='self.focus()'>" +"<center>"+"<IMG src='"+ima2+"' >"+"<form>"+"<div align='center'>"+"<INPUT TYPE=button VALUE=Cerrar onClick='window.close()'; NAME='button'>"+"</div>"+"</form>"+"</center>"+"</BODY>"+"</HTML>");
	ventana.document.close();
}

//  FUNCIONES DE generacion094/generacion094.js

/**
*	Funcion que calcula el total de liquidaciones correctas
*/
function calculaTotalLiquidacionesCorrectas() {
	
	var totalLiquidaciones = 0;
	var checks = '';
	if($('formulario:liquidaciones').getElementsByTagName('input').type = 'checkbox') {		
		checks = $('formulario:liquidaciones').getElementsByTagName('input');
	}
	
	var listaChecks = $A(checks);	
	$j.each(listaChecks, function (i,check){
							   	if(check.checked){
									totalLiquidaciones ++;	
								}
							   });
	$('formulario:totalLiquidacionesSeleccionadas').value=totalLiquidaciones;
	
}

/**
*	DUDA
*/
function calculaTotalIngresarCorrectas(){
	
	var totalIngresar = new Number(0.0);
	var checks = '';
	var idHidden = '';
	if($('formulario:liquidaciones').getElementsByTagName('input').type = 'checkbox'){
		checks = $('formulario:liquidaciones').getElementsByTagName('input');
	}
	var listaChecks = $A(checks);
	
	$j.each(listaChecks,function (i,check){						   
							   	if(check.checked){
									idHidden = check.id.replace('checkBoxLiquidaciones','hiddenImporte');
									totalIngresar = totalIngresar + (new Number ($(idHidden).value));
								}
							   });
	
	$('formulario:totalIngresarSeleccionadas').value= formateaCantidad(totalIngresar);
	
}

/**
*	Funcion imprimir para el 094
*/
function imprimir094() {
	
	var modelo = $('formularioPago:modeloGenerado').value;
	var version =$('formularioPago:versionGenerado').value ;
	var numeroDocumento =$('formularioPago:numeroDocumentoGeneradoEncriptado').value ;
	
	var usuario=$('formularioPago:usuario').value;
	var fechaDocumento=$('formularioPago:fechaDocumento').value;
	var token = $('TOKEN').value;

	var URL = "../visorPDFWEB?modelo="+modelo+"&version="+version+"&numeroDocumento="+numeroDocumento+"&usuario="+usuario+"&fechaDocumento="+fechaDocumento+"&TOKEN="+token;
	var windowImprimir = window.open(URL,'','toolbar=0,resizable=no,top=0,left=0,width='+(screen.width-50)+',height='+(screen.height-100)); 

}

//  FUNCIONES DE /js/funcionesVarias.js

/**
*	Funcion que elimina todos los espacios en blanco 
* 	del texto que recibe por parámetro.
*/
function trimAll(sString) {
    while(sString.substring(0,1)== ' '){
        sString= sString.substring(1, sString.length);
    }
  
    while(sString.substring(sString.length-1, sString.length)== ' ') {
        sString= sString.substring(0, sString.length-1);
    }
    
    return sString;
}

// FUNCIONES DE /SURWEB/web/consultas/oficinasLiquidadoras/mapaGoogle.js

/**
*  Funcion que muestra dentro del div indicado en el argumento de entrada 
*  'mapa', el mapa correspondiente a Elemento
* 
*  @param	localizacion 						Elemento coordenadas (latitud,longitud) que ubican a Elemento en un mapa de GoogleMaps
*  @param	marcador_Elemento_en_Mapa 			Variable que se emplea para ubicar un marcador que señale la ubicación de Elemento en el mapa
*  @param	texto_informacion_marcador_Elemento	Texto que se muestra asociado al marcador en el mapa sobre Elemento
*  @param	iconoGraficoElemento				Gráfico que se muestra en el icono del marcador para mostrar la ubicación de Elemento en el mapa
*  @param	mapa								Contiene el DIV que mostrará el mapa de Google Maps				
*/
function pintarElemento(localizacionElemento,
                        marcador_Elemento_en_Mapa,texto_informacion_marcador_Elemento,iconoGraficoElemento,
                        mapa){
								
		// centramos el mapa en la ubicación de Elemento
		mapa.setCenter(localizacionElemento, 15);
		mapa.addControl(new GLargeMapControl());
		mapa.addControl(new GMapTypeControl());	
		// creamos un marcador personalizado para indicar en el mapa la ubicación exacta de Elemento
		marcador_Elemento_en_Mapa = new GMarker(localizacionElemento,new GIcon(G_DEFAULT_ICON,iconoGraficoElemento));			
		// ahora vamos a asociar enlaces de forma que cuando se pulsa el enlace de localización de Elemento junto al mapa(a su izda) 
		// se destaque frente al de el resto de elementos			   		
		estableceMarcadorLateral(texto_informacion_marcador_Elemento,marcador_Elemento_en_Mapa);			
		// añadimos un escuchador de eventos para el marcador
		GEvent.addListener(marcador_Elemento_en_Mapa, "click", function() {
																	       marcador_Elemento_en_Mapa.openInfoWindowHtml(texto_informacion_marcador_Elemento);
																	      }
						  );								  								  								  
		// mostramos el marcador en el mapa
		mapa.addOverlay(marcador_Elemento_en_Mapa);							      							      
		// agregamos un texto indicativo flotante sobre el marcador
		marcador_Elemento_en_Mapa.openInfoWindowHtml(texto_informacion_marcador_Elemento); 
		return true;            						
}

/**
*  Funcion elimina los enlaces asociados a Elemento ya que no ha podido ser localizado y no tiene sentido mostrarlos
* 
*  @param	IdElemento				Identificador HTML del enlace visual situado dentro de la tabla con datos pertenecientes 
*                   				a Elemento, que muestra el div que ubica a Elemento
*  @param	enlaceElemento 			Identificador HTML del enlace visual situado a la izda del DIV que señala a Elemento en el mapa 		
*/
function borrarElemento(IdElemento,enlaceElemento){
		// ocultamos la visualización de los enlaces que muestran a Elemento puesto que está no ha sido posible ubicarlo en el mapa
		if(IdElemento == 'OOLL'){
			document.getElementById(IdElemento).getElementsByTagName("tr")[5].style.display="none";
		} else if(IdElemento == 'Banco'){
		    document.getElementById(IdElemento).getElementsByTagName("tr")[3].style.display="none";							              
		}
		document.getElementById(enlaceElemento).style.display="none";
		return false;
}

/**
*	Funcion oculta el div que contiene el mapa puesto que ningún Elemento ha sido 
* 	localizado y, por tanto, no tiene sentido mostrarlo
* 
*  @param	seccionContenedora		Identificador HTML de la sección que contiene al div que muestra el mapa
*/
function borrarDIVMapa(seccionContenedora) {
		// ocultamos la visualización del DIV que contiene el mapa
		document.getElementById(seccionContenedora).style.display="none"; 
}

/**
*	Funcion que activa el enlace asociado a Elemento que está a la izda del DIV cuya misión es señalar a Elemento en el mapa
* 	Hay que señalar que las variables 'marcadorEnlaceOOLL' y 'marcadorEnlaceBanco' referencian en el código HTML de 'index.jsp'
* 	los enlaces ubicados a la izda del div del contiene el mapa y sirven para destacar en el mapa la ubicación de un 
* 	Elemento concreto(OOLL,Banco,...)
* 
*  @param	texto_informacion_marcador_Elemento		Texto con el que determinamos qué marcador pertenece a qué Elemento 
*  @param	marcador_Elemento_en_Mapa				Marcador de Elemento en el mapa
* 
*/
function estableceMarcadorLateral(texto_informacion_marcador_Elemento,marcador_Elemento_en_Mapa){
		
		cad = String(texto_informacion_marcador_Elemento);
		if(cad.indexOf("Oficina Tributaria") != -1) {
			marcadorEnlaceOOLL = marcador_Elemento_en_Mapa;				
		} 
        if(cad.indexOf("Entidad Bancaria") != -1) {
		    marcadorEnlaceBanco = marcador_Elemento_en_Mapa;
		} 	
}

/**
*	Funcion que muestra dentro del div indicado en el argumento de entrada 'mapa', el mapa correspondiente a 'direccionOOLL' y 
* 	'direccionBanco'
* 
*  @param	direccionElemento						Dirección de Elemento 
*  @param	IdElemento								Identificador de Elemento
*  @param	enlaceElemento							Enlace HTTP que muestra en el div a Elemento
*  @param	imagenIconoElemento						Imagen PNG que se muestra como icono gráfico indicando la ubicación de 
* 													elemento en el div
*  @param	seccion									Identificador del DIV que muestra el mapa dentro del código HTML. Es necesario puesto que cuando                           		       
* 													no se localiza la OOLL ni la Entidad Bancaria Colaboradora no tiene sentido mostrar dicho DIV
*  @param	codificadorGeografico					Variable que contiene el objeto que convierte direcciones por latitudes-longitudes
*  @param	mapa									Contiene el DIV que mostrará el mapa de Google Maps
*  @param	marcador_Elemento_en_Mapa				Apuntador con forma de "gota de agua invertida" que señala en el mapa la ubicación de la OOLL
*  @param 	texto_informacion_marcador_Elemento		Texto que se muestra asociado al marcador en el mapa sobre la OOLL
*/
function muestraMapa(direccionElemento,IdElemento,enlaceElemento,imagenIconoElemento,
                     seccion,
                     codificadorGeografico,
                     mapa,
                     marcador_Elemento_en_Mapa,
                     texto_informacion_marcador_Elemento) {
    	    
	// llamamos con la dirección de Elemento a la función que calcula la latitud 
	// y longitud de un ubicación en base a su dirección postal
	codificadorGeografico.getLatLng( direccionElemento,                                             
							function(localizacionElemento) {    
							// evaluamos si se encontró Elemento						                     
								if (!localizacionElemento) {      
									// NO se encuentra Elemento
									borrarElemento(IdElemento,enlaceElemento); 
									//borramos los enlaces relacionados con Elemento	
							  	   	if(IdElemento=='OOLL'){ 
							  	   		//si el Elemento en cuestión es la OOLL, marcamos dicho Elemento como no localizado
							  	   		OOLL_localizadaConExito = false;
							  	   	}
							  	   	if(IdElemento=='Banco'){
							  	   		//si el Elemento en cuestión es el Banco, marcamos dicho Elemento como no localizado
							  	   		Banco_localizadoConExito = false;
							  	   	}
							  	   	continuarEjecucion(); 
							  	   	// llamamos a este método para sincronizar los resultados de localización de los Elementos
							  	    // buscados. En caso de que ninguno hubiese sido localizado, se ocultará el DIV del mapa		
							  		} else {  
							  			// SI se encuentra Elemento
							       		pintarElemento(localizacionElemento,marcador_Elemento_en_Mapa,
							                      texto_informacion_marcador_Elemento,imagenIconoElemento,
							                      mapa);
							  		}               					  			  
							}  
						  );
}

/**
*	Funcion se encarga de ocultar el DIV en el caso de que no haya ningún elemento que mostrar en el mapa
*/
function continuarEjecucion() {	
	if(OOLL_localizadaConExito == false && Banco_localizadoConExito == false) { 
		// si no fue localizado ningún Elemento
		borrarDIVMapa("campoMapa"); //ocultamos el DIV
	} 
}

//	FUNCIONES DE busquedas.js

/**
*	DUDA busquedas.js
*/
// JavaScript Document

  <!-- Hide from old browsers

	/******************************************
	* Find In Page Script -- Submitted/revised by Alan Koontz (alankoontz@REMOVETHISyahoo.com)
	* Visit Dynamic Drive (http://www.dynamicdrive.com/) for full source code
	* This notice must stay intact for use
	******************************************/

//  revised by Alan Koontz -- May 2003

var TRange = null;
var dupeRange = null;
var TestRange = null;
var win = null;

//  SELECTED BROWSER SNIFFER COMPONENTS DOCUMENTED AT
//  http://www.mozilla.org/docs/web-developer/sniffer/browser_type.html

var nom = navigator.appName.toLowerCase();
var agt = navigator.userAgent.toLowerCase();
var is_major   = parseInt(navigator.appVersion);
var is_minor   = parseFloat(navigator.appVersion);
var is_ie      = (agt.indexOf("msie") != -1);
var is_ie4up   = (is_ie && (is_major >= 4));
var is_not_moz = (agt.indexOf('netscape')!=-1)
var is_nav     = (nom.indexOf('netscape')!=-1);
var is_nav4    = (is_nav && (is_major == 4));
var is_mac     = (agt.indexOf("mac")!=-1);
var is_gecko   = (agt.indexOf('gecko') != -1);
var is_opera   = (agt.indexOf("opera") != -1);

//  GECKO REVISION

var is_rev=0
if (is_gecko) {
temp = agt.split("rv:")
is_rev = parseFloat(temp[1])
}

//  USE THE FOLLOWING VARIABLE TO CONFIGURE FRAMES TO SEARCH
//  (SELF OR CHILD FRAME)

//  If you want to search another frame, change from "self" to
//  the name of the target frame:
//  e.g., var frametosearch = 'main'

//var frametosearch = 'main';
var frametosearch = self;

function search(whichform, whichframe) {
	
	//  TEST FOR IE5 FOR MAC (NO DOCUMENTATION)
	
	if (is_ie4up && is_mac) return;
	
	//  TEST FOR NAV 6 (NO DOCUMENTATION)
	
	if (is_gecko && (is_rev <1)) return;
	
	//  TEST FOR Opera (NO DOCUMENTATION)
	
	if (is_opera) return;
	
	//  INITIALIZATIONS FOR FIND-IN-PAGE SEARCHES
	
	if(whichform.findthis.value!=null && whichform.findthis.value!='') {
	
	       str = whichform.findthis.value;
	       win = whichframe;
	       var frameval=false;
	       if(win!=self) {
	
	       frameval=true;  // this will enable Nav7 to search child frame
	       win = parent.frames[whichframe];
	}
	    
	}
	
	else return;  //  i.e., no search string was entered
	
	var strFound;
	
	//  NAVIGATOR 4 SPECIFIC CODE
	
	if(is_nav4 && (is_minor < 5)) {
	   
	  strFound=win.find(str); // case insensitive, forward search by default
	
	//  There are 3 arguments available:
	//  searchString: type string and it's the item to be searched
	//  caseSensitive: boolean -- is search case sensitive?
	//  backwards: boolean --should we also search backwards?
	//  strFound=win.find(str, false, false) is the explicit
	//  version of the above
	//  The Mac version of Nav4 has wrapAround, but
	//  cannot be specified in JS
	 
	        }
	
	//  NAVIGATOR 7 and Mozilla rev 1+ SPECIFIC CODE (WILL NOT WORK WITH NAVIGATOR 6)
	
	if (is_gecko && (is_rev >= 1)) {
	   
	    if(frameval!=false) win.focus(); // force search in specified child frame
	    strFound=win.find(str, false, false, true, false, frameval, false);
	
	//  The following statement enables reversion of focus 
	//  back to the search box after each search event 
	//  allowing the user to press the ENTER key instead
	//  of clicking the search button to continue search.
	//  Note: tends to be buggy in Mozilla as of 1.3.1
	//  (see www.mozilla.org) so is excluded from users 
	//  of that browser.
	
	    if (is_not_moz)  whichform.findthis.focus();
	
	//  There are 7 arguments available:
	//  searchString: type string and it's the item to be searched
	//  caseSensitive: boolean -- is search case sensitive?
	//  backwards: boolean --should we also search backwards?
	//  wrapAround: boolean -- should we wrap the search?
	//  wholeWord: boolean: should we search only for whole words
	//  searchInFrames: boolean -- should we search in frames?
	//  showDialog: boolean -- should we show the Find Dialog?
	
	}
	
	 if (is_ie4up) {
	
	  // EXPLORER-SPECIFIC CODE revised 5/21/03
	
	  if (TRange!=null) {
		  
	   TestRange=win.document.body.createTextRange();
	  
	   if (dupeRange.inRange(TestRange)) {
	
	   TRange.collapse(false);
	   strFound=TRange.findText(str);
	    if (strFound) {
	        //the following line added by Mike and Susan Keenan, 7 June 2003
	        win.document.body.scrollTop = win.document.body.scrollTop + TRange.offsetTop;
	        TRange.select();
	        }
	   }
	   
	   else {
	
	     TRange=win.document.body.createTextRange();
	     TRange.collapse(false);
	     strFound=TRange.findText(str);
	     if (strFound) {
	        //the following line added by Mike and Susan Keenan, 7 June 2003
	        win.document.body.scrollTop = TRange.offsetTop;
	        TRange.select();
	        }
	   }
	  }
	  
	   if (TRange==null || strFound==0) {
	   TRange=win.document.body.createTextRange();
	   dupeRange = TRange.duplicate();
	   strFound=TRange.findText(str);
	    if (strFound) {
	        //the following line added by Mike and Susan Keenan, 7 June 2003
	        win.document.body.scrollTop = TRange.offsetTop;
	        TRange.select();
	        }
	   
	   }
	
	 }
	
	if (!strFound) alert ("¡El modelo '"+str+"' no ha sido encontrado!") // string not found
	        
}


//	FUNCIONES DE /SURWEB/web/estilos/scripts/estilos.js

/**
*	Funcion que imprime la pagina a traves de la impresora
*/
function imprimir() {
	if(confirm("Se va a mandar esta página a la impresora\n con un formato adecuado para su impresión.\n ¿Desea continuar?")) { 
	  window.print();
	}
}

/**
*	DUDA
*/
function setActiveStyleSheet(title) {
  var i, a, main;
  for(i=0; (a = document.getElementsByTagName("link")[i]); i++) {
    if(a.getAttribute("rel").indexOf("style") != -1 && a.getAttribute("title")) {
      a.disabled = true;
      if(a.getAttribute("title") == title) {
      	a.disabled = false;
      }
    }
  }
}

/**
*	DUDA
*/
function getActiveStyleSheet() {
	var i, a;
	for(i=0; (a = document.getElementsByTagName("link")[i]); i++) {
		if(a.getAttribute("rel").indexOf("style") != -1 && a.getAttribute("title") && !a.disabled){
			return a.getAttribute("title");
		}
	}
	return null;
}

/**
*	DUDA
*/
function getPreferredStyleSheet() {
	var i, a;
	for(i=0; (a = document.getElementsByTagName("link")[i]); i++) {
	if(a.getAttribute("rel").indexOf("style") != -1
       && a.getAttribute("rel").indexOf("alt") == -1
       && a.getAttribute("title")
       ) {
			return a.getAttribute("title");
	}
  }
  return null;
}

/**
*	DUDA
*/
function createCookie(name,value,days) {
  if (days) {
    var date = new Date();
    date.setTime(date.getTime()+(days*24*60*60*1000));
    var expires = "; expires="+date.toGMTString();
  }
  else expires = "";
  document.cookie = name+"="+value+expires+"; path=/";
}

/**
*	DUDA
*/
function readCookie(name) {
  var nameEQ = name + "=";
  var ca = document.cookie.split(';');
  for(var i=0;i < ca.length;i++) {
    var c = ca[i];
    while (c.charAt(0)==' ') c = c.substring(1,c.length);
    if (c.indexOf(nameEQ) == 0) return c.substring(nameEQ.length,c.length);
  }
  return null;
}


/**
*	DUDA
*/
window.onload = function(e) {
  var cookie = readCookie("style");
  var title = cookie ? cookie : getPreferredStyleSheet();
  setActiveStyleSheet(title);
}


/**
*	DUDA
*/
window.onunload = function(e) {
  var title = getActiveStyleSheet();
  createCookie("style", title, 365);
}
var cookie = readCookie("style");
var title = cookie ? cookie : getPreferredStyleSheet();
setActiveStyleSheet(title);



//	FUNCIONES DE /SURWEB/web/gestorDeDeclaraciones/comun/js/funcionesVarias.js

/************************************************************************************************/
/* Constantes que representan los diferentes estados en los que se puede encontrar un documento */
/************************************************************************************************/
var ESTADO_ERRONEO                      =  0;
var ESTADO_CORRECTO                     =  1;
var ESTADO_IMPRESO                      =  2;
var ESTADO_FIRMADO                      =  3;
var ESTADO_PAGADO                       =  4;
var ESTADO_PENDIENTE_DE_DOCUMENTACION   =  5;
var ESTADO_PRESENTADO                   =  6;
var ESTADO_ERROR_EN_PAGO                =  7;
var ESTADO_ERROR_TECNICO_EN_PAGO        =  8;
var ESTADO_ERROR_TECNICO_EN_PRESENTACION=  9;
var ESTADO_NRC_ERROR                    = 11;

// Almacenamos en esta variable global el tipo de modelo que trata de imprimir el usuario, ya que 
// será necesario conocerlo en otras validaciones como, por ejemplo, la que se hace en la llamada al
// método 'importePermiteImprimirOFirmar' que se llama desde el mismo método que se llama a este ['imprimirDocumentos']
var codigoModeloSeleccionado;

// Definimos estas variables globales para referirnos a elementos que contengan las diferentes tablas de las
// diferentes pestañas de la JSF 'gestionDeDocumentos'. Las usamos porque con la versión 1.1.3 de myFaces, no 
// se tenía en cuenta el identificador de cada pestaña a la hora de recuperar los valores de los componentes 
// que contuviera, sin embargo, con la versión 1.1.5 sí tiene en cuenta este identificador, por lo que hubo 
// que hacer todas las modificaciones correspondientes y para que no pase nada parecido usamos estas variables 
// globales por si acaso ocurre algo similar en el futuro con nuevas versiones de las APIs
var formulario  = "formPresentacion";
var pestDocum_1_1_5   = "formPresentacion:tabDocumentos";
var pestDocum   = "formPresentacion";
var tablaDocu_1_1_5   = "formPresentacion:tabDocumentos:tablaDatosDocumentos";
var tablaDocu   = "formPresentacion:tablaDatosDocumentos";
var tablaHist   = "formPresentacion:tablaDatosFicheros";
var capaDupliDoc_1_1_5= "formPresentacion:tabDocumentos:capaDuplicarDocumento";
var capaDupliDoc= "formPresentacion:capaDuplicarDocumento";
var pestPreconf = "formPresentacion:tabPreconfecciones";
var tablaPreconf= "formPresentacion:tabBorradores:tablaDatosPreconfecciones";
var tabDocumentosConExpediente = "formPresentacion:tabDocumentosConExpediente";

/**
*	Funcion que selecciona o deselecciona todos los checkbox de la JSF 'gestionDeDocumentos'
*/
function chekAll(estado){
    for(i= 0; i< document.forms[0].elements.length; i++){
        if (document.forms[0].elements[i].type == "checkbox"){
            if(document.forms[0].elements[i].name.indexOf('checkDocumentoUsuario')!= -1){
	        document.forms[0].elements[i].checked= estado;
	    }
        }						
    }
}

function unCheck(campo){	
    document.forms['formPresentacion'].elements[tablaDocu_1_1_5 + ':control'].checked= false;
    return true;
}

/**
*	Funcion que Arranca el motor de AJAX Reverse que permite actualizar desde el servidor el resultado de la ejecución  
* 	del fichero xml, sin necesidad de tener que refrescar la pantalla cada x segundos. Lo activamos sólo     
* 	cuando el usuario acceda a la JSF de 'consultarXML' una vez ha enviado un fichero xml para carga masiva.
*/
function activaMotorAjaxReverse(){

    var hayCargaMasiva= document.getElementById("formPresentacion:hayCargaMasiva").value;

    if(hayCargaMasiva== 'true'){
        // Activamos el motor de AJAX
        dwr.engine.setActiveReverseAjax(true);
    }
}


// Almacenaremos aqui el nombre de la referencia del documento que desea duplicar el usuario
var referenciaOriginal;
// Almacenaremos aqui el identificador del registro de SU_DOCTMP_WEB que contiene el documento que 
// desea duplicar el usuario
var identificadorDoc;
// Posicion donde se encuentra el registro duplicado
var posRegDuplicadoNuevo= null;

/**
*	Funcion que duplica el documento seleccionado por el usuario.
*/
function ejecutaAccionDuplicarDocumento(operacion, referenciaDocumento, identificador, numRegistro){
	var tablaRegistros= document.getElementById(tablaDocu_1_1_5);

	// Si ya habia elegido un registro para copiarlo el usuario, lo borramos, para pintar el nuevo
	if (posRegDuplicadoNuevo!= null && operacion=='duplicarDocumento'){
		tablaRegistros.deleteRow(posRegDuplicadoNuevo);
	}
					
	if (operacion=='duplicarDocumento'){
		posRegDuplicadoNuevo= numRegistro+1;		
                tablaRegistros.insertRow(numRegistro+1);
                var fila= tablaRegistros.rows[numRegistro+1];
                fila.insertCell();
                fila.cells[0].colSpan= 12;
                fila.cells[0].innerHTML= document.getElementById(capaDupliDoc_1_1_5).innerHTML;
		
                document.getElementById(pestDocum_1_1_5 + ':nombreReferencia').value="";	
                document.getElementById(pestDocum_1_1_5 + ':nombreReferencia').focus();

                // Mostramos aqui el nombre de la referencia del documento que desea duplicar el usuario
                document.getElementById(pestDocum_1_1_5 + ':referenciaDocADuplicar').innerHTML= referenciaDocumento;
		
                // Almacenamos en las variables globales sus valores correspondientes para su posterior uso
                referenciaOriginal= referenciaDocumento;
                identificadorDoc= identificador;
	}	
	else if(operacion=='cancelarDuplicado'){
		var fila= tablaRegistros.rows[posRegDuplicadoNuevo];
		fila.deleteCell();		
	}		
}

/**
*	Funcion que comprueba que la referencia introducida por el usuario para duplicar un documento           
* 	concreto está rellena y es distinta de la del documento original a duplicar; si la          
* 	referencia es correcta, se ejecuta la accion definida en el atributo 'actionListener'       
* 	del botón de comando de id: 'botonAceptarDuplicarDocumento' de la JSF 'gestionDeDocumentos' 
*/
function compruebaReferencia(Event){
    if(Event.button== 1){
    	
    	var referenciaNueva   = document.getElementById(pestDocum_1_1_5 + ':nombreReferencia').value;        

        // Si el usuario nó introduce ninguna referencia, o bien, sólo introduce espacios en blanco, lo entendemos 
        // como vacío
        if((trimAll(referenciaNueva)).length== 0){
            alert("Debe asignar una referencia al documento que desea duplicar");
            document.getElementById(pestDocum_1_1_5 + ':nombreReferencia').value="";
            document.getElementById(pestDocum_1_1_5 + ':nombreReferencia').focus();
        }
        // Si la referencia nueva es idéntica a la original, lo entendemos como inválida
        else if(trimAll(referenciaNueva.toUpperCase())== trimAll(referenciaOriginal.toUpperCase())){
            alert("La referencia nueva debe ser distinta a la referencia del documento original");
            document.getElementById(pestDocum_1_1_5 + ':nombreReferencia').select();            
        }
        // En otro caso, analizamos la referencia introducida por el usuario
        else{
            // Eliminamos las posibles comillas simples o acentos sueltos que pudiera haber introducido el usuario 
            // como parte del nombre de la referencia
            var hayComillaSimple= referenciaNueva.indexOf("'");
            var hayAcentoSuelto = referenciaNueva.indexOf("´");
            var referenciaSin;                                    
            
            var modificarReferencia= false;
            
            // Caso donde el usuario introduce como parte de la referencia ambos caracteres: ' y ´
            if(hayComillaSimple!= -1 && hayAcentoSuelto!= -1){
            	// Eliminamos, de la siguiente forma, TODAS las comillas simples que pudieran existir 
            	// en la referencia que ha introducido el usuario.
            	// (En JavaScript NO existe el método replaceAll; de esta forma se emula el 
            	// funcionamiento del mismo)
            	var referenciaTmp= referenciaNueva.replace(/["'"]+/g, "");
            	
            	// Eliminamos ahora los caracteres del acento, ´, que tuviera
            	referenciaSin= referenciaTmp.replace(/["´"]+/g, "");
            	
            	modificarReferencia= true;
            }	
            // Caso donde el usuario introduce como parte de la referencia sólo el carácter apóstrofe: '
            else if(hayComillaSimple!= -1){
                // Eliminamos los apóstrofes que tuviera
                referenciaSin= referenciaNueva.replace(/["'"]+/g, "");
            	
                modificarReferencia= true;
            }
            // Caso donde el usuario introduce como parte de la referencia sólo el carácter acento: ´
            else if(hayAcentoSuelto!= -1){
            	// Eliminamos ahora los caractares del acento, ´, que tuviera
            	referenciaSin= referenciaNueva.replace(/["´"]+/g, "");
            	
                modificarReferencia= true;
            }
        	
            // Si hay comillas simples, continuamos analizando
            if(modificarReferencia){
            	// Eliminamos los espacios en blanco de antes y despues de la cadena
            	referenciaSin= trimAll(referenciaSin);
            	// Si, al eliminar las comillas y los espacios en blanco, la longitud es mayor que cero, 
            	// continuamos analizando
            	if(referenciaSin.length> 0){
                    // Si, una vez limpia de comillas y espacios en blanco anteriores y posteriores, la
                    // referencia nueva es idéntica a la original, se lo advertimos al usuario            
            	    if(trimAll(referenciaSin.toUpperCase())== trimAll(referenciaOriginal.toUpperCase())){
                        alert("La referencia nueva debe ser distinta a la referencia del documento original");
                        document.getElementById(pestDocum_1_1_5 + ':nombreReferencia').select();            
            	    }
            	    // Si todo es correcto, actualizamos los campos
            	    else{
                        document.getElementById(pestDocum_1_1_5 + ':identifDocumento').value= identificadorDoc;     
                        // Actualizamos el valor del campo que almacena la referencia, para su correcta recuperación
                        // desde el bean
                        document.getElementById(pestDocum_1_1_5 + ':nombreReferencia').value= referenciaSin;                    
                    }
            	}
            	// Si la longitud es cero, quiere decir que el usuario sólo introdujo comillas, de modo que
            	// le advertimos que introduzca una referencia válida
            	else{
            	    alert("Debe asignar una referencia válida al documento que desea duplicar");
                    document.getElementById(pestDocum_1_1_5 + ':nombreReferencia').select();
            	}
            }
            // Si el nombre de la referencia es correcto, actualizamos
            else{
                document.getElementById(pestDocum_1_1_5 + ':identifDocumento').value= identificadorDoc;                
            }
        }
    }
}
 
/**
*	Funcion que comprueba que el usuario haya introducido una referencia al documento nuevo que va a crear; 
* 	si ha introducido una referencia, se ejecuta la accion definida en el atributo              
* 	'actionListener' del botón de comando de id: 'botonAceptarNuevoDocumento' de la             
* 	JSF 'nuevoDocumento'.                                                                       
*/
function nuevoDocumento(Event){
    if (Event.button== 1){ 
        var referencia= document.getElementById(pestDocum + ':referenciaNuevoDoc').value;
	
        if(trimAll(referencia).length== 0){
            alert("Debe asignar una referencia al documento nuevo que va a crear");
	    document.getElementById('formPresentacion:referenciaNuevoDoc').select();
        }else{
            // Eliminamos las posibles comillas simples que pudiera haber introducido el usuario como parte del
            // nombre de la referencia
            var hayComillaSimple= referencia.indexOf("'");
            var referenciaSin;
            // Si hay comillas simples, continuamos analizando
            if(hayComillaSimple!= -1){
            	// Eliminamos, de la siguiente forma, TODAS las comillas simples que pudieran existir en la referencia
            	// que ha introducido el usuario.
            	// (En JavaScript NO existe el método replaceAll; de esta forma se emula el funcionamiento del mismo)
            	referenciaSin= referencia.replace(/["'"]+/g, "");
            	// Eliminamos los espacios en blanco de antes y despues de la cadena
            	referenciaSin= trimAll(referenciaSin);
            	// Si, al eliminar las comillas simples y los espacios en blanco, la longitud NO es mayor que cero, 
            	// informamos al usuario
            	if(!(referenciaSin.length> 0)){
            	    alert("Debe asignar una referencia válida al documento nuevo que va a crear");
                    document.getElementById(pestDocum + ':referenciaNuevoDoc').select();
            	}
            	// Si todo es correcto, actualizamos los campos
            	else{
                    // Actualizamos el valor del campo que almacena la referencia, para su correcta recuperación
                    // desde el bean
                    document.getElementById(pestDocum + ':referenciaNuevoDoc').value= referenciaSin; 
                }
            }
        }
    }
}
	
/**
 *	Funcion que determina si el acceso a esta pantalla es la primera vez ó, de lo contrario, el usuario      
 * 	ya accedió anteriormente y lo que pretende es cambiar de contrato, de modo que si es el      
 * 	primer caso, se ocultan tanto el menú de navegación, como el de los datos de la autorización  
 * 	seleccionada.                                                                      
 */
function primeraAutorizacion(){
    var cifAutorizacion= document.getElementById("formPresentacion:dni").innerHTML;
    var razonSocialAutorizacion= document.getElementById("formPresentacion:nombre").innerHTML;

    // Si accedemos por primera vez a la pantalla de las autorizaciones, ocultamos la barra de submenú
    // donde aparece los 'Datos de la Autorización' seleccionado por el titular del certificado
    if ((cifAutorizacion== null || cifAutorizacion=='') && 
        (razonSocialAutorizacion== null || razonSocialAutorizacion=='')){    
         document.getElementById('menu1').style.display='none';
         document.getElementById('menu3').style.display='none';       
    }
}

/**
*	Funcion a la que se le pregunta al usuario que confirme su deseo de salir de la Plataforma. Para, de  
* 	este modo, evitar aquellos casos donde éste haya pulsado de forma accidental.        
* 	Si el usuario lo confirma, se ejecuta la accion definida en el atributo 'action'     
* 	del commandLink de id: 'salirGestor' de la JSF 'cabecera'.                                                                                 
*/
function salir(link, Event){
    // Solo si el usuario pulso el boton izquierdo del raton, le efectuamos la consulta
    if (Event.button== 1){
	if (confirm("¿Realmente desea salir de la aplicación?")){
	    link.onclick();
        }
    }
}

/**
*	Funcion que comprueba que el usuario haya introducido la ruta donde se encuentra el fichero xml que 
* 	contiene los documentos que va a enviar para la carga masiva.                           
* 	Si el usuario ha seleccionado el fichero, se ejecuta la accion definida en el atributo  
* 	'actionListener' del botón de comando de id: 'enviarXML' de la JSF 'importarXML'.                                                                                       
*/
function compruebaXML(Event){
    if(Event.button== 1){
        var ficheroXml= document.getElementById('formPresentacion:docDocumento').value;

        if(trimAll(ficheroXml).length== 0){
            alert("Debe seleccionar el fichero xml que desea enviar");
        }
    }
}


/**
*	Funcion a la que Se le pregunta al usuario que confirme su deseo de eliminar el documento seleccionado    
* 	para, de este modo, evitar aquellos casos donde éste haya pulsado de forma accidental.   
* 	Si el usuario lo confirma, se ejecuta la accion definida en el atributo 'actionListener' 
* 	del commandLink de id: 'eliminarDocumento' de la JSF 'gestionDeDocumentos'.                                                                                                  
*/
function borrarDocumento(link, Event, referencia, numDocumento){
    // Eliminamos los espacios en blanco anteriores y posteriores que pudiera tener la referencia
    var referenciaLimpia= trimAll(referencia);
    
    var confirmacion;
    // Si la referencia está informada, identificamos el documento por la misma, para que confirme el usuario
    if(referenciaLimpia.length> 0){
    	confirmacion= "¿Realmente desea eliminar el documento de referencia '" + referenciaLimpia + "'?";
    }
    // Si la referencia NO está informada, identificamos el documento por el nº de documento que tuviera, para que 
    // confirme el usuario
    else{
        confirmacion= "¿Realmente desea eliminar el documento cuyo Nº documento es '" + numDocumento + "'?";
    }

    if(Event.button== 1){
        if (confirm(confirmacion)){
            link.onclick();
        }
    }
}

/**
*	Funcion que cierra la ventana del navegador donde el usuario estaba utilizando la aplicación                                                                                                
*/
function cerrarVentana(){
    alert('Gracias por utilizar la Plataforma de Gestión de Declaraciones Tributarias y Otros Modelos de Ingreso de la Junta de Andalucía. A continuación la ventana se cerrará');
    self.window.close();
}
 
/**
*	Funcion que comprueba, para las JSFs 'importarXML' y 'gestionDeDocumentos', si se ha producido algún error      
* 	al enviar el fichero xml para la carga masiva, ó al tratar de firmar un documento, respectivamente, 
* 	de modo que si es así, se le muestra el correspondiente mensaje de error al usuario en un alert.                                                                                            
*/
function compruebaSiError(){
    var errorProducido= document.getElementById("errorProducido").value;
	
    if (errorProducido.length> 0){
        alert(errorProducido);
    }        
} 
 
/**
*	Funcion que comprueba, para las JSF 'gestionDeDocumentos', si el usuario ha eliminado un documento de su histórico, 
* 	de modo que si es así, se coloca el foco junto al texto de confirmación de la eliminación del documento,
* 	para que el usuario lo observe nada más acceder a la pantalla despues del borrado.                                                                                                                 
*/
function compruebaSiMensaje(){
    // Si el usuario ha eliminado un documento, colocamos el foco en el campo oculto, para que se vea el
    // texto que confirma que la eliminación del mismo ha sido correcta
    if(document.getElementById(pestDocum + ":txtEliminacion")){ 
    	document.getElementById(pestDocum + ":focoTexto").focus();     	
    }
} 
 
/**
*	Funcion que añade a la barra de estado el mensaje que se pasa como parámetro.                                                                                                            
*/
function borraMensajeBarraEstado(mensaje){
    window.status= mensaje;
}

/**
*	Funcion que llama al formulario de contacto                                                                                                         
*/
function llamarAyuda(){
    window.open('http://www.juntadeandalucia.es/economiayhacienda/ov/general/contacto/contacto-tributos.htm','SURCAU','width=700,height=510,alwaysRaised,left=100,top=10,scrollbars=yes');
}

/**
*	Funcion que comprueba que solo haya un check marcado                                                                                                      
*/
// Comprueba que solo haya un check marcado
var checkOld;
var hayElemAccion= false;
function compruebaCheck(checkNew){
	
    if(checkOld && checkOld.name!= checkNew.name){
        checkOld.checked= false;
    }	

    checkOld= checkNew;
	
    // Si hay algun elemento marcado, colocamos a true la variable global, para mostrar la capa de las acciones
    if(checkNew.checked){
        hayElemAccion= true;
    }
    // De lo contrario, si no hay elemento marcado, la colcamos a false para nó mostrar la capa de las acciones
    else{
        hayElemAccion= false;
    }
}

/**
*	Funcion que muestra un menu de acciones dinámico en la JSF de 'gestionDeDocumentos'                                                                                                       
*/
var numRegistro;
var capaOld = null;
var capaNew = null;
function _toggleMenu(e, numReg){

	numRegistro= numReg-1;
	
	capaNew= document.getElementById(tablaDocu_1_1_5 + ":" + numRegistro + ":capaAcciones");   
	
   	// hide any open menu
   	if (capaOld != null && capaOld.id != capaNew.id){
            capaOld.style.display = 'none';
            capaOld = null;
        }
   
       // toggle visibility of the specified element id
       if (capaNew.style.display == 'none'){   
           capaNew.style.display = 'block';

          capaOld = capaNew;
      
          // set global onclick handler to hide menu
   	  e.cancelBubble = true;

   	  if (e.stopPropagation){
   	      e.stopPropagation();
   	  }

          document.onclick = _hideLastMenu;
       }else{
           capaNew.style.display = 'none';
           document.onclick = null;
       }
}

/**
*	Funcion que oculta el último menu de acciones que hubiera abierto en la JSF de 'gestionDeDocumentos'                                                                                                     
*/
function _hideLastMenu(){
	
	// Hide the last opened menu

   if (capaOld != null){
       capaOld= document.getElementById(tablaDocu_1_1_5 + ":"+ numRegistro + ":capaAcciones");     	
       capaOld.style.display = 'none';
       capaOld = null;
       document.onclick = null;              
   }
}

/**
*	Funcion que resalta el texto asociado a las imágenes que contiene la capa del menú de acciones cuando el 
* 	usuario pasa el ratón sobre ellas; y las deja como estaba al salir de las mismas, todo ello  
* 	en la JSF de 'gestionDeDocumentos'.                                                                                                    
*/
function resalta(numReg, evento, campoTxt){
    var numRegistro= numReg-1;
	
    elemTexto= document.getElementById(tablaDocu_1_1_5 + ":" + numRegistro + ":" + campoTxt);
	
    if(evento== 0){
        elemTexto.style.color= "yellow";
        elemTexto.style.textDecoration= "underline";
    }else{
        elemTexto.style.color= "white";
        elemTexto.style.textDecoration= "none";
    }
}

/**
* 	Funcion que cambia el color de la imagen cuando se situa el ratón sobre ella, y deja la que estaba  
* 	cuando el ratón se va de la misma. Utilizado para el icono 'más' del menú de acciones   
* 	de la la JSF 'gestionDeDocumentos'                                                      
*/
function swap(numReg, evento, img){

    var numRegistro= numReg-1;	
    var elemImg= document.getElementById(tablaDocu_1_1_5 + ":" + numRegistro + ":" + img);

    if(evento== 0){
        elemImg.src= "../comun/imagenes/mas_yellow.gif";	    
    }else{
        elemImg.src= "../comun/imagenes/mas_blue.gif";
    }
}


/**
* 	Funcion que cambia el color de la imagen cuando se situa el ratón sobre ella, y deja la que estaba  
* 	cuando el ratón se va de la misma. Utilizado para el icono 'más' de la tabla            
* 	de la la JSF 'consultarXML'                                                      	   
*/
function swapHistorico(numReg, evento, img){

    var numRegistro= numReg-1;	
    var elemImg= document.getElementById(tablaHist + ":" + numRegistro + ":" + img);

    if(evento== 0){
        elemImg.src= "../comun/imagenes/mas_yellow.gif";	    
    }else{
        elemImg.src= "../comun/imagenes/mas_blue.gif";
    }
}

/**
* 	Funcion que lleva a cabo la llamada al método que se define en el atributo 'value' del botón de comando 'cmbPaginaCombo' 
* 	para paginar a la página concreta seleccionada por el usuario. Antes se llamaba al método definido en el     
* 	atributo 'valueChangeListener' del componente 'selectOneMenu', pero a raíz de añadir el atributo 'binding'   
* 	en el 'dataTable', éste dejó de funcionar, por lo que hubo que implementar de esta forma la llamada al método
*	correspondiente.                                                                                             
*/
function paginarAConcreta(){
    if(document.getElementById(pestDocum + ':cmbPaginaCombo') != null){
    	document.getElementById(pestDocum + ':cmbPaginaCombo').click();	
    }
    
    else if(document.getElementById(tabDocumentosConExpediente + ':cmbPaginaCombo') != null){
    	document.getElementById(tabDocumentosConExpediente + ':cmbPaginaCombo').click();	
    }
    
    else{
    	document.getElementById(pestDocum_1_1_5 + ':cmbPaginaCombo').click();		
    }	
}

/**
* 	Funcion que comprueba que el evento de entrada se corresponda con la pulsación de una tecla numérica,
* 	de lo contrario, impide su impresión en el campo correspondiente.                        
*/
function soloNumeros(Event){	
    if(Event.keyCode< 48 || Event.keyCode> 57){
        return (Event.keyCode= 0); 
    }
}

/**
 * Comprueba que el usuario haya seleccionado, al menos, un protocolo en la JSF de 'diligencias' para poder
 * llevar a cabo la acción solicitada.
 */
function generaDiligencia(Event){
	if(Event.button== 1){
		if(alMenosUnProtocoloSeleccionado()){
			// Se ejecuta el método 'diligenciaDePresentacion' del action del botón de comando de id
			// 'diligPresent' de la JSF 'diligencias
		}else{
			alert("Debe seleccionar algún documento para poder llevar a cabo la operación");
		}
	}
}

/**
 * Comprueba que el usuario haya seleccionado, al menos, un protocolo en la JSF de 'diligencias' para poder
 * llevar a cabo la acción solicitada.
 */
function generaDocumentacion(Event){
	if(Event.button== 1){
	    if(alMenosUnProtocoloSeleccionado()){
		    // Se ejecuta el método 'documentacionDiligenciaDePresentacion' del action del botón de comando
		    // de id 'docuDiligPresent' de la JSF 'diligencias
	    }else{
	    	alert("Debe seleccionar algún documento para poder llevar a cabo la operación");
	    }	
	}
}

/**
 * 	Funcion que comprueba que el usuario haya seleccionado en la JSF 'diligencias' al menos un protocolo 
 * 	de los que tiene en pantalla.
 */
function alMenosUnProtocoloSeleccionado(){
    var hayUnoSeleccionado= false;
    
    var tablaRegistros= 'formPresentacion:tabDocumentosConExpediente:tablaDocumentosConExpedientes';
    
    // El primer registro se corresponde con el nombre de las columnas, por lo que restamos 1
    var numRows= document.getElementById(tablaRegistros).rows.length-1;
    
    for(k= 0; k< numRows && !hayUnoSeleccionado; k++){
        // Comprobamos, si el registro tiene la caja de check
	    var check= document.getElementById(tablaRegistros + ':' + k + ':checkProtocolo');

	    // Si existe la caja, comprobamos si está seleccionada
	    if(check!= null){	    
	        var valorCheck= check.checked;

	        if(valorCheck){
	            hayUnoSeleccionado= true;
	        }
	    }
    }	
    
    return hayUnoSeleccionado;
}


/**
 * Valida los criterios de busqueda introducidos por el usuario en la JSF de 'diligencias' de PLAGES.
 */
function validaCampos(Event){
	if(Event.button== 1){
		if(compruebaCampos()){
			// Validamos que sean correctas las fechas introducidas por el usuario
		    if(validaFechas()){
		    	// Si son correctas las validaciones, se ejecutará el método que tiene asignado 
		    	// en al atributo 'action' el botón de comando de comando 'Buscar diligencias' de
		    	// la JSF 'diligencias'
		    }
		}
	}
}

/**
 * Comprueba si el usuario introdujo algun criterio en los campos 'protocolo' y 'ejercicio' de la
 * JSF 'diligencias', de modo que deben estar rellenos los dos o ninguno para realizar la busqueda.
 */
function compruebaCampos(Event){
	var camposOK= true;
	  	    
	var protocolo = document.getElementById("formPresentacion:buscaProtocolo");
	var ejercicio = document.getElementById("formPresentacion:buscaEjercicio");

	if(campoNoVacio(protocolo) && !campoNoVacio(ejercicio)){
	    alert("Debe consignar el ejercicio del protocolo para realizar la consulta");	
	    camposOK= false;
	}
	else if(campoNoVacio(ejercicio) && !campoNoVacio(protocolo)){
	    alert("Debe consignar el protocolo del ejercicio para realizar la consulta");
	    camposOK= false;	
	}    
    
    return camposOK;
}

/**
* 	Funcion comprueba que son válidas las fechas introducidas en la JSF 'consultarXML', de modo que si 
* 	es así, se ejecuta la accion definida en el atributo 'action' del botón de comando de id:  
* 	'buscaFicheros' de dicha JSF.                                                              
*/
function compruebaFecha(Event){
    if (Event.button== 1){     	    	
    	if(validaFechas()){
            // Si son correctas las fechas introducidas por el usuario, se ejecutará el 
            // método que tiene asignado en al atributo 'action' el botón de comando 'buscaFicheros'
    	}
    }
}

/**
* 	Funcion que devuelve cierto si son correctas las fechas introducidas en la JSF 'consultarXML' y falso  
* 	en caso contrario.                                                                         
*/
function validaFechas(){
    var fechasOK= true;
    
    var diaDesde = document.getElementById("formPresentacion:diaDesde");
    var mesDesde = document.getElementById("formPresentacion:mesDesde");
    var anyoDesde= document.getElementById("formPresentacion:anyoDesde");
    	
    var diaHasta = document.getElementById("formPresentacion:diaHasta");
    var mesHasta = document.getElementById("formPresentacion:mesHasta");
    var anyoHasta= document.getElementById("formPresentacion:anyoHasta");
    
    if(!validaInputFecha(diaDesde, mesDesde, anyoDesde)){
        fechasOK= false;        
    }
    
    if(fechasOK && !validaInputFecha(diaHasta, mesHasta, anyoHasta)){
        fechasOK= false;         
    }
    
    if(fechasOK && !validarFechasConsulta(diaDesde, mesDesde, anyoDesde, diaHasta, mesHasta, anyoHasta)){
    	fechasOK= false;
    }
    
    return fechasOK;
}


// Constantes que contienen los valores que tendrán en la JSF de 'gestionDeDocumentos' 
var CRITERIO_FECHA_DEVENGO       = 0;
var CRITERIO_FECHA_INCORPORACION = 1;
var CRITERIO_FECHA_PAGO_PRESENTAC= 2;

/**
* 	Funcion que devuelve cierto si la fecha de entrada es correcta, y falso en caso contrario.             
*/
function validaInputFecha(diaFech, mesFech, anyoFech) {
    var bisiesto;
    var days  = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
    
    var dia   = parseInt(diaFech.value, 10);

    // Si nó es un número el valor que introdujo el usuario en el día, se lo hacemos saber para que lo corrija
    if (campoNoVacio(diaFech) && isNaN(dia)) {
    	alert("El día debe ser numérico. Por favor, introdúzcalo de nuevo.");
    	diaFech.select();
    	return false;
    }


    var mes   = parseInt(mesFech.value, 10);
    
    // Si nó es un número el valor que introdujo el usuario en el mes, se lo hacemos saber para que lo corrija
    if (campoNoVacio(mesFech) && isNaN(mes)) {
    	alert("El mes debe ser numérico. Por favor, introdúzcalo de nuevo.");
    	mesFech.select();
    	return false;
    }
    
    var ano   = parseInt(anyoFech.value, 10);
    
    // Si nó es un número el valor que introdujo el usuario en el año, se lo hacemos saber para que lo corrija
    if (campoNoVacio(anyoFech) && isNaN(ano)) {
    	alert("El año debe ser numérico. Por favor, introdúzcalo de nuevo.");
    	anyoFech.select();    	
    	return false;
    }

    var limite= 0 ;
    var indice;
    var fecha1 = new Date();
    var actual = Date.parse(fecha1);
    
    if (mes> 12 || mes< 1) {
    	alert("El mes debe estar comprendido entre 1 y 12. Por favor, introdúzcalo de nuevo.");
    	mesFech.select();
    	return false;
    }
    
    indice = mes--;
    (ano % 4 == 0) ? ((ano %100 ==0)?((ano % 400 ==0)? bisiesto = true : bisiesto = false) : bisiesto = true) : bisiesto = false;
    
    if ((bisiesto== true) && (indice== 2)){
    	limite = 29;
    } else {
    	limite= days[mes];
    }

    // Si está definido el valor de 'limite', realizamos la comprobación
    if(limite){
        if (dia< 1 || dia >limite) { 
            alert ("El día debe estar comprendido entre 1 y " + limite + ". Por favor, introdúzcalo de nuevo."); 
            diaFech.select();
            return false;
        }
    }
        
    if(ano< 1000){
    	alert("Introduzca el año completo, por favor");
    	anyoFech.select();
    	return false;
    }

    if(campoNoVacio(diaFech) && campoNoVacio(mesFech) && campoNoVacio(anyoFech)){
        if (esMenorFecha(diaFech, mesFech, anyoFech)){
            return true; 
        }else {
            // Recuperamos qué fecha seleccionó el usuario, ya que si ésta es la Fecha de Devengo, en ese caso
            // sí puede ser superior a la fecha actual
            // [Esto sólo para el caso de comprobación de fechas en la JSF de 'gestionDeDocumentos']
            var comboFechas= document.forms[formulario].elements[formulario + ':buscaFecha'];
            
            // Si existe, estamos en la JSF de 'gestionDeDocumentos'; llevamos a cabo la comprobación
            if(comboFechas){
            	// Recuperamos el valor del combo que indica el tipo de fecha que seleccionó el usuario para buscar
            	var fechaSeleccionada= document.forms[formulario].elements[formulario + ':buscaFecha'].selectedIndex;
            	
            	// Si seleccionó la fecha de devengo, devolvemos que todo es OK
            	if(fechaSeleccionada== CRITERIO_FECHA_DEVENGO){
            	    return true;
                }
            }
                    	
    	    alert("La fecha debe ser inferior a la actual"); 
    	    
    	    return false;
        }
    }
    // Este caso se dará sólo en los 3 siguientes casos:
    // 
    // El usuario deja dia y mes en blanco e introduce un año superior al actual 
    // El usuario deja dia en blanco e introduce un mes cualquiera y un año superior al actual 
    // El usuario deja dia en blanco, introduce el año actual y un mes superior al actual
    // 
    // De modo que devolvemos true para que en la validación siguiente: 'validarFechasConsulta' se 
    // compruebe si el usuario dejó algún campo de la fecha en blanco y se le obligue a introducirlo
    else{    
        return true;
    }
}

/**
* 	Funcion que devuelve cierto si la fecha que se pasa como parámetro es menor que la fecha del día actual 
* 	y falso en caso contrario.                                                                  
*/
function esMenorFecha(diaFech, mesFech, anyoFech){
    var fechaActual= new Date();
    var annioActual= fechaActual.getFullYear();
    var diaActual  = fechaActual.getDate();
    var mesActual  = fechaActual.getMonth()+1;
    
    if(anyoFech.value > annioActual){
    	anyoFech.focus();
    	return false;
    }else if(anyoFech.value < annioActual){
    	return true;
    }else if(anyoFech.value==annioActual){
        if(mesFech.value > mesActual){
            mesFech.focus();
            return false;
        }else if(mesFech.value < mesActual){
            return true;
        }else if(mesFech.value==mesActual){
            if(diaFech.value > diaActual){
            	diaFech.focus();
            	return false;
            }else if(diaFech.value <=diaActual){
                return true;
            }
        }
    }
}

/**
* 	Funcion que devuelve cierto si las fechas que se pasan por parametro estan informadas y la primera es  
* 	anterior a la segunda, y falso en caso contrario.                                          
*/
function validarFechasConsulta(diaDesde, mesDesde, anyoDesde, diaHasta, mesHasta, anyoHasta){
	var fecha1= null;
	var fecha2= null;
	var anio;
	var dia1 = diaDesde;	
        var mes1 = mesDesde;	
        var agno1= anyoDesde;

	if (trimAll(dia1.value)== "" && (mes1.value || agno1.value)){
	    alert("Debe introducir el día para la fecha desde");
	    diaDesde.focus();
	    return false;
	}else if (trimAll(mes1.value)== "" && (dia1.value || agno1.value)){
	    alert("Debe introducir el mes para la fecha desde");
	    mesDesde.focus();
	    return false;
	}else if (trimAll(agno1.value)=="" && (dia1.value || mes1.value)) {
	    alert("Debe introducir el año para la fecha desde");
	    anyoDesde.focus();
	    return false;
	}else{		
	    var hoy= new Date();	    
		
	    if(dia1.value && mes1.value && agno1.value){	    
	        fecha1= new Date(agno1.value, new Number(mes1.value)-1, dia1.value);
	    }
		
	    if (fecha1!= null){	
	        if (fecha1.getTime()> hoy.getTime()){
		    alert("La fecha de inicio no puede ser posterior a la fecha actual");
                    dia1.select();
		    dia1.focus();
		    return false;
		}
	    }		
	}
	
	var dia2= diaHasta; 
        var mes2= mesHasta; 
        var agno2= anyoHasta;
        
	if (trimAll(dia2.value)== "" && (mes2.value || agno2.value)){
	    alert("Debe introducir el día para la fecha hasta");
	    diaHasta.focus();
	    return false;
	}else if (trimAll(mes2.value)== "" && (dia2.value || agno2.value)){
	    alert("Debe introducir el mes para la fecha hasta");
	    mesHasta.focus();
	    return false;
	}else if (trimAll(agno2.value)== "" && (dia2.value || mes2.value)){
	    alert("Debe introducir el año para la fecha hasta");
	    anyoHasta.select();
	    return false;			
	} else{
		
	    var hoy= new Date();	    
	
	    if(dia2.value && mes2.value && agno2.value){
	        fecha2= new Date(agno2.value, new Number(mes2.value)-1, dia2.value);	        
	    }
	}
	
	if (fecha1!= null && fecha2!= null)
	    if (fecha1.getTime()> fecha2.getTime()){
	        alert("La fecha de inicio no puede ser posterior a la fecha de fin");
		dia1.select();		
		return false;
	}
	
	return true;
}

/**
 * Abre la ventana de busqueda de notarios para la JSF de las diligencias de PLAGES.
 */
function buscarNotario(){
	var popup= window.open('../diligencias/buscaNotario.jsf','buscarNotario','width=520,height=250,scrollbars=yes');
	popup.focus();
	return false;	
}

/**
 * Coloca en el campo 'Notario' de la JSF de diliegencias de PLAGES el notario que haya seleccionado
 * en la búsqueda el usuario.
 */
function seleccionNotario(codNotar, codTaria, nomNotar){
	window.opener.document.getElementById('formPresentacion:buscaNotario').value          = nomNotar;
	window.opener.document.getElementById('formPresentacion:buscaNotarioCodNotario').value= codNotar;
	window.opener.document.getElementById('formPresentacion:buscaNotarioCodNotaria').value= codTaria;
	window.close();
}

/**
* 	Funcion que comprueba si el campo de un formulario se encuentra vacío o contiene al menos un carácter 
*	que no sea espacios en blanco.                                                            
*/
function campoNoVacio(campo){
    var campoRelleno= false;
    
    if(trimAll(campo.value).length!= 0){
    	campoRelleno= true;
    }

    return campoRelleno;
}

/**
* 	Funcion que elimina el contenido de los campos que contiene el parámetro de entrada, los cuáles   
*	se encuentran separados por el carácter 'pipe -->> |', ejemplo: 'campo1|campo2|campo3'
*/
function borrarCampos(camposABorrar){
    // Recuperamos todos los campos que contiene el parametro de entrada
    var campos= new Array();
    campos= camposABorrar.split("|");
    
    for(i= 0; i< campos.length; i++){
    	document.getElementById("formPresentacion:" + campos[i]).value= '';
    }
}	

/**
* 	Funcion que se encarga de resaltar y reestablecer a sus valores normales aquel registro de la JSF  
* 	'consultarXML' sobre el que se pase el ratón.                                          
*/
function cambiaColor(numReg, evento){
    
    // Restamos uno al parametro porque éste empieza la numeración en 1, y en este caso necesitamos
    // que empiece en cero
    var numRegistro= numReg-1;
	
    elemTextoFecha    = document.getElementById("formPresentacion:tablaDatosFicheros:" + numRegistro + ":fechaEjecucion");   
    elemTextoFichero  = document.getElementById("formPresentacion:tablaDatosFicheros:" + numRegistro + ":ficheroEjecucion");   
    elemTextoResultado= document.getElementById("formPresentacion:tablaDatosFicheros:" + numRegistro + ":resultadoEjecucion");   
    elemTextoEstado   = document.getElementById("formPresentacion:tablaDatosFicheros:" + numRegistro + ":estadoEjecucion");   
    elemNumDocumentos = document.getElementById("formPresentacion:tablaDatosFicheros:" + numRegistro + ":numeroDocumentos");   
	
    if(evento== 0){
        elemTextoFecha.style.textDecoration    ='underline';
 	
 	elemTextoFichero.style.textDecoration  ='underline';
 	
 	elemTextoResultado.style.textDecoration='underline';
 	
 	elemTextoEstado.style.textDecoration   ='underline'; 		
 	
 	elemNumDocumentos.style.textDecoration ='underline'; 		
    }else{    
 	elemTextoFecha.style.textDecoration    ='none';
	
	elemTextoFichero.style.textDecoration  ='none';
	
	elemTextoResultado.style.textDecoration='none';
	
	elemTextoEstado.style.textDecoration   ='none';		
	
	elemNumDocumentos.style.textDecoration ='none';	
    }
}


/**
* 	Funcion que comprueba que el usuario haya introducido la clave del borrador que va a solicitar;     
* 	si ha introducido una clave, se ejecuta la accion definida en el atributo               
* 	'actionListener' del botón de comando de id: 'botonAceptarSolicitudBorrador' de la      
* 	JSF 'solicitudBorrador'.                                                                
*/
function solicitarBorrador(Event){
    if (Event.button== 1){
        var notario= document.getElementById('formPresentacion:claveNotario').value;
        var notaria= document.getElementById('formPresentacion:claveNotaria').value;
        var protoco= document.getElementById('formPresentacion:claveProtocolo').value;
        var anyo   = document.getElementById('formPresentacion:claveAnyo').value;
        var nifUser= document.getElementById('formPresentacion:claveNif').value;
 
        if(trimAll(notario).length== 0){
            alert("Debe insertar el notario");     
            document.getElementById('formPresentacion:claveNotario').focus();
        }else if(trimAll(notaria).length== 0){
            alert("Debe insertar la notaría");     
            document.getElementById('formPresentacion:claveNotaria').focus();
        }else if(trimAll(protoco).length== 0){
            alert("Debe insertar el protocolo");     
            document.getElementById('formPresentacion:claveProtocolo').focus();        
        }else if(trimAll(anyo).length== 0){
            alert("Debe insertar el año");     
            document.getElementById('formPresentacion:claveAnyo').focus();
        }else if(trimAll(nifUser).length== 0){
            alert("Debe insertar el nif del declarante");     
            document.getElementById('formPresentacion:claveNif').focus();
        }
    }
}

/**
 *  Funcion que comprueba el estado del documento que el usuario va a enviar a la Plataforma de Pago, 
 *  de modo que si éste es CORRECTO o IMPRESO, y NO es Empleado Público, se le informa al usuario de 
 *  la situación, para advertirle que primero debe firmarlo. En cambio, si su estado es FIRMADO, o el 
 *  usuario es Empleado Público, se envía el documento directamente a la Plataforma de Pago.                                                         
 */
function pagarDocumento(link, Event, estadoDocumento, empPublico){
    // Una variable Boolean en JavaScript:
    // - Se inicializa a false cuando no se le pasa ningún valor al constructor, o si 
    //   se le pasa una cadena vacía, el número 0 o la palabra false sin comillas. 
    // - Se inicializa a true cuando recibe cualquier valor entrecomillado o cualquier 
    //   número distinto de 0. 
    // El parámetro 'empPublico' puede contener los valores 'true', 'false' o 'undefined', de modo
    // que de la siguiente forma, nos aseguramos un correcto tratamiento de la variable lógica 
    var esEmpPublico= false;
    if(empPublico== 'true'){
        esEmpPublico= true;
    }
	
    if(Event.button== 1){
        // Solo hacemos la comprobación siguiente si el usuario que accede a la Plataforma NO
        // es Empleado Público, pues para éstos, el documento se firma en Surnet
        if(!esEmpPublico){
            // Si el documento aún no ha sido firmado, se le informa al usuario que antes de mandar el mismo 
            // a la Plataforma de Pago debe firmarlo
            if(estadoDocumento== ESTADO_CORRECTO || estadoDocumento== ESTADO_IMPRESO){

            	var textoInformativo= "Al menos un documento de los seleccionados no ha sido firmado.\n";
	                textoInformativo+= "A continuación, se mostrarán estos documentos para que sean firmados.\n";
	                textoInformativo+= "Una vez firmados se enviarán, conjuntamente, todos los documentos \n";
	                textoInformativo+= "seleccionados a la Plataforma de Pago";
           	
            	
                if (confirm(textoInformativo)){
	        	    link.onclick();  
	            }
	        }
        }
	    // Si el estado del documento es FIRMADO o ERROR EN PAGO, o el usuario tiene perfil de Empleado
	    // Público, se ejecutará el método que tiene asociado el actionListener, por lo que NÓ es 
	    // necesario activar en un 'else' el 'link.onclick()', de lo contrario, 
	    // SE EJECUTARÍA 2 VECES el método asociado en el bean de respaldo		
    }
}

/**
* 	Funcion que comprueba, antes de enviar a imprimir en PDF los documentos, que el usuario haya seleccionado          
* 	el check de, al menos, un documento correcto, de modo que, si es así, se ejecuta la accion definida en 
* 	el atributo 'actionListener' del botón de comando de id: 'botonPDF' de la JSF 'gestionDeDocumentos'.   
*/
function imprimirDocumentos(Event){
    if(Event.button== 1){	
        // Comprobamos, en primer lugar, que al menos haya un documento correcto
        if(alMenosUnDocumentoOK()){
            // Comprobamos ahora que el usuario haya seleccionado, al menos, uno de esos documentos
            if(alMenosUnDocumentoSeleccionado()){
                // Comprobamos que todos los documentos seleccionado sean del mismo tipo
                if(numModelosMismoTipo()){
                    // Comprobamos ahora que el usuario tenga permiso para imprimir todos los documentos seleccionados	
                    if(permisoParaImprimirFirmarTodos('imprimir')){
	                // Comprobamos que cada documento se encuentre en un estado que le permita ser impreso (ya que 
	                // hay estados que nó permiten que un documento se pueda imprimir, como los estados 
	                // 'Error téc. presentación', 'Error en pago', ...)
	            	if(estadoPermiteImprimir()){   
	            	    // Comprobamos si el importe permite imprimir ya que para ciertos modelos, como el 621, si
	                    // el estado del documento es EXENTO, no se permite imprimirlos
	                    if(importePermiteImprimir()){
	                        // Si todo es ok, se ejecutará el método del actionListener
	                    }
	                }
	            }
                }else{
                    alert("No es posible imprimir documentos de distinto tipo.");                
                }        
            }else{
                alert("Debe seleccionar al menos un documento para imprimir");        
            }
        }else{
            alert("No existe ningún documento correcto para imprimir");
        }
    }
}

/**
* 	Funcion que comprueba que el usuario haya seleccionado correctamente los documentos para firmar, o sea,  
* 	sean todos del mismo tipo [todos 600, todos 621, ...], no se haya firmado anteriormente, ... 
* 	Si todo es correcto, se ejecuta la accion definida en el atributo 'actionListener' del       
* 	botón de comando de id: 'botonFirma' de la JSF 'gestionDeDocumentos'.                        
*/
function firmarDocumentos(Event){
    if(Event.button== 1){	
        // Comprobamos, en primer lugar, que al menos haya un documento correcto
        if(alMenosUnDocumentoOK()){
            // Comprobamos ahora que el usuario, al menos, haya seleccionado uno de esos documentos
            if(alMenosUnDocumentoSeleccionado()){
                // Comprobamos que todos los documentos seleccionado sean del mismo tipo
                if(numModelosMismoTipo()){
            	    // Comprobamos que, de esos documentos seleccionados, no se haya firmado ninguno anteriormente
            	    if(ningunDocumentoYaFirmado()){
            	        // Comprobamos ahora que el usuario tenga permiso para firmar todos los documentos seleccionados
                        if(permisoParaImprimirFirmarTodos('firmar')){	            	    	
            	            // Comprobamos si el importe permite firmar, ya que para ciertos modelos, como el 621, si
                            // el estado del documento es EXENTO y el caucional incorrecto, nó se permite firmar
                            if(importePermiteFirmar()){
                                // Si todo es ok, se ejecutará el método del actionListener
                            }
                        }
                    }else{
                        alert("No puede volver a firmar documentos ya firmados. Por favor,\nrevise la selección de los documentos que desea firmar.");         
                    }            	            	
                }else{
    	            alert("No es posible firmar documentos de distinto tipo.");
                }
            }else{
                alert("Debe seleccionar al menos un documento para firmar");
            }
        }else{
            alert("No existe ningún documento correcto para firmar");
        }
    }
}

/**
 * Cuenta el nº de documentos que ha seleccionado el usuario seleccionando la check correspondiente.
 */
function numDocumentosSeleccionados(){
    var numDocs= 0;
    
    // El primer registro se corresponde con el nombre de las columnas, por lo que restamos 1
    var numRows= document.getElementById(tablaDocu_1_1_5).rows.length-1;
    
    for (k= 0; k< numRows; k++){
        // Comprobamos si el registro tiene la caja de check, la cual solo aparece cuando el modelo es correcto
	    var check= document.getElementById(tablaDocu_1_1_5 + ':' + k + ':checkDocumentoUsuario');
	
	    // Si existe la caja, comprobamos si está seleccionada
	    if (check!= null){	    
	        var valorCheck= check.checked;
	    
    	    // Si está seleccionada, incrementamos el contador
	        if (valorCheck){
	            numDocs++;
	        }
	    }
    }
	   
    return numDocs;
}

/**
* 	Funcion que comprueba que el usuario haya seleccionado correctamente los documentos para pagar, o sea:   
* 	haya seleccionado al menos uno, no se hayan pagado anteriormente, ...                         
* 	Si todo es correcto, se ejecuta la accion definida en el atributo 'actionListener' del botón
* 	de comando de id: 'botonSURNET' de la JSF 'gestionDeDocumentos'.                            
*/
function pagarDocumentos(Event){
    if(Event.button== 1){
        // Comprobamos, en primer lugar, que al menos haya un documento correcto
        if(alMenosUnDocumentoOK()){
            // Comprobamos ahora que el usuario, al menos, haya seleccionado uno de esos documentos
            if(alMenosUnDocumentoSeleccionado()){
    		// Comprobamos que todos los documentos seleccionado sean del mismo tipo
    		if(numModelosMismoTipo()){
    		    // Comprobamos que, de esos documentos seleccionados, no se haya pagado ninguno anteriormente
    		    if(ningunDocumentoYaPagado()){
    		    	// Comprobamos ahora que el usuario tenga permiso para pagar todos los documentos seleccionados	
    		        if(permisoParaPagarPresentarTodos()){	
    		    	    // Comprobamos ahora que todos se puedan pagar/presentar en la Plataforma de Pago en función
    		    	    // del importe de cada documento
                 	    if(sePuedenPresentar('pagar')){
    		    	        // Comprobamos que se cumplan las condiciones para el caso de los documentos en estado
    		    	        // 'Error Tecnico en Pago'
    		    	        if(errorTecnicoPagoOK()){
    		    	    	    // Comprobamos que se cumplan las condiciones para el caso de los documentos en estado
    		    	            // 'Error Tecnico en Presentacion'
    		    	    	    if(errorTecnicoPresentacionOK()){
                                        // Finalmente, si de entre los documentos elegidos, existe al menos uno sin firmar, se 
                                        // le informa al usuario que antes de mandar los documentos a la Plataforma de Pago, debe 
                                        // firmar los que aún no han sido firmados y deban estarlo
	                                if(hayQueFirmarDocumentos()){
	                                    var textoInformativo= "Al menos un documento de los seleccionados no ha sido firmado.\n";
                                            textoInformativo+= "A continuación, se mostrarán estos documentos para que sean firmados.\n";
                                            textoInformativo+= "Una vez firmados se enviarán, conjuntamente, todos los documentos \n";
                                            textoInformativo+= "seleccionados a la Plataforma de Pago";
	            	
	            	                    if (confirm(textoInformativo)){
	            	                        // Si el usuario confirma el mensaje, ejecutamos el 'actionListener' asociado al botón de comando
	            	                        // 'botonOcultoSURNET' que ejecuta en el servidor el metodo 'pagarDocumentos'           		
		    	                        document.getElementById(pestDocum_1_1_5 + ':botonOcultoSURNET').click();
		    	                    }
		                        }
		                    }else{
                                        alert("No es posible enviar a la Plataforma de Pago documentos en estado \n'Error técnico en presentación' con documentos en otro estado.");
		                    }
		                }
    		            }else{
    		                alert("Elimine de la selección de documentos aquellos que no se pueden pagar/presentar");
    		            }
    		        }    		    		
    		    }else{
    		        alert("No puede volver a pagar/presentar documentos que ya hiciera con anterioridad.\nPor favor, revise la selección de los documentos que desea enviar.");
    		    }
    	        }else{
    	            alert("No puede pagar/presentar documentos de distinto tipo");
    	        }
            }else{
                alert("Debe seleccionar al menos un documento para pagar");
            }
        }else{
            alert("No existe ningún documento correcto para pagar");
        }
    }
}

/**
 * Establece a true el campo oculto 'jsfCambioAutorizacion' de la JSF de las autorizaciones para indicar 
 * de este modo que el usuario ha navegado a la JSF de los documentos desde la de autorizaciones y así 
 * realizar las comprobaciones oportunas con respecto al posible cambio de autorización que pueda realizar 
 * el mismo durante su navegación por la Plataforma.
 */
function jsfAutorizaciones(){
	// Establecemos la bandera a true para que se realicen las comprobaciones oportunas en el método
	// aludido 'GestionDeDocumentos.recuperaDocumentos'
	document.getElementById(pestDocum + ':jsfCambioAutorizacion').value= "true";
}

/**
 * 	Funcion que comprueba que el usuario de perfil E. Público haya seleccionado correctamente el 
 *   documento para pagar, o sea:   
 * 	haya seleccionado uno y solo un documento; no se haya pagado anteriormente; etc.                         
 * 	Si todo es correcto, se ejecuta la accion definida en el atributo 'actionListener' del botón
 * 	de comando de id: 'botonSURNET' de la JSF 'gestionDeDocumentos'.
 */
function pagarDocumentoEP(Event){
	var numDocsSelec= 0;

    if(Event.button== 1){
        // Comprobamos, en primer lugar, que al menos haya un documento correcto
        if(alMenosUnDocumentoOK()){
          	// Comprobamos ahora que el usuario haya seleccionado uno y solo uno de esos documentos 
          	// para firmar
            numDocsSelec= numDocumentosSeleccionados();
            if(numDocsSelec== 1){
		        // Comprobamos que, de esos documentos seleccionados, no se haya pagado ninguno 
		        // anteriormente
		        if(ningunDocumentoYaPagado()){
		    	    // Comprobamos ahora que el usuario tenga permiso para pagar el 
    		    	// documento seleccionado	
    		        if(permisoParaPagarPresentarTodos()){
	    	    	    // Comprobamos ahora que el documento se pueda pagar/presentar en la Plataforma de 
		        	    // Pago en función del importe
             	        if(sePuedenPresentar('pagar')){
             	        	// Si todo es OK, se ejecutará el método definido en el actionListener del botón 
             	        	// de comando de identificador 'botonSURNETEPff' de la JSF 'gestionDeDocumentos'
		                }else{
		                    alert("Elimine de la selección de documentos aquellos que no se pueden pagar/presentar");
		                }
		            }    		    		
		        }else{
		            alert("No puede volver a pagar/presentar documentos que ya hiciera con anterioridad.\nPor favor, revise la selección de los documentos que desea enviar.");
		        }
            }else{
            	if(numDocsSelec== 0){
                    alert("Debe seleccionar el documento que desea enviar a la Plataforma de Pago");
                }else if(numDocsSelec> 1){
                    alert("No es posible enviar más de un documento simultáneamente a la Plataforma de Pago");
                }
            }
        }else{
            alert("No existe ningún documento correcto para pagar");
        }
    }
}

/**
* 	Funcion que comprueba que en la JSF 'gestionDeDocumentos' exista al menos un documento que nó sea erróneo 
*/
function alMenosUnDocumentoOK(){
    var hayUnoOK = false;
    
    // El primer registro se corresponde con el nombre de las columnas, por lo que restamos 1
    var numRows= document.getElementById(tablaDocu_1_1_5).rows.length-1;
    
    for (k= 0; k< numRows && !hayUnoOK; k++){
        // Comprobamos, si el registro tiene la caja de check, la cual solo aparece cuando el modelo es correcto
	var check= document.getElementById(tablaDocu_1_1_5 + ':' + k + ':checkDocumentoUsuario');
	
	// Si existe, al menos un documento de los que se muestra al usuario es NÓ erróneo
	if (check!= null){
	    hayUnoOK= true;
	}
    }
    
    return hayUnoOK;
}

/**
* 	Funcion que comprueba que el usuario haya seleccionado en la JSF 'gestionDeDocumentos' al menos un documento 
* 	de los que tiene en pantalla y son nó erróneos.                                                  
*/
function alMenosUnDocumentoSeleccionado(){
    var hayUnoSeleccionado= false;
    
    // El primer registro se corresponde con el nombre de las columnas, por lo que restamos 1
    var numRows= document.getElementById(tablaDocu_1_1_5).rows.length-1;
    
    for (k= 0; k< numRows && !hayUnoSeleccionado; k++){
        // Comprobamos, si el registro tiene la caja de check, la cual solo aparece cuando el modelo es correcto
	var check= document.getElementById(tablaDocu_1_1_5 + ':' + k + ':checkDocumentoUsuario');
	
	// Si existe la caja, comprobamos si está seleccionada
	if (check!= null){	    
	    var valorCheck= check.checked;
	    
	    if (valorCheck){
	        hayUnoSeleccionado= true;
	    }
	}
    }
	
    
    return hayUnoSeleccionado;
}



/**
* 	Funcion que comprueba que el usuario haya seleccionado modelos del mismo tipo, y NO mezclados [600 y 621] 
*/
function numModelosMismoTipo(){
	// El primer registro se corresponde con el nombre de las columnas, por lo que restamos 1
	var numRows= document.getElementById(tablaDocu_1_1_5).rows.length-1;
	
	var codModeloTipoA= null;
	var codModeloTipoB= null;
	var modelosDelMismoTipo= true;
	
	for (k= 0; k< numRows && modelosDelMismoTipo; k++){
            // Comprobamos, en primer lugar, si el registro tiene la caja de check, la cual solo aparece
            // cuando el modelo es correcto
            var check= document.getElementById(tablaDocu_1_1_5 + ':' + k + ':checkDocumentoUsuario');

            if (check!= null){
                var valorCheck= check.checked;

                // Si el usuario selecciono el check para imprimir el modelo, comprobamos que tipo 
                // de modelo es
                if (valorCheck){
                    var idModelo= document.getElementById(tablaDocu_1_1_5 + ':' + k + ':conceptoModelo').innerHTML;
                    
                    // Obtenemos los 3 primeros caracteres del concepto, para recuperar el tipo de modelo seleccionado						
                    if (idModelo!= null && idModelo.length>= 3){
                        var codModelo= idModelo.substring(0, 3);
					
                        if(codModeloTipoA== null){
                            codModeloTipoA= codModelo;
                        }else{
                            codModeloTipoB= codModelo;
                        }
					
                        if(codModeloTipoA!= null && codModeloTipoB!= null){
                            if(codModeloTipoA!= codModeloTipoB){
                                modelosDelMismoTipo= false;
                            }
                        }	

                        // Almacenamos el tipo de modelo en el parámetro global
                        codigoModeloSeleccionado= codModelo;														
                    }												
                }					
            }								
        }	
	
	return modelosDelMismoTipo;
}

/**
* 	Funcion que comprueba que, para todos los documentos seleccionados por el usuario para imprimir o firmar, disponga  
* 	de los permisos necesarios.                                                                             
*/
function permisoParaImprimirFirmarTodos(accion){
    var refExterna;
    
    // Array para almacenar las referencias de los documentos que no se puedan imprimir por carecer de permisos 
    // el usuario
    var arrayReferencias= new Array();
    
    // El primer registro se corresponde con el nombre de las columnas, por lo que restamos 1
    var numRows= document.getElementById(tablaDocu_1_1_5).rows.length-1;
    
    var permisoParaTodos= true;
    
    var cont= 0;
    	
    for (k= 0; k< numRows; k++){
        // Comprobamos, en primer lugar, si el registro tiene la caja de check, la cual solo aparece
        // cuando el modelo es correcto
        var check= document.getElementById(tablaDocu_1_1_5 + ':' + k + ':checkDocumentoUsuario');
        if (check!= null){
            var valorCheck= check.checked;

            // Si el usuario seleccionó el check para imprimir el modelo, comprobamos el permiso            
            if (valorCheck){
                var permiso= document.getElementById(tablaDocu_1_1_5 + ':' + k + ':permisoPermiteImprimirFirmar').value;
                        
                // Si no tiene permiso, recuperamos la referencia externa del documento                                
                if(permiso== 'false'){
                    refExterna= document.getElementById(tablaDocu_1_1_5 + ':' + k + ':referenciaExterna').innerHTML;
                    arrayReferencias[cont]= " '" + refExterna + "'";
                    permisoParaTodos= false;
                    cont++;
                }
            }
        }
    }
    
    // Si al menos para uno de los documentos seleccionados por el usuario carece de permisos, le informamos de ello
    if(!permisoParaTodos){
    	if(cont== 1){
    	    alert("El usuario carece de permisos para " + accion + " el documento de referencia \n'" + refExterna + "'.");	
    	}else{    	    
            alert("El usuario carece de permisos para " + accion + " los documentos de referencia:\n" + arrayReferencias);
        }
    }

    return permisoParaTodos;
}

/**
* 	Funcion que comprueba que todos los modelos seleccionados por el usuario se puedan imprimir, o sea, no se           
* 	encuentren en cualquiera de los estados: 'Error en pago', 'Error téc. pago', 'Error téc. presentación' 
* 	ó 'NRC error'.                                                                                         
*/
function estadoPermiteImprimir(){
    // El primer registro se corresponde con el nombre de las columnas, por lo que restamos 1
    var numRows= document.getElementById(tablaDocu_1_1_5).rows.length-1;
    
    var todosLosModelosSePuedenImprimir= true;
	
    for (k= 0; k< numRows && todosLosModelosSePuedenImprimir; k++){
        // Comprobamos, en primer lugar, si el registro tiene la caja de check, la cual solo aparece
        // cuando el modelo es correcto
        var check= document.getElementById(tablaDocu_1_1_5 + ':' + k + ':checkDocumentoUsuario');
        if (check!= null){
            var valorCheck= check.checked;

            // Si el usuario selecciono el check para imprimir el modelo, comprobamos el estado            
            if (valorCheck){
                var estadoDocumento= document.getElementById(tablaDocu_1_1_5 + ':' + k + ':estadoDocumento').value;

                if(estadoDocumento== ESTADO_ERROR_EN_PAGO){
                    todosLosModelosSePuedenImprimir= false;
                    alert("No es posible imprimir documentos en estado 'Error en pago'");
		}else if(estadoDocumento== ESTADO_ERROR_TECNICO_EN_PAGO){
                    todosLosModelosSePuedenImprimir= false;
                    alert("No es posible imprimir documentos en estado 'Error técnico en pago'");
                }else if(estadoDocumento== ESTADO_ERROR_TECNICO_EN_PRESENTACION){
                    todosLosModelosSePuedenImprimir= false;
                    alert("No es posible imprimir documentos en estado 'Error técnico en presentación'");
                }else if(estadoDocumento== ESTADO_NRC_ERROR){
                    todosLosModelosSePuedenImprimir= false;
                    alert("No es posible imprimir documentos en estado 'NRC error'");
                }
            }
        }
    }

    return todosLosModelosSePuedenImprimir;
}

/**
* 	Funcion que muestra un mensaje informando que el usuario seleccionó algún modelo de tipo 621 que no se puede imprimir 
* 	en PDF, porque éste está EXENTO de pago; si nó es EXENTO de pago, devuelve true.                          
*/
function importePermiteImprimir(){
    var ningunModeloExento= true;

    // Sólo hacemos la comprobación si los modelos seleccionados son de tipo 621, ya que, en prinicipio, que sepamos, 
    // son el único que no permite imprimirlos si éstos son EXENTO de pago. La variable global que utilizamos para
    // comprobar el tipo de modelo se inicializó en la llamada al método 'numModelosMismoTipo' que se llama desde
    // el método 'imprimirDocumentos' también [al igual que este]
    if(codigoModeloSeleccionado== '621'){
    	// Si al menos uno de los modelos 621 seleccionados para imprimir es EXENTO devolvemos falso, pues no es 
    	// posible imprimir
    	if(algunoNoSePuedeImprimir()){
    	    ningunModeloExento= false;
    	}
    }
	
    return ningunModeloExento;
}


/**
* 	Funcion que muestra un mensaje informando que el usuario seleccionó algún modelo de tipo 621 que nó se puede firmar,   
* 	porque éste está EXENTO de pago y el caucional nó es correcto; si nó es EXENTO de pago ó es EXENTO pero el 
* 	caucional es correcto, devuelve true.                                                                      
*/
function importePermiteFirmar(){
    var todosSePuedenFirmar= true;

    // Sólo hacemos la comprobación si los modelos seleccionados son de tipo 621, ya que, en principio, que se sepa, 
    // son el único que no permite firmar si éstos son EXENTO de pago. La variable global que utilizamos para
    // comprobar el tipo de modelo se inicializó en la llamada al método 'numModelosMismoTipo' que se llama desde
    // el método 'firmarDocumentos' también [al igual que este]
    if(codigoModeloSeleccionado== '621'){
    	// Si, al menos, uno de los modelos 621 seleccionados para firmar es EXENTO, comprobamos si se puede presentar
    	// porque sea el caucional OK; si es que sí, el documento se puede firmar
    	if (!sePuedenPresentar('firmar')){
    	    todosSePuedenFirmar= false;
    	}
    }
	
    return todosSePuedenFirmar;
}

/**
* 	Funcion que comprueba que todos los modelos seleccionados por el usuario se puedan imprimir/firmar, o sea, ninguno de 
* 	ellos se encuentra EXENTO de pago. Sólo para modelos de tipo 621.                                         
*/
function algunoNoSePuedeImprimir(){
    var esAlgunImporteExento= false;
		
    // Array para almacenar las referencias de los documentos que no se puedan imprimir debido al importe
    // del documento
    var arrayReferencias= new Array(); 
    		
    // El primer registro se corresponde con el nombre de las columnas, por lo que restamos 1
    var numRows= document.getElementById(tablaDocu_1_1_5).rows.length-1;
	
    var cont= 0;
    	
    for (k= 0; k< numRows; k++){
        // Comprobamos, en primer lugar, si el registro tiene la caja de check, la cual solo aparece
        // cuando el modelo es correcto
        var check= document.getElementById(tablaDocu_1_1_5 + ':' + k + ':checkDocumentoUsuario');

        if (check!= null){
            var valorCheck= check.checked;

            // Si el usuario selecciono el check para imprimir el modelo, comprobamos el importe                
            if (valorCheck){ 
                var importePermiteImprimirFirmar= document.getElementById(tablaDocu_1_1_5 + ':' + k + ':importePermiteImprimirFirmar').value;

                // Si alguno no se puede imprimir porque sea EXENTO, devolvemos cierto                    						
                if (importePermiteImprimirFirmar== 'false'){
                    refExterna= document.getElementById(tablaDocu_1_1_5 + ':' + k + ':referenciaExterna').innerHTML;
                    arrayReferencias[cont]= " '" + refExterna + "'";
                    esAlgunImporteExento= true;
                    cont++;										
                }												
            }					
        }								
    }
    
    // Si, al menos, uno de los documentos seleccionados es EXENTO de pago, informamos al usuario de ello
    if(esAlgunImporteExento){
    	var msg;
    	if(cont== 1){
    	    msg = "El documento de referencia '" + refExterna + "' está EXENTO de pago,\n";
    	    msg+= "por lo que no es posible imprimirlo. Desmarque dicho documento y\n";
    	    msg+= "vuélvalo a intentar.";
    	}else{
            msg = "Los documentos de referencia " + arrayReferencias + " están EXENTOS de pago, ";
    	    msg+= "por lo que no es posible imprimirlos. Desmarque dichos documentos y vuélvalo ";
    	    msg+= "a intentar.";
        }
        
        alert(msg);
    }
	
    return esAlgunImporteExento;
}


/**
* 	Funcion que comprueba que, de los documentos que el usuario ha seleccionado en la JSF 'gestionDeDocumentos',  
* 	no haya ninguno que se haya pagado con anterioridad.                                              
*/
function ningunDocumentoYaPagado(){
    var ningunoPagado= true;
    
    // El primer registro se corresponde con el nombre de las columnas, por lo que restamos 1
    var numRows= document.getElementById(tablaDocu_1_1_5).rows.length-1;
    
    for (k= 0; k< numRows && ningunoPagado; k++){
        // Comprobamos, si el registro tiene la caja de check, la cual solo aparece cuando el modelo es correcto
	var check= document.getElementById(tablaDocu_1_1_5 + ':' + k + ':checkDocumentoUsuario');
	
	// Si existe la caja, comprobamos si está seleccionada
	if (check!= null){	    
	    var valorCheck= check.checked;
	    
	    // Si está seleccionada, comprobamos el estado del documento
	    if (valorCheck){
	    	var estadoDocumento= document.getElementById(tablaDocu_1_1_5 + ':' + k + ':estadoDocumento').value;
	        
	        // Si ya se ha pagado anteriormente el documento, devolvemos cierto
	        if(estadoDocumento== ESTADO_PAGADO || 
	           estadoDocumento== ESTADO_PENDIENTE_DE_DOCUMENTACION ||
	           estadoDocumento== ESTADO_PRESENTADO || 
                   estadoDocumento== ESTADO_NRC_ERROR){
		    ningunoPagado= false;
	        }
	    }
	}
    }
    
    return ningunoPagado;
}

/**
* 	Funcion que comprueba que, de los documentos que el usuario ha seleccionado en la JSF 'gestionDeDocumentos',  
* 	no haya ninguno que se haya firmado con anterioridad.                                             
*/
function ningunDocumentoYaFirmado(){
    var ningunoFirmado= true;
    
    // El primer registro se corresponde con el nombre de las columnas, por lo que restamos 1
    var numRows= document.getElementById(tablaDocu_1_1_5).rows.length-1;
    
    for (k= 0; k< numRows && ningunoFirmado; k++){
        // Comprobamos, si el registro tiene la caja de check, la cual solo aparece cuando el modelo es correcto
	var check= document.getElementById(tablaDocu_1_1_5 + ':' + k + ':checkDocumentoUsuario');
	
	// Si existe la caja, comprobamos si está seleccionada
	if (check!= null){	    
	    var valorCheck= check.checked;
	    
	    // Si está seleccionada, comprobamos el estado del documento
	    if (valorCheck){
	    	var estadoDocumento= document.getElementById(tablaDocu_1_1_5 + ':' + k + ':estadoDocumento').value;
	        
	        // Sólo se pueden firmar documentos que se encuentren en estado 'Correcto' o 'Impreso'
                if(estadoDocumento!= ESTADO_CORRECTO && estadoDocumento!= ESTADO_IMPRESO){
                    ningunoFirmado= false;
                }
	    }
	}
    }
    
    return ningunoFirmado;
}

/**
* 	Funcion que comprueba que, para todos los documentos seleccionados por el usuario para pagar/presentar en surnet,   
*	disponga de los permisos necesarios.                                                                    
*/
function permisoParaPagarPresentarTodos(){
    var refExterna;
    
    // Array para almacenar las referencias de los documentos que no se puedan pagar/presentar por carecer de 
    // permisos el usuario
    var arrayReferencias= new Array(); 
    
    // El primer registro se corresponde con el nombre de las columnas, por lo que restamos 1
    var numRows= document.getElementById(tablaDocu_1_1_5).rows.length-1;
    
    var permisoParaTodos= true;
    
    var cont= 0;
    	
    for (k= 0; k< numRows; k++){
        // Comprobamos, en primer lugar, si el registro tiene la caja de check, la cual solo aparece
        // cuando el modelo es correcto
        var check= document.getElementById(tablaDocu_1_1_5 + ':' + k + ':checkDocumentoUsuario');
        if (check!= null){
            var valorCheck= check.checked;

            // Si el usuario selecciono el check para pagar/presentar el modelo, comprobamos el permiso            
            if (valorCheck){
                var permiso= document.getElementById(tablaDocu_1_1_5 + ':' + k + ':permisoPermitePagarPresentar').value;
                        
                // Si no tiene permiso, recuperamos la referencia externa del documento                                
                if(permiso== 'false'){
                    refExterna= document.getElementById(tablaDocu_1_1_5 + ':' + k + ':referenciaExterna').innerHTML;
                    arrayReferencias[cont]= " '" + refExterna + "'";
                    permisoParaTodos= false;
                    cont++;
                }
            }
        }
    }
    
    // Si, al menos, para uno de los documentos seleccionados por el usuario carece de permisos, le informamos de ello
    if(!permisoParaTodos){
    	if(cont== 1){
    	    alert("El usuario carece de permisos para enviar a la Plataforma de Pago el documento de referencia \n'" + refExterna + "'.");	
    	}else{    	    
            alert("El usuario carece de permisos para enviar a la Plataforma de Pago los documentos de referencia:\n" + arrayReferencias);
        }
    }

    return permisoParaTodos;
}

/**
* 	Funcion que comprueba si, de entre los modelos seleccionados, hay alguno que nó se pueda presentar a SURNET. Esto es 
*	aplicable para los modelos 621, que se encuentran en estado EXENTO, de modo que si en el resultado       
* 	de la declaración resultó que nó se puede presentar, porque por ejemplo el caucional nó es correcto,     
* 	se le hace saber al usuario.                                                                             
*/
function sePuedenPresentar(accion){
	var todosSePuedenPresentar= true;
	
	//  El primer registro se corresponde con el nombre de las columnas, por lo que restamos 1
        var numRows= document.getElementById(tablaDocu_1_1_5).rows.length-1;
        var referencias= new Array();
        var contador= 0;
        
        for (k= 0; k< numRows; k++){
	    // Comprobamos, en primer lugar, si el registro tiene la caja de check, la cual solo aparece
	    // cuando el modelo es correcto
	    var check= document.getElementById(tablaDocu_1_1_5 + ':' + k + ':checkDocumentoUsuario');

	    if (check!= null){
	        var valorCheck= check.checked;
		
		// Si el usuario seleccionó el check para pagar el modelo, recuperamos el campo oculto que indica
		// si el modelo se puede presentar
		if (valorCheck){
		    var importePermitePagarPresentar= document.getElementById(tablaDocu_1_1_5 + ':' + k + ':importePermitePagarPresentar').value;
		    var refExterna = document.getElementById(tablaDocu_1_1_5 + ':' + k + ':referenciaExterna').innerHTML;
		    
		    if(importePermitePagarPresentar== 'false'){
		    	referencias[contador]= refExterna;
		    	contador++;
		    }
	        }
	    }
	}
		
        var mensaje= null;
	if(referencias.length> 0){
		todosSePuedenPresentar= false;
		
		if(referencias.length> 1){
		    mensaje= "Los documentos de referencia ";
		}else{
		    mensaje= "El documento de referencia ";
	        }
	
		for (j= 0; j< referencias.length; j++){
		    mensaje+= "'" + referencias[j] + "'";
		    
		    if(j< referencias.length-2){
		    	mensaje+= ", ";
		    }else if(j== referencias.length-2){
		        mensaje+= " y ";
		    }
		}
	
		if(accion== 'pagar'){
		    if(referencias.length> 1){
			mensaje+= " no se pueden presentar. Razón:\n";
		    }else{
			mensaje+= " no se puede presentar. Razón:\n";
		    }
		        
		    mensaje+= "La presentación telemática de autoliquidaciones cuya exención esté fundamentada por el ";
		    mensaje+= "artículo 45.I.B.17 del T.R. del Impuesto sobre Transmisiones Patrimoniales y Actos ";
		    mensaje+= "Jurídicos Documentados, requiere la acreditación previa por las Delegaciones ";
	            mensaje+= "Provinciales de la Consejería de Economía.";
	            
	            alert(mensaje);
	            
	        }else if(accion== 'firmar'){
	            if(referencias.length> 1){
			mensaje+= " no se pueden firmar, al estar EXENTOS de pago.";
		    }else{
			mensaje+= " no se puede firmar, al estar EXENTO de pago.";
		    }	
		    
		    alert(mensaje);
		}
	}
	
	return todosSePuedenPresentar;
}

/**
* 	Funcion que comprueba si entre los documentos que el usuario ha seleccionado en la JSF 'gestionDeDocumentos' 
* 	hay al menos uno que deba ser firmado.                                                           
*/
function hayQueFirmarDocumentos(){
    var hayQueFirmar= false;    
    
    // El primer registro se corresponde con el nombre de las columnas, por lo que restamos 1
    var numRows= document.getElementById(tablaDocu_1_1_5).rows.length-1;

    for (k= 0; k< numRows && !hayQueFirmar; k++){
        // Comprobamos, si el registro tiene la caja de check, la cual solo aparece cuando el modelo es correcto
	var check= document.getElementById(tablaDocu_1_1_5 + ':' + k + ':checkDocumentoUsuario');

	// Si existe la caja, comprobamos si está seleccionada
	if (check!= null){
	    var valorCheck= check.checked;

	    // Si está seleccionada, comprobamos el estado del documento
	    if (valorCheck){
	    	var estadoDocumento= document.getElementById(tablaDocu_1_1_5 + ':' + k + ':estadoDocumento').value;

	        // Si el documento se encuentra en estado correcto ó impreso, hay que firmarlo
	        if(estadoDocumento== ESTADO_IMPRESO){
	            hayQueFirmar= true;
	        }else if(estadoDocumento== ESTADO_CORRECTO){
                    hayQueFirmar= true;
	        }
	    }
	}
    }
    
    return hayQueFirmar;
}

/**
* 	Funcion que comprueba que, en el caso de que el usuario haya seleccionado un documento en estado 'Error Técnico en Pago', 
* 	no haya seleccionado otros documentos, ni en el mismo ni en otro estado, pues sólo se permite enviar a la     
* 	Plataforma de Pago un documento en ese estado, sin más compañía.                                              
*/
function errorTecnicoPagoOK(){
    // El primer registro se corresponde con el nombre de las columnas, por lo que restamos 1
    var numRows= document.getElementById(tablaDocu_1_1_5).rows.length-1;
    
    var docsETPagoOK= true;
    
    var contadorETP= 0;
    
    var contadorResto= 0;
	
    for (k= 0; k< numRows && docsETPagoOK; k++){
        // Comprobamos, en primer lugar, si el registro tiene la caja de check, la cual solo aparece
        // cuando el modelo es correcto
        var check= document.getElementById(tablaDocu_1_1_5 + ':' + k + ':checkDocumentoUsuario');
        if (check!= null){
            var valorCheck= check.checked;

            // Si el usuario selecciono el check para imprimir el modelo, comprobamos el estado            
            if (valorCheck){
                var estadoDocumento= document.getElementById(tablaDocu_1_1_5 + ':' + k + ':estadoDocumento').value;

                // Si el documento seleccionado se encuentra en estado 'ERROR TECNICO EN PAGO', incrementamos 
                // el contador correspondiente
                if(estadoDocumento== ESTADO_ERROR_TECNICO_EN_PAGO){
                    contadorETP++;
                }
                // Si el documento se encuentra en cualquier otro estado, incrementamos el contador correspondiente
                else{
                    contadorResto++;
                }

                // Si el usuario selección más de un documento en estado 'ERROR TECNICO EN PAGO' devolvemos false
                if(contadorETP> 1){
                    alert("No es posible enviar más de un documento en estado 'Error técnico en pago' \nde forma simultánea a la Plataforma de Pago.");
                    docsETPagoOK= false;
                }
                
                // Si el usuario selección un documento en estado 'ERROR TECNICO EN PAGO' y algún(os) otro(s) más, sea 
                // el estado que sea, devolvemos false
                if(contadorETP> 0 && contadorResto> 0){
                    alert("No es posible enviar a la Plataforma de Pago un documento en estado \n'Error técnico en pago' con documentos en otro estado.");
                    docsETPagoOK= false;
                }
            }
        }
    }
    
    return docsETPagoOK;
}

/**
 * 	Funcion que comprueba que, en el caso de que el usuario haya seleccionado documentos en estado 
 *  'Error Técnico en Presentación', no haya seleccionado otros documentos en otro estado también 
 *  para enviar a la Plataforma de Pago, pues nó está permitido.                                                                                                          
 */
function errorTecnicoPresentacionOK(){
    // El primer registro se corresponde con el nombre de las columnas, por lo que restamos 1
    var numRows= document.getElementById(tablaDocu_1_1_5).rows.length-1;
    
    var docsETPresentOK= true;
    
    var contadorETPresent= 0;
    
    var contadorResto= 0;
	
    for (k= 0; k< numRows && docsETPresentOK; k++){
        // Comprobamos, en primer lugar, si el registro tiene la caja de check, la cual solo aparece
        // cuando el modelo es correcto
        var check= document.getElementById(tablaDocu_1_1_5 + ':' + k + ':checkDocumentoUsuario');
        if (check!= null){
            var valorCheck= check.checked;

            // Si el usuario selecciono el check para imprimir el modelo, comprobamos el estado            
            if (valorCheck){
                var estadoDocumento= document.getElementById(tablaDocu_1_1_5 + ':' + k + ':estadoDocumento').value;

                // Si el documento seleccionado se encuentra en estado 'ERROR TECNICO EN PRESENTACION', incrementamos 
                // el contador correspondiente
                if(estadoDocumento== ESTADO_ERROR_TECNICO_EN_PRESENTACION){
                    contadorETPresent++;
                }
                // Si el documento se encuentra en cualquier otro estado, incrementamos el contador correspondiente
                else{
                    contadorResto++;
                }
                
                // Si el usuario seleccionó documentos en estado 'ERROR TECNICO EN PRESENTACION' y cualquier documento
                // en otro estado, sea el estado que sea, devolvemos false                
                if(contadorETPresent> 0 && contadorResto> 0){
                    docsETPresentOK= false;
                }
            }
        }
    }
    
    return docsETPresentOK;
}

// FUNCIONES DE /SURWEB/web/gestorDeDeclaraciones/comun/js/usuarios.js

// patron que se utiliza al validar el correo en los jsp
var patron_correoElectronico=/.+@.+/  // Algo seguido de @ seguido de algo

/**
* 	Funcion que comprueba que el usuario haya seleccionado en la JSF 'usuarios' un usuario                       
* 	de los que tiene en pantalla                                                                     
*/
function usuarioSeleccionado(){
    var haySeleccionado= false;
    
    // El primer registro se corresponde con el nombre de las columnas, por lo que restamos 1
    var numRows= document.getElementById('formPresentacion:tablaUsuarios').rows.length-1;
    for (k= 0; k< numRows && !haySeleccionado; k++){
        // Comprobamos, si el registro tiene la caja de check, la cual solo aparece cuando el modelo es correcto
		var check= document.getElementById('formPresentacion:tablaUsuarios:' + k + ':checkUsuario');
		// Si existe la caja, comprobamos si está seleccionada
		if (check!= null){	    
		    var valorCheck= check.checked;
		    
		    if (valorCheck){
		        haySeleccionado= true;
		    }
		}
    }
	
    
    return haySeleccionado;
}

/**
*	Funcion que comprueba que al pulsar el botón Detalle/Modificación de usuario, se haya seleccionado 
*	UNO necesariamente
*/
function mostrarDetalleUsuario(Event){
    if(Event.button== 1){	
          // Comprobamos ahora que el usuario haya seleccionado uno de los usuarios
          if(usuarioSeleccionado()){
              
          }else{
              alert("Debe seleccionar un usuario para modificar/mostrar detalle");        
          }
    }
}

/**
*	Funcion que comprueba que al pulsar el botón Copiar usuario, se haya seleccionado 
*	UNO necesariamente
*/
function copiarUsuario(Event){
    if(Event.button== 1){	
          // Comprobamos ahora que el usuario haya seleccionado uno de los usuarios
          if(usuarioSeleccionado()){
              
          }else{
              alert("Debe seleccionar un usuario para copiarlo");        
          }
    }
}

/**
*	Funcion que selecciona o deselecciona todos los checkbox de la JSF 'gestionUsuarios'
*/
function checkAllUsuarios(estado){
    for(i= 0; i< document.forms[0].elements.length; i++){
        if (document.forms[0].elements[i].type == "checkbox"){
            if(document.forms[0].elements[i].name.indexOf('checkUsuario')!= -1){
	        document.forms[0].elements[i].checked= estado;
	    }
        }						
    }
}

/************************************************************************************************/
/* Comprueba que sólo haya seleccionado en todo momento un único check en la JSF de 'usuarios'. */
/************************************************************************************************/
var campoSelec;
function unCheckUsuario(campo){
    // Si ya había seleccionado algún check
    if(campoSelec){
    	// Si son distintos los checks, deseleccionamos el anterior y asignamos el anterior al nuevo
    	if(campo.id!= campoSelec.id){        
            campoSelec.checked= false;
            campoSelec= campo;
        }
    }
    // Si nó había seleccionado ninguno, le asignamos el actual
    else{
        campoSelec= campo;
    }
}

/**
*	Funcion que actualiza un permiso de usuario
*/
function actualizar(rowIndex) {
		var elementoModelo = document.getElementById('formPresentacion:tablaPermisos:'+rowIndex+':modeloVersion');
		var elementoCheck = document.getElementById('formPresentacion:tablaPermisos:'+rowIndex+':checkConsulta');
		if(elementoModelo.value != ""){
			if(elementoCheck.checked){
				if(confirm("Se dispone a modificar el permiso, ¿Esta Ud. seguro?")) {			
					return true;
				} else{
					return false;
				}
			}else{
				alert("Debe de seleccionar consulta para poder asignar el permiso");
				return false;
			}
		}else{
			alert("Debe de seleccionar un modelo para asignar");
			return false;
		}
		return false;
}

/**
*	Funcion que asigna un permiso a un usuario 
*/	
function asignar(rowIndex) {
	var elementoCheck = document.getElementById('formPresentacion:tablaPermisos:'+rowIndex+':checkConsulta');
	if(elementoCheck.checked){
		return true;
	}else{
		alert("Debe de seleccionar consulta para poder asignar el permiso");
		return false;
	}
}

/**
*	Funcion que desactiva un usuario
*/
function desactivarUsuario(usuario){
	respuesta = confirm("¿Realmente desea desactivar el usuario '"+usuario+"'?");
	
	return respuesta;
}

/**
*	Funcion que activa un usuario
*/
function activarUsuario(usuario){
	respuesta = confirm("¿Realmente desea activar el usuario '"+usuario+"'?");
	
	return respuesta;
}

/**
*	Funcion que bloquea un usuario
*/
function bloquearUsuario(usuario){
	respuesta = confirm("¿Realmente desea bloquear el usuario '"+usuario+"'?");
	
	return respuesta;
}

/**
*	Funcion que desbloquea un usuario
*/
function desbloquearUsuario(usuario){
	respuesta = confirm("¿Realmente desea desbloquear el usuario '"+usuario+"'?");
	
	return respuesta;
}

/**
*	Funcion que elimina un usuario
*/
function eliminarUsuario(usuario) {
	respuesta = confirm("¿Realmente desea eliminar el usuario '"+usuario+"'?");
	
	return respuesta;
	
}

/**
*	Funcion que modifica el valor de un permiso seleccionado
*/
function cambioValorSelectModelo(valor){
	//Guardamos el valor del elemento seleccionado en un campo hidden
	document.getElementById('formPresentacion:nuevoValorPermisoSeleccionado').value = valor;
    document.getElementById('formPresentacion:botonOcultoModelo').click(); 
}

/**
*	Funcion que modifica el valor de un concepto seleccionado
*/
function cambioValorSelectConcepto(valor){
	//Guardamos el valor del elemento seleccionado en un campo hidden
	document.getElementById('formPresentacion:nuevoValorConceptoSeleccionado').value = valor;
    document.getElementById('formPresentacion:botonOcultoConcepto').click(); 
}

/**
*	Funcion que modifica el valor de un organismo seleccionado
*/
function cambioValorSelectOrganismo(valor){
	//Guardamos el valor del elemento seleccionado en un campo hidden
	document.getElementById('formPresentacion:nuevoValorOrganismoSeleccionado').value = valor;
    document.getElementById('formPresentacion:botonOcultoOrganismo').click(); 
}

/**
*	Funcion que modifica el valor de un nuevo permiso seleccionado
*/
function cambioValorSelectModeloNuevo(valor){
	//Guardamos el valor del elemento seleccionado en un campo hidden
	document.getElementById('formPresentacion:nuevoValorPermisoSeleccionado').value = valor;
    document.getElementById('formPresentacion:botonOcultoModeloNuevo').click(); 
}

/**
*	Funcion que modifica el valor de un nuevo concepto seleccionado
*/
function cambioValorSelectConceptoNuevo(valor){
	//Guardamos el valor del elemento seleccionado en un campo hidden
	if(document.getElementById('formPresentacion:modeloVersionNuevo').value != ''){
		if(document.getElementById('formPresentacion:conceptoNuevo').value != 'TODOS'){
				document.getElementById('formPresentacion:nuevoValorConceptoSeleccionado').value = valor;
			    document.getElementById('formPresentacion:botonOcultoConceptoNuevo').click(); 
		}
	} else {
		alert('Debe seleccionar un modelo antes de elegir el concepto');
	} 
}

/**
*	Funcion que modifica el valor de un nuevo organismo seleccionado
*/
function cambioValorSelectOrganismoNuevo(valor){
	if(document.getElementById('formPresentacion:modeloVersionNuevo').value != ''){
		if(document.getElementById('formPresentacion:codigoTerritorialNuevo').value != 'TODOS'){
				//Guardamos el valor del elemento seleccionado en un campo hidden
				document.getElementById('formPresentacion:nuevoValorOrganismoSeleccionado').value = valor;
			    document.getElementById('formPresentacion:botonOcultoOrganismoNuevo').click(); 
	    } 
	} else {
		alert('Debe seleccionar un modelo antes de elegir el organismo');
	} 
}

/**
*	Funcion que borra un nuevo permiso seleccionado
*/
function borrarPermiso(){
	respuesta = confirm('Se dispone a borrar el permiso ¿Esta Ud. seguro?');
	return respuesta;
}

/******************************************************************************************/
/* Se encarga de resaltar y reestablecer a sus valores normales aquel registro de la JSF  */
/* 'usuarios' sobre el que se pase el ratón.                                              */
/******************************************************************************************/
function resaltaUsuario(numReg, evento){
    
    var elemNifUsuario = document.getElementById("formPresentacion:tablaUsuarios:" + numReg + ":nifUsuario");   
	
    if(evento== 0){
        elemNifUsuario.style.textDecoration    ='underline';
    }else{
 	elemNifUsuario.style.textDecoration    ='none';
    }
}

// Funciones de /SURWEB/web/modelos/comun/js/modelos.js

/**
*	Funcion que muestra la seccion de ayuda
*/
function muestraAyuda() { 
	var div;
	var boton;
		  
	div=document.getElementById("botonesAyuda");
	div.style.display="block";
	div=document.getElementById("botonesApartados");
	div.style.display="none";	   
	boton=document.getElementById("botonApartados");
	boton.className="";
	boton=document.getElementById("botonAyuda");
	boton.className="select";		   
}

/**
*	Funcion que muestra la seccion de apartados
*/
function muestraApartados()
{ 
	var div;
	var boton;
	div=document.getElementById("botonesAyuda");
	div.style.display="none";
	div=document.getElementById("botonesApartados");
	div.style.display="block";
	boton=document.getElementById("botonApartados");
	boton.className="select";
	boton=document.getElementById("botonAyuda");
	boton.className="";	  
}


// FUNCIONES DE /SURWEB/web/modelos/modelo806/construccion.js

/**
*	Funcion que carga Arrendador
*/
function cargaArrendador(){	
		var url ='/modelos/modelo806/arrendador.jsp';
		var numeroArrendador  = new Number( $('nArrendadores').value )+ 1;
		var params ='numArrendador='+numeroArrendador ;
		incluirFragmentoConContador('botoneraArrendador',url+"?"+params, $('nArrendadores'), 10, "NO SE PUEDEN AÑADIR MÁS ARRENDADORES");
		//alert($j('#botoneraDeclarante').offset().top);
}

/**
*	Funcion que borra Arrendador
*/
function borrarArrendador(){
	borrarFragmento(["cabeceraArrendador"+$('nArrendadores').value,"ARRENDADOR"+$('nArrendadores').value],$('nArrendadores'),1,"NO SE PUEDEN ELIMINAR MÁS ARRENDADORES");
}


/**
*	Funcion que carga Arrendatario
*/
function cargaArrendatario(){
		var url ='/modelos/modelo806/arrendatario.jsp';
		var numeroArrendatario  = new Number( $('nArrendatarios').value )+ 1;
		var params ='numArrendatario='+numeroArrendatario ;
		incluirFragmentoConContador('botoneraArrendatario',url+"?"+params, $('nArrendatarios'), 10, "NO SE PUEDEN AÑADIR MÁS ARRENDATARIOS");
}


/**
*	Funcion que borra Arrendatario
*/
function borrarArrendatario(){
	borrarFragmento(["cabeceraArrendatario"+$('nArrendatarios').value,"ARRENDATARIO"+$('nArrendatarios').value],$('nArrendatarios'),1,"NO SE PUEDEN ELIMINAR MÁS ARRENDATARIOS");
}






// FUNCIONES DE /SURWEB/web/modelos/modelo600/construccion.js

/**
*	Funcion que carga los declarantes del modelo 600
*/
function cargaDeclarante(){	
		var url ='/modelos/modelo600/declarante.jsp';
		var numeroDeclarante  = new Number( $('h1c082').value )+ 1;
		var params ='numDeclarante='+numeroDeclarante ;
		incluirFragmentoConContador('botoneraDeclarante',url+"?"+params, $('h1c082'), 10, "NO SE PUEDEN AÑADIR MÁS DECLARANTES");
		//alert($j('#botoneraDeclarante').offset().top);
}

/**
*	Funcion que borra declarantes
*/
function borrarDeclarante(){
	borrarFragmento(["cabeceraDeclarante"+$('h1c082').value,"DECLARANTE"+$('h1c082').value],$('h1c082'),1,"NO SE PUEDEN ELIMINAR MÁS DECLARANTES");
}

/**
*	Funcion que carga los transmitentes del modelo 600
*/
function cargaTransmitente(){
		var url ='/modelos/modelo600/transmitente.jsp';
		var numeroTransmitente  = new Number( $('h1c084').value )+ 1;
		var params ='numTransmitente='+numeroTransmitente ;
		incluirFragmentoConContador('botoneraTransmitente',url+"?"+params, $('h1c084'), 10, "NO SE PUEDEN AÑADIR MÁS TRANSMITENTES");
}

/**
*	Funcion que borra transmitentes del modelo 600
*/
function borrarTransmitente(){
	borrarFragmento(["cabeceraTransmitente"+$('h1c084').value,"TRANSMITENTE"+$('h1c084').value],$('h1c084'),1,"NO SE PUEDEN ELIMINAR MÁS TRANSMITENTES");
}

/**
*	Funcion que carga un bien del modelo 600
*/
function cargaBien(){		
		var tipoBien = $('tipoBien').value;
		if (tipoBien!='')
		{
			var dialogo = '';
			if(tipoBien == 'U')
				dialogo = $('dialogoUrbano').value;
			if(tipoBien == 'R')
				dialogo = $('dialogoRustico').value;
			if(tipoBien == 'O')
				dialogo = $('dialogoOtros').value;
	
			var numeroBien  = new Number( $('numBienes').value )+ 1;
			var params ='numBien='+numeroBien+'&tipoBien='+tipoBien+'&dialogo='+dialogo;
			var url ='/modelos/modelo600/bienes.jsp';
			incluirFragmentoConContador('botoneraBienes',url+"?"+params, $('numBienes'), 10, "NO SE PUEDEN AÑADIR MÁS BIENES");
		}
}

/**
*	Funcion que borra un bien del modelo 600
*/
function borrarBien(){
	borrarFragmento(["cabeceraBien"+$('numBienes').value,"BIEN"+$('numBienes').value],$('numBienes'),0,"NO SE PUEDEN ELIMINAR MÁS BIENES");
}

/**
 * Función que autocompleta la casilla de descripcion de concepto
 * 
 * @param casilla
 */
function autocompletarDescripcionConcepto(casilla){
	if(esVacio(casilla)){
		alert("Debe introducir una fecha de devengo");
		return
	}
	var nombreCampoDescripcion=casilla;
	var campoDescripcion=$("h1c004");
	ocultarResultados(campoDescripcion);
	autocompletarCampo("h1c004",
			"buscarDescripcionConcepto.jsp",
			formatearDescripcionConcepto,{'casilla':casilla}); 
}

/**
 * Función que autocompleta la casilla de descripcion de concepto del modelo 046, boton lupa
 * 
 */
function autocompletarDescripcionConcepto046Lupa(){	
	var codterri = $("h1c000").value;
	var fdevengo = $("h1c002").value;
	if(fdevengo==null || fdevengo==''){
		alert("Debe rellenar la Fecha de Devengo");
	}else if(codterri==null || codterri==''){
		alert("Debe rellenar el Código Territorial");
	}else{
		autocompletarDescripcionConcepto046();
	}
	
}




/**
 * Función que autocompleta la casilla de descripcion de concepto del modelo 046
 * 
 */
function autocompletarDescripcionConcepto046(){	
	var codterri = $("h1c000").value;	
	var fdevengo = $("h1c002").value;
	if(codterri==null || codterri=='' || fdevengo==null || fdevengo==''){
		return;
	}else{
		var codigoOrgano = codterri.substring(0,2);
		var campoDescripcion=$("h1c004_1");
		var devengo=$("h1c002");
		ocultarResultados(campoDescripcion);
		autocompletarCampo("h1c004_1",
				"buscarDescripcionConcepto046.jsp",
				formatearDescripcionConcepto046,{'casilla':codigoOrgano,'fechaDevengo':fdevengo}); 
	}
	
}

/**
 * Función que autocompleta la casilla de descripcion de concepto del modelo 046
 * 
 */
function autocompletarDescripcionConcepto046Actualiza(){	
	$("h1c004").value="";
	$("h1c004_1").value="";
	$("h1c004descripcion").value="";
	autocompletarDescripcionConcepto046();
	
}

/**
 * Función que autocompleta la casilla de descripcion de concepto de los modelos 800
 * 
 * @param modelo: Modelo del que se quiere obtener la descrion del concepto
 */
function autocompletarDescripcionConcepto800(modelo){	
	var campoDescripcion=$("h1c004Descripcion");
	ocultarResultados(campoDescripcion);
	autocompletarCampo("h1c004Descripcion",
			"../../modelos/comun/buscarDescripcionConcepto800.jsp",
			formatearDescripcionConcepto800,{'valor':modelo}); 
}

/**
* Funcion que autocompleta el notario
*/

function autocompletarNotario(casilla){
	
	var nombreCampoNotario=casilla;
	var campoNotario=$(casilla);
	ocultarResultados(campoNotario);
	
	var esPublico = document.forms[0].h1c045.checked;
	var comboProvincia = document.forms[0].elements["h1c049"];
	var provincia = comboProvincia.options[comboProvincia.selectedIndex].value;
	var municipio = document.forms[0].h1c048.value;
	var fechaDevengo = document.forms[0].h1c002.value;
	var concepto = document.forms[0].h1c004.value;
	
	if(!esPublico || esVacio(provincia) || esVacio(municipio) || esVacio(fechaDevengo) || !esFormatoFechaCorrecto(fechaDevengo)){
	campoNotario.value='';
	return;
	}
	
	campoNotario.value='';
	
	autocompletarCampo(nombreCampoNotario,
			"buscarNotarios.jsp",
			formatearNotariosModelo600,{'provincia':provincia,
								'municipio':municipio,
								'fechaDevengo':fechaDevengo,
								'casilla':casilla,
								'concepto':concepto}); 
}



/**
*	Funcion que autocompleta la Autoridad Ordenante
*/
function autocompletarAutoridadOrdenante(casilla){

	var nombreCampoNotario=casilla;
	var campoNotario=$(casilla);

	ocultarResultados(campoNotario);

	var esPublico = document.forms[0].h1c045.checked;
	var comboProvincia = document.forms[0].elements["h1c049"];
	var provincia = comboProvincia.options[comboProvincia.selectedIndex].value;
	var municipio = document.forms[0].h1c048.value;
	var fechaDevengo = document.forms[0].h1c002.value;
	var concepto = document.forms[0].h1c004.value;

	if(!esPublico || esVacio(provincia) || esVacio(municipio)){
	campoNotario.value='';
	return;
	}

	campoNotario.value='';

	autocompletarCampo(nombreCampoNotario,
					"buscarAutOrdenante.jsp",
					formatearAutOrdenante,
					{'provincia':provincia,
					'municipio':municipio,
					'casilla':casilla, 
					'concepto':concepto,
					'fechaDevengo':fechaDevengo}); 
}

/**
 *  Funcion que realiza la carga del evento de autocompletado en el caso
 * 	de que el formulario tenga algún valor (ej: a la vuelta de validaciones)
 */
function autocompletarNotarioVuelta(campo) {
	
	if ($(campo).autocompleter==null) {
		// Guardamos el valor del campo (porque se pierde al cargar el evento)
		var valorAnterior=$(campo).value;
		
		//$j('#h1c047').focus();
		autocompletarNotario(campo);
		
		//Restauramos el valor del campo
		$(campo).value=valorAnterior;
	}
}

/**
 *  Funcion que realiza la carga del evento de autocompletado en el caso
 * 	de que el formulario tenga algún valor (ej: a la vuelta de validaciones)
 */
function autocompletarAutoridadOrdenanteVuelta(campo) {
	if ($(campo).autocompleter==null) {
		// Guardamos el valor del campo (porque se pierde al cargar el evento)
		var valorAnterior=$(campo).value;
		
		//$j('#h1c047').focus();
		autocompletarAutoridadOrdenante(campo);
		
		//Restauramos el valor del campo
		$(campo).value=valorAnterior;
	}
}

function formatearDescripcionConcepto800(row) 
{	
	if(row[0] != undefined){
		if(row[1] == 'No se han encontrado descripciones de conceptos para este modelo.') {
			document.forms[0].elements['h1c004Descripcion'].style.color="red";
			return "<font color='red'><b>"+row[0]+"</b></font>";
		} else {
			document.forms[0].elements['h1c004Descripcion'].style.color="000000";
			var dollar = row[0].indexOf('$');
			if(dollar>0){
				var cad = row[0].substring(0,dollar);
				return "<b>"+cad+"</b><br>";
			}else{
				var cad = row[0];
				return "<b>"+cad+"</b><br>";
			}
			
		}
	} 
}

/**
*	Funcion que formatea correctamente la descripcion de los conceptos
*/
function formatearDescripcionConcepto(row) {	
	//return row[1] + "<br><i>" + row[2] + "</i>";
	if(row[0] != undefined && row[2] != undefined){
		if(row[1] == 'No se han encontrado descripciones de conceptos para este modelo.') {
			document.forms[0].elements['h1c004'].style.color="red";
			return "<font color='red'><b>"+row[0]+"</b><br><i>" + row[2] + "</i></font>";
		} else {
			document.forms[0].elements['h1c004'].style.color="000000";
			return "<b>"+row[0]+"</b><br><i>" + row[2] + "</i>";
		}
	} 
}

/**
*	Funcion que formatea correctamente la descripcion de los conceptos
*/
function formatearDescripcionConcepto600(row) {	
	//return row[1] + "<br><i>" + row[2] + "</i>";
	if(row[0] != undefined && row[2] != undefined){
		if(row[1] == 'No se han encontrado descripciones de conceptos para este modelo.') {
			document.forms[0].elements['h1c004'].style.color="red";
			return "<font color='red'><b>"+row[0]+"</b><br><i>" + row[2] + "</i></font>";
		} else {
			document.forms[0].elements['h1c004'].style.color="000000";
			var almohadilla = row[0].indexOf('#');
			if(almohadilla>0){
				var cad = row[0].substring(0,almohadilla);
				return "<b>"+cad+"</b><br><i>" + row[2] + "</i>";
			}else{
				var cad = row[0];
				return "<b>"+cad+"</b><br><i>" + row[2] + "</i>";
			}
			
		}
	} 
}

/**
*	Funcion que formatea correctamente la descripcion de los conceptos
*/
function formatearDescripcionConcepto046(row) {	
	//return row[1] + "<br><i>" + row[2] + "</i>";
	if(row[0] != undefined && row[2] != undefined){
		if(row[1] == 'No se han encontrado descripciones de conceptos para este modelo.') {
			document.forms[0].elements['h1c004_1'].style.color="red";
			return "<font color='red'><b>"+row[0]+"</b><br><i>" + row[2] + "</i></font>";
		} else {
			document.forms[0].elements['h1c004_1'].style.color="000000";
			var arroba = row[0].indexOf('@');
			if(arroba>0){
				var cad = row[0].substring(0,arroba);
				return "<b>"+cad+"</b><br><i>" + row[2] + "</i>";
			}else{
				var cad = row[0];
				return "<b>"+cad+"</b><br><i>" + row[2] + "</i>";
			}
			
		}
	} 
}


/**
*	Funcion que formatea correctamente los notarios
*/
function formatearNotariosModelo600(row) {	
	//return row[1] + "<br><i>" + row[2] + "</i>";
	if(row[1] != undefined && row[2] != undefined){
		if(row[0] == 'No existen notarios en la población seleccionada') {
			document.forms[0].elements['h1c047'].style.color="red";
			return "<font color='red'><b>"+row[1]+"</b><br><i>" + row[2] + "</i></font>";
		} else {
			document.forms[0].elements['h1c047'].style.color="000000";
			return "<b>"+row[1]+"</b><br><i>" + row[2] + "</i>";
		}
	} 
}

/**
*	Funcion que formatea correctamente las Autoridades Ordenantes
*/
function formatearAutOrdenante(row) {	
	
	if(row[1] != undefined && row[0] == 'No existen autoridades ordenantes en la población seleccionada') {
		document.forms[0].elements['h1c162'].style.color="red";
		return "<font color='red'><b>"+row[1]+"</b><br></font>";
	} else {
		document.forms[0].elements['h1c162'].style.color="000000";
		return "<b>"+row[0]+"</b><br>";
	}
	
	 
}

/**
*	Funcion que bloquea la posibilidad de introducion valores en un campo
*/
function noIntroducirValores(event){
	return false;
}

/**
*	Funcion que muestra los mensajes de advertencia en caso de que no se hayan completado 
*	alguno de los campos obligatorios
*/
function validarNotario(casilla){
	//Hacer las comprobaciones 
	var esPublico = document.forms[0].h1c045.checked;
 	var comboProvincia = document.forms[0].elements["h1c049"];
	var provincia = comboProvincia.options[comboProvincia.selectedIndex].value;
	var municipio = document.forms[0].h1c048.value;
	var fechaDevengo = document.forms[0].h1c002.value;
	if(!esPublico)
		alert("Debe seleccionar la opción Documento Público");
	else if(esVacio(provincia))
		alert("Debe seleccionar una provincia");
	else if(esVacio(municipio))
		alert("Debe seleccionar un municipio");
	else if (esVacio(fechaDevengo)){
		alert("Debe introducir una fecha de devengo");
	} else if (!esFormatoFechaCorrecto(fechaDevengo)){
		alert("La fecha de devengo no tiene un formato correcto");
	} else{
			
			if(document.forms[0].h1c162.value !=''){
				alert("Ya hay seleccionado una Autoridad Ordenante");
			}
			else {
				bloquearAutoridadOrdenante();
				desBloquearNotarioFedatario();
				autocompletarNotario(casilla);	
			}
		}
}



/**
*	Funcion que muestra los mensajes de advertencia en caso de que no se hayan completado 
*	alguno de los campos obligatorios
*/
function validarAutoridadOrdenante(casilla){
	//Hacer las comprobaciones 
	var esPublico = document.forms[0].h1c045.checked;
 	var comboProvincia = document.forms[0].elements["h1c049"];
	var provincia = comboProvincia.options[comboProvincia.selectedIndex].value;
	var municipio = document.forms[0].h1c048.value;
	
	if(!esPublico)
		alert("Debe seleccionar la opción Documento Público");
	else if(esVacio(provincia))
		alert("Debe seleccionar una provincia");
	else if(esVacio(municipio))
		alert("Debe seleccionar un municipio");
	else{
		if(document.forms[0].h1c047.value !=''){
			alert("Ya hay seleccionado un Notario");
		}
		else {
			bloquearNotarioFedatario();
			desBloquearAutoridadOrdenante();
			autocompletarAutoridadOrdenante(casilla);	
		}
	}
}



/**
*	Funcion que muestra muestra la ventana de error con el texto 
* 	con el mensaje de error pasado como parámetro
*/
function muestraVentanaErrorMensaje(error) {
	
	
	var nueva =	window.open('../../comun/msg_error.jsp?msgError='+error, '', 'resizable=no, toolbar=no, scrollbars=no, status=no, alwaysRaised=no, width=300, height=175');	
}

/** INICIO DEL CONJUNTO DE FUNCIONES COMUNES DE LOS MODELOS 801,802,803,804 Y 805 **/

/**
*  Función que comprueba si el campo quer recibe como parametro de entrada es o no un Nif o Cif.
*  Dependiendo de si lo es o no, se habilitara o se dejara de Solo Lectura.
* 
*/
function compruebaSiEsNifCif(campo) {
	var longCampo= campo.value.length; 
	
	// Si es nif/cif, habilitamos el campo denominacion y nos situamos en ?l
	if (esNifCif(longCampo)) {
		document.getElementById("h1c033").readOnly=false;
		document.getElementById("h1c033").style.background="#ffffff";
		document.getElementById("h1c033").select(); 
	} else {
		document.getElementById("h1c033").readOnly=true;
		document.getElementById("h1c033").style.background="#dddddd"; 
		document.getElementById("h1c034").focus();
	} 
	
	document.getElementById("h1c033").value="";
}


/**
*  Función que comprueba si el campo quer recibe como parametro de entrada es o no un Nif o Cif.
*  Dependiendo de si lo es o no, se habilitara o se dejara de Solo Lectura.
*/
function compruebaSiNifCifEnOnLoad() {
	var valorCampo= document.getElementById("h1c032").value;
	
	if (esNifCif(valorCampo.length)) {
		document.getElementById("h1c033").readOnly=false;
		document.getElementById("h1c033").style.background="#ffffff"; 
	}
	else{
		document.getElementById("h1c033").readOnly=true;
		document.getElementById("h1c033").style.background="#DDDDDD"; 
	}

}

/**
*  Función que comprueba si el presunto nif o cif consta de 9 caracteres [N? valida si es o no correcto]
* 
*/
function esNifCif(cadenaAComprobar) {
	var esNifCif= false; 
	if (cadenaAComprobar== 9) {
		esNifCif= true;
	}

	return esNifCif;
}

var codigo;
	var centro;
	
	function actualizaCodigo(){
		if(document.forms[0].h1c032_3.selectedIndex == -1 || document.forms[0].h1c032_3.selectedIndex == 0){
			codigo = document.forms[0].h1c032_3.value;
			centro = "";
			// Si ha introducido un nif o cif, habilitamos el campo denominacion
			if(codigo.length> 0){
				document.forms[0].h1c033.readOnly=false;
				document.forms[0].h1c033.style.background="#ffffff"; 
				document.forms[0].h1c033.focus();
			}
		}else{
			codigo = document.forms[0].h1c032_3[document.forms[0].h1c032_3.selectedIndex].value;
			centro = document.forms[0].h1c032_3[document.forms[0].h1c032_3.selectedIndex].text;
			document.forms[0].h1c033.readOnly=true;
			document.forms[0].h1c033.style.background="#dddddd"; 
		}
		
		/*
        CRS006: Por petición expresa, se añade el órgano de Agencia Tributaria de Andalucía. 
        Tanto la insercción como el tratamiento de dicho órgano se hace de forma manual
        El código de Agencia tributaria es TA, pero tanto en PDF como en formulario se mostrará EH
        Para diferenciarla a la hora de tratamiento de CHAP (tambien tiene código EH) añadimos un espacio
        */
		if(document.forms[0].h1c032.value.substring(0,3) == ' EH'){
			document.forms[0].h1c032.value = " EH"+document.forms[0].h1c032_3[document.forms[0].h1c032_3.selectedIndex].value.substring(2);
		}else{
			document.forms[0].h1c032.value = codigo;
		}
		
		document.forms[0].h1c033.value = centro;
		
		
	
		if(document.forms[0].h1c032.value !=""){
			document.forms[0].esNif.value = "si";
		}else{
			document.forms[0].esNif.value = "no";
		}
	}
	
	
	function compruebaCifDenominacion(){
		if(document.forms[0].h1c032_1.selectedIndex == 0){
		 	habilitaCIF();
		 	deshabilitaDenominacion();
		}else{ 
			deshabilitaCIF(); 
			deshabilitaDenominacion(); 
		}
	}
	
	function habilitaCIF(){
		document.forms[0].h1c032.value ="";
		
		for (m=document.forms[0].h1c032_2.options.length-1;m>=0;m--){
			document.forms[0].h1c032_2.options[m]=null;
		}
			
		for (m=document.forms[0].h1c032_3.options.length-1;m>=0;m--){
			document.forms[0].h1c032_3.options[m]=null;
		} 
	}
	
	function habilitaDenominacion(){
		
		document.forms[0].h1c033.style.background="white"; 
		document.forms[0].h1c033.readonly=false;
	}
	
	function deshabilitaCIF(){
		document.forms[0].h1c032.value="";
	}
	
	function deshabilitaDenominacion(){
		document.forms[0].h1c033.value="";
		document.forms[0].h1c033.readonly=true;
		document.forms[0].h1c033.style.background="#DDDDDD"; 
	}
	
	
	function cargarCodigoProvincia()
	{   
		recargarCombos(['h1c032_2'], 'modelos.modelo801.Modelos800Ajax.cargarCodigosProvincia',[annoActual,$('h1c032_1').value]);
	}
	
	function cargarCodigoCentro()
	{   
		recargarCombos(['h1c032_3'], 'modelos.modelo801.Modelos800Ajax.cargarCodigoCentro',[annoActual,$('h1c032_1').value,$('h1c032_2').value]);
	}
	
	function limpiarSelect(campo){
        	        	
        	for (m=document.getElementById(campo).options.length-1;m>=0;m--){
				document.getElementById(campo).options[m]=null;
			}
				
			for (m=document.getElementById(campo).options.length-1;m>=0;m--){
				document.getElementById(campo).options[m]=null;
			}
        	
        }
	
	
     
     function AJAXCrearObjeto(){  
			var obj;  
			// Compatibilidad con FIREFOX
			if(typeof(XMLHttpRequest) != 'undefined'){
		    	try{
		    		obj = new XMLHttpRequest();
		    	}
		    	catch(e){
		    		alert('El navegador es Firefox y no está soportado');   
		    	}
		  	} else{	
				if(window.XMLHttpRequest) { // no es IE  
					obj = new XMLHttpRequest();  
				} else { // Es IE o no tiene el objeto  
					try {  
						obj = new ActiveXObject("Microsoft.XMLHTTP");  
					}  
					catch (e) {  
						alert('El navegador utilizado no está soportado');  
					}  
				}  
			}
			return obj;  
		}  
		
    function cargaDescripcion() { 
		var ajax = AJAXCrearObjeto();
		/*
        CRS006: Por petición expresa, se añade el órgano de Agencia Tributaria de Andalucía. 
        Tanto la insercción como el tratamiento de dicho órgano se hace de forma manual
        El código de Agencia tributaria es TA, pero tanto en PDF como en formulario se mostrará EH
        Para diferenciarla a la hora de tratamiento de CHAP (tambien tiene código EH) añadimos un espacio.
        Por lo tanto, si empieza por " EH", realmente es TA
        */
		var patron = /^\s/;
		var campo = document.formulario.h1c032.value;
		var codigo;				
		if ((campo.match(patron)) && (campo!='')){
			codigo = 'TA'+campo.substring(3);
		}else{
			codigo = campo;
		}
		ajax.open("GET","../comun/cargaDescripcionTerritorial.jsp?codigoTer="+codigo, true); 
		ajax.onreadystatechange = function() { 
		  	if (ajax.readyState==4) { 
				// Obtengo la descripción escrita en la jsp cargaDescripcionTerrirorial, y elimino la coma y lo que halla delante de ella 	
				var datos = ajax.responseText.split("|"); 
				// Llamamos a la función que escribe la descripción en la casilla h1c033 
				escribeDescrip(datos[1]); 
		  	} 
		} 
		ajax.send(null); 
	} 
	
	function escribeDescrip (dato){
		document.getElementById("h1c033").value = dato;
	}
	
	function actualizaDenominacion(){
		if (document.formulario.h1c032.value != "" && !esNifCif((document.formulario.h1c032.value).length)){
			cargaDescripcion();	
			setTimeout ('cargaSelects()', 400);
		}
		else{
			if(esNifCif((document.formulario.h1c032.value).length))
			{
				limpiarSelects();
			}
		}
	}
	
	function limpiarSelects()
	{
		document.formulario.h1c032_1.options.selectedIndex = 0;
		limpiarSelect('h1c032_2');
		limpiarSelect('h1c032_3');
	}
		
	function cargaSelects(){
		
		if(document.formulario.h1c033.value != 'NO ENCONTRADO'){
			
				/*
		        CRS006: Por petición expresa, se añade el órgano de Agencia Tributaria de Andalucía. 
		        Tanto la insercción como el tratamiento de dicho órgano se hace de forma manual
		        El código de Agencia tributaria es TA, pero tanto en PDF como en formulario se mostrará EH
		        Para diferenciarla a la hora de tratamiento de CHAP (tambien tiene código EH) añadimos un espacio.
		        Por lo tanto, si empieza por " EH", realmente es TA
		        */
				var patron = /^\s/;
				var campo = document.formulario.h1c032.value;
				var codigo;				
				if ((campo.match(patron)) && (campo!='')){
					codigo = 'TA';
				}else{
					codigo = document.formulario.h1c032.value.substr(0,2);
				}
			
				for(j=0;j<document.formulario.h1c032_1.options.length;j++){
				
					if(document.formulario.h1c032_1.options[j].value == codigo){
						
						document.formulario.h1c032_1.options.selectedIndex = j;
					}
				}	
				//El setTimeOut se pone xq al no estar sincronizadas, las consultas en ajax tardan mas en realizarse que las otras funciones
				cargarCodigoProvincia();
				setTimeout ('cargaProvincia()', 1000);
				setTimeout ('cargarCodigoCentro()', 1000);
				setTimeout ('cargaCodigoCentro()', 1500);
		}
		else{
			limpiarSelects();
		}	
		
	}
		
		
		
	
	function cargaProvincia()
	{
		/*
        CRS006: Por petición expresa, se añade el órgano de Agencia Tributaria de Andalucía. 
        Tanto la insercción como el tratamiento de dicho órgano se hace de forma manual
        El código de Agencia tributaria es TA, pero tanto en PDF como en formulario se mostrará EH
        Para diferenciarla a la hora de tratamiento de CHAP (tambien tiene código EH) añadimos un espacio.
        Por lo tanto, si empieza por " EH", realmente es TA
        */	
		var patron = /^\s/;
		var campo = document.formulario.h1c032.value;
		var codigo;
		
		if ((campo.match(patron)) && (campo!='')){
			codigo = document.formulario.h1c032.value.substr(3,2);
		}else{
			codigo = document.formulario.h1c032.value.substr(2,2);
		}
		for(j=0;j<document.formulario.h1c032_2.options.length;j++){
			if(document.formulario.h1c032_2.options[j].value == codigo){				
				document.formulario.h1c032_2.options.selectedIndex = j;
			}
			
		}
	}
	
	function cargaCodigoCentro(){
		
		/*
        CRS006: Por petición expresa, se añade el órgano de Agencia Tributaria de Andalucía. 
        Tanto la insercción como el tratamiento de dicho órgano se hace de forma manual
        El código de Agencia tributaria es TA, pero tanto en PDF como en formulario se mostrará EH
        Para diferenciarla a la hora de tratamiento de CHAP (tambien tiene código EH) añadimos un espacio.
        Por lo tanto, si empieza por " EH", realmente es TA
        */
		var patron = /^\s/;
		var campo = document.formulario.h1c032.value;
		var codigo;
		
		if ((campo.match(patron)) && (campo!='')){
			codigo = 'TA'+campo.substring(3);
		}else{
			codigo = campo;
		}
		for(j=0;j<document.formulario.h1c032_3.options.length;j++){
			
			if(document.formulario.h1c032_3.options[j].value == codigo){
				
					document.formulario.h1c032_3.options.selectedIndex = j;
			}
			
		}
		
	}
	
	function validaTecla(e){
			var key;
			if (e.keyCode)
				key = e.keyCode;
			else
				key = e.which;
				
			if (13 == key){
				document.forms[0].h1c035.focus();
				return false;
			}
			return true;	
		}
		
	function insertaCodigoOrganoTerritorial(valor)
	{
		/*
        CRS006: Por petición expresa, se añade el órgano de Agencia Tributaria de Andalucía. 
        Tanto la insercción como el tratamiento de dicho órgano se hace de forma manual
        El código de Agencia tributaria es TA, pero tanto en PDF como en formulario se mostrará EH
        Para diferenciarla a la hora de tratamiento de CHAP (tambien tiene código EH) añadimos un espacio.
        Por lo tanto, si empieza por " EH", realmente es TA
        */
		if(valor == 'TA'){
			document.formulario.h1c032.value = ' EH';
		}else{
			document.formulario.h1c032.value = valor;
		}
		document.formulario.h1c033.value = '';
	}
	
	function insertaCodigoCodigoProvincia(valor)
	{
		/*
        CRS006: Por petición expresa, se añade el órgano de Agencia Tributaria de Andalucía. 
        Tanto la insercción como el tratamiento de dicho órgano se hace de forma manual
        El código de Agencia tributaria es TA, pero tanto en PDF como en formulario se mostrará EH
        Para diferenciarla a la hora de tratamiento de CHAP (tambien tiene código EH) añadimos un espacio.
        Por lo tanto, si empieza por " EH", realmente es TA
        */
		var patron = /^\s/;
		var campo = document.formulario.h1c032.value;
		
		if((campo.match(patron)) && (campo!='')){
			document.formulario.h1c032.value = ' EH'+ valor;
		}else{
			document.formulario.h1c032.value = document.formulario.h1c032_1.value + valor;
		}
	}
/** FIN DEL CONJUNTO DE FUNCIONES COMUNES DE LOS MODELOS 801,802,803,804 Y 805 **/


function desmarcar (casilla){
	
	if(document.getElementById(casilla) != null && document.getElementById(casilla).checked){
		document.getElementById(casilla).checked = false	
	}
	
}

var logado;
function compruebaLogado(Event){
	if(Event.button== 1){
	    if(logado){
		    alert('La operación se está procesando. Espere... ');
	    }else{
		    logado = true;
	    }
	}
}

function enviaDocumento(){
	
	document.forms[0].action ="../comun/CargarDocumento";
	document.forms[0].submit();
}

function incorporarDocumento(incorporar){
	
	if(incorporar){
		document.getElementById("documentoIncorporar").style.display="block";
		document.getElementById("cuerpoDocumento").style.display="block";
	}
	else{
		document.getElementById("documentoIncorporar").style.display="none";	
	}
}

function cancelarCargaDocumento(){
	
	document.forms[0].nif.value="";
	document.forms[0].numeroDocumento.value="";
	document.forms[0].importe.value="";
	
	incorporarDocumento(false);
	document.getElementById("erroresCargaDocumentos").style.display="none";	
}

//Muestra los criterios de busqueda en plages
function mostrarCriteriosBusqueda(campo){
	
	document.getElementById("formPresentacion:capaCriterios").style.display="none";
	document.getElementById("capaBusqueda").style.display="block";
	document.getElementById("formPresentacion:"+campo).value ="true";	
	
}

//Oculta los criterios de busqueda en plages
function ocultarCriteriosBusqueda(campo){
	
	document.getElementById("formPresentacion:capaCriterios").style.display="block";
	document.getElementById("capaBusqueda").style.display="none";
	document.getElementById("formPresentacion:"+campo).value ="false";
	
}
//Comprueba en el onload los criterios de busqueda para mostrarlo en plages en la gestion de documentos
//o en la gestion de diligencias
function compruebaMuestraCriteriosBusqueda(campo){
	
	var mostrarCriterios = document.getElementById("formPresentacion:"+campo).value;
	
	if(mostrarCriterios == "true" || mostrarCriterios ==""){
		mostrarCriteriosBusqueda(campo);
	}
	else{
		ocultarCriteriosBusqueda(campo);	
	} 
}

/**
* FUNCIONES PARA GESTIÓN DE CUENTAS BANCARIAS ASOCIADAS A LAS AUTORIZACIONES PROFESIONALES
*/

//	Funcion que comprueba que al pulsar el botón Detalle/Modificación de usuario, se haya seleccionado 
//	UNO o más de UNO
function validarSeleccionCCC(){	
	// Comprobamos ahora que el usuario haya seleccionado una o más de una cuenta bancaria
	if(cccSeleccionada() > 0){
		if (!(confirm('¿Desea eliminar las cuentas bancarias seleccionadas?'))){		
			return false;
		}else{
			return true;
		}
	}else{
		alert("Por favor, seleccione alguna cuenta bancaria");
		return false;
	}	
}

/**
* 	comprueba que se hallan seleccionado una o más cuentas bancarias para eliminar                                                                     
*/
function cccSeleccionada(){	
    var numDocs= 0;    
    // El primer registro se corresponde con el nombre de las columnas, por lo que restamos 1
    var numRows= document.getElementById(tablaDocu_1_1_5).rows.length-1;
    for (k= 0; k< numRows; k++){
        // Comprobamos si el registro tiene la caja de check
	    var check= document.getElementById(tablaDocu_1_1_5 + ':' + k + ':checkDocumentoUsuario');
	    // Si existe la caja, comprobamos si está seleccionada	    
	    if (check!= null){	    
	        var valorCheck= check.checked;
	        // Si está seleccionada, incrementamos el contador
	        if (valorCheck){
	            numDocs++;
	        }
	    }
    }   
    return numDocs;
}

function nuevaCuentaBancaria(){
	
	var entidad = (document.getElementById("formPresentacion:entidad")).value;	
	var sucursal = (document.getElementById("formPresentacion:sucursal")).value;
	var dc = (document.getElementById("formPresentacion:dc")).value;
	var numcuenta = (document.getElementById("formPresentacion:numcuenta")).value; 
	var alias = (document.getElementById("formPresentacion:aliasCuenta")).value;
	
	if (!validaCCC(entidad, sucursal, dc, numcuenta, true)){
			alert('Introduzca un CCC válido');
			if (numcuenta && numcuenta.focus){
				numcuenta.focus();
			}
			(document.getElementById("formPresentacion:numcuenta")).select();			
			return false;
	}else if (null == alias || " " == alias || "" == alias){
		alert('Todos los campos son obligatorios');
		if (alias && alias.focus){
			alias.focus();
		}
		(document.getElementById("formPresentacion:aliasCuenta")).select();
		return false;
	}else{	
		return true;
	}
}

function validaCCC(entidad, oficina, dc, cuenta, permiteAsterisco)
{
	var entidad_oficina=entidad + oficina;
	var dcSuc=parseInt(dc.substring(0, 1));
	var dcCue=parseInt(dc.substring(1));
	var suma;
	var digitoControl;
	if(!permiteAsterisco&&(dcSuc=="*"||dcCue=="*"))return false;
	if(dc != '**'||!permiteAsterisco){
		suma=parseInt(entidad_oficina.substring(0,1))*4 +
				parseInt(entidad_oficina.substring(1,2))*8 +
				parseInt(entidad_oficina.substring(2,3))*5 +
				parseInt(entidad_oficina.substring(3,4))*10 +
				parseInt(entidad_oficina.substring(4,5))*9 + 
				parseInt(entidad_oficina.substring(5,6))*7 +
				parseInt(entidad_oficina.substring(6,7))*3 +
				parseInt(entidad_oficina.substring(7,8))*6;		
		digitoControl=11 -(suma % 11);
		if(digitoControl==10)digitoControl=1;
		if(digitoControl==11)digitoControl=0;
		if(digitoControl != dcSuc&&dcSuc != '*')return false;

		suma=parseInt(cuenta.substring(0,1))*1 +
				parseInt(cuenta.substring(1,2))*2 +
				parseInt(cuenta.substring(2,3))*4 +
				parseInt(cuenta.substring(3,4))*8 +
				parseInt(cuenta.substring(4,5))*5 +
				parseInt(cuenta.substring(5,6))*10 +
				parseInt(cuenta.substring(6,7))*9 +
				parseInt(cuenta.substring(7,8))*7 + 
				parseInt(cuenta.substring(8,9))*3 +
				parseInt(cuenta.substring(9,10))*6;
		digitoControl=11 -(suma % 11);
		if(digitoControl==10)digitoControl=1;
		if(digitoControl==11)digitoControl=0;
		if(digitoControl != dcCue&&dcCue != '*')return false;
	}	
	return true;
}
// FUNCIÓN PARA EL PAGO DIFERIDO
function enviarDiferido(){   
	// colocamos a true el parámetro que indica el pago diferido	
	document.forms[0].nrcDiferido.value="true";
	// invocamos a la función genérica de envío del formulario
	enviar();
}


