/*BV************************************************************************************************/

/*
 * Init - Clase de inicializacion.
*/


//this.basePath = $("#basepath").val();

// NAV

$(document).ready(function(){
 	
	$("#nav > ul > li").hover( function() {
	    $(this).addClass("selected")
	    		.find("ul").stop().css({display:"block"})
	    		.animate({height:"140px"},{"duration":"def","queue":false}); 
	    return false;
  	},function() {
	    $(this).removeClass("selected")
	    		.find("ul").stop().animate({height:"0%"},{"duration":"fast","queue":false,complete:reset});
	    return false;
  	});
  
	$("#nav > ul > li > ul").hover( function() {
		$(this).parent().addClass("selected");
	},function() { 
	  	$(this).stop().animate({height:"0%"},{"duration":"fast","queue":false,complete:reset})
	  			.parent().removeClass("selected");
	  	return false;
  	}).css({height:"0%",opacity:1.0,display:"none"});
  	
  	$(document).click(function(){
  		$("#nav > ul > li > ul:visible").stop().animate({height:"0%"},{"duration":"fast","queue":false,complete:reset})
  				.parent().removeClass("selected");
  	});
	
	function reset(){
		$(this).css({height:"0%",display:"none"});
	}

});
 
// Igualar columnas


$(document).ready(function(){

	//igualar columnas
	$(".izq,.der").equalCols();
	$(".izq2,.der2").equalCols();
	$(".izqsearch,.dersearch").equalCols();
	//colorear filas de tablas y listas
	$(".coloreaazlist li:even").addClass("color");
	$("ul.colorea").each(function(){
	 	$(this).children("li:even").addClass("color");
	});
	$(".colorea table").each(function(){
	 	$(this).children("tbody").children("tr:even").addClass("color");
	 	
	 	$(".buttonhover input").hover( 
		    function() { $(this).addClass("hoverclass"); }, 
		    function() { $(this).removeClass("hoverclass"); } 
		);
	});


});


function openHelp(theURL, webcod) { 
	w = window.open(theURL+"?"+"webcod="+webcod+"&"+"urlprov="+window.location,'ayuda','scrollbars=yes,width=568,height=600');
	w.focus();
}


/*
 * LIB
 * data_bv.js: Agrupa funciones de cookies y ajax
 * fecha ultima modificacion: 08/11/2007
 */
//Requiere jQuery 1.1.2+ para la llamada ajax


/*
	LIB
	common_bv.src.js: Agrupa las funciones del antiguo commons.js y fechas.js
	version: 1.0
	Fecha ultima modificacion: 29/05/2007
*/
/*
	FUNCIONES GENERALES
	===================================
	
	Funciones:
		isFilled
		validate
		unvalidate
		validateNIF
		validateCIF
		emailChecker
		Pop
		calcular_edad

	FUNCIONES DE TRATAMIENTO DE FECHA
	===================================
	Dependencia: common_bv.js
	
	Funciones:
		getNextDate
		getDays
		parseDate
		parseHour
		validaDate
		validaHour
		isLeapyear
		calculaDias
		getToday
		validateDate
*/

/*------------------------------------------------------------------
	CONSTANTES
------------------------------------------------------------------*/
LETTERS="áéíóúÁÉÍÓÚabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
LETRAS="abcdefghijklmnñopqrstuvwxyzABCDEFGHIJKLMNÑOPQRSTUVWXYZ";
DIGITS="0123456789";
PASSPORT_VALID = "!\"#$%&'()*+,-./0123456789:;=?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~";
ZIP_VALID = DIGITS;
PHONE_VALID = DIGITS + "+- ()";
DATE_VALID=DIGITS + "/";
CIF_CODE = "1";
NIF_CODE = "2";

/*------------------------------------------------------------------
	Funcion: isFilled
	
	Comprueba que una cadena de caracteres determinada contiene
	alg�n caracter distinto de espacios.
	
	Params:
		str, cadena de caracteres
	Return: 
		true/false
------------------------------------------------------------------*/
function isFilled (str)
{
	for (c = 0; c < str.length; c++)
	{
		if (str.charAt(c) != " ")
		{
			return true;
		}
	}
	return false;
}


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


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


/*------------------------------------------------------------------
	Funcion: validateNIF
	
	Se comprueba si 'nif' es un nif v�lido.
	
	Params:
		nif, n�mero de identificaci�n fiscal
		desc,descripci�n del campo empleada en los avisos que se 
				muestran al usuario en caso de error
	Return: 
		true/false
------------------------------------------------------------------*/
function validateNIF (nif, desc)
{
	numeros=nif.substring (0, nif.length-1);
	letra=nif.substring (nif.length-1).toUpperCase();
	if (!validate (numeros, DIGITS) || !validate (letra, LETTERS))
	{
		//alert (desc + " no es correcto");
		return false;
	}
	ctrlLetters = new Array ("T", "R", "W", "A", "G", "M", "Y", "F", "P", "D", "X", "B", "N", "J", "Z", "S", "Q", "V", "H", "L", "C", "K", "E","T");
	index = numeros - (parseInt (numeros/23,10)*23);
	if (ctrlLetters[index] != letra)
	{
		//alert (desc + " no es correcto");
		return false;
	}
	return true;
}

/*------------------------------------------------------------------
Funcion: validateNIE

Se comprueba si 'nie' es un nie válido.

Params:
	nif, número de identificación de extranjeros
	desc,descripción del campo empleado en los avisos que se 
			muestran al usuario en caso de error
Return: 
	true/false
------------------------------------------------------------------*/
function validateNIE(doc, desc) {
	
	letras = "XYZxyz";	
	car = doc.substring(0,1);
	
	// acepta solo los nie con caracter inicial validos
	if(letras.indexOf(car)==-1) return false;
	
	// reemplaza caracter inicial con equivalente numerico
	doc = doc.replace(/^[xX]/,'0');
	doc = doc.replace(/^[yY]/,'1');
	doc = doc.replace(/^[zZ]/,'2');			
	
	//valida igual que NIF
	return validateNIF(doc,desc);	
	
};

/*------------------------------------------------------------------
Funcion: validateBI

Se comprueba si 'bi' es un número de identificación válido.
Algoritmo: 9*x1 + 8*x2 + 7*x3 + 6*x4 + 5*x5 + 4*x6 + 3*x7 + 2*x8 + x9 = 0 (mod 11)

Params:
	bi, Número de identificación personal portugués
Return: 
	true/false
------------------------------------------------------------------*/
function validateBI (bi) {
	var calculo = 0;
	var numeros = new String(bi);
	if (!validate (numeros, DIGITS) || numeros.length != 9) {
		return false;
	}
	return true; ////// No hay que validar el dígito de control, de manera que solamente
	//comprobamos que sea numérico.
	//for (i=0; i<=8; i++) {
		//alert("calculo["+calculo+"] numeros[i]["+numeros.charAt(i)+"] parseint(numeros[i])["+parseInt(numeros.charAt(i))+"]");
		//calculo += parseInt(numeros.charAt(i)) * (9-i);
	//}
	
	//if (calculo % 11 == 0){
		//return true;
	//} else {
		//return false;
	//}
}


/*------------------------------------------------------------------
	Funcion: validatePhone
	
	Se comprueba si 'telefono' es válido.  Solamente se permite un + al inicio
	
	Params:
		telefono, número de teléfono que se va a validar
	Return: 
		true/false
------------------------------------------------------------------*/
function validatePhone (telefono)
{
	var telefonoString = new String(telefono);
	var regExpTelefono = /^\+?[\d\s\-\(\))]{3,}$/;
	return telefonoString.match(regExpTelefono);
}

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

/*------------------------------------------------------------------
	Funcion: emailChecker
	
	Comprueba que el e-mail sea v�lido.
	
	Params:
		email, direcci�n de correo electr�nico
	Return: 
		true/false
------------------------------------------------------------------*/
function emailChecker(email){
	
	var index_of_at = email.indexOf("@");
	var index_of_last_dot = email.lastIndexOf(".");
	var extension = email.substring((index_of_last_dot+1)).length;
	var length = email.length;
	if ((index_of_at < 1) || (index_of_last_dot < index_of_at) || (index_of_last_dot > length - 3) || (index_of_last_dot +1 < length - extension)){
		return false;
	}else{	
		return true;
	}
}


/*------------------------------------------------------------------
	Funcion: pop
	
	Abre una ventana de navegador nueva.
	
	Params:
		obj, nombre de la ventana
		ancho, 
		alto,
		parametros,
	Return: 
		true/false
------------------------------------------------------------------*/
function pop(obj,ancho,alto,parametros){
	if(!parametros) parametros='scrollbars = yes';
	ventana = window.open(obj.href,obj.target,'width='+ancho+',height='+alto+','+parametros);
	ventana.focus();
}



/*------------------------------------------------------------------
	Funcion: calcular_edad
	
	Dada una fecha de nacimiento calcula la edad actual.
	
	Params:
		fecha, fecha de nacimiento
	Return: 
		true/false
------------------------------------------------------------------*/
function calcular_edad(fecha){
	hoy = new Date();
	var array_fecha = fecha.split("/");
	if (array_fecha.length!=3) return "";
	var ano;
	ano = parseInt(array_fecha[2],10);
  	if (isNaN(ano)) return "";
	var mes;
	mes = parseInt(array_fecha[1],10);
	if (isNaN(mes)) return "";
	var dia;
  	dia = parseInt(array_fecha[0],10);
	if (isNaN(dia)) return "";
	if (ano<=99) ano +=1900;
	edad=hoy.getFullYear()- ano - 1; 		//-1 porque no se si ha cumplido a�os ya este a�o				
	if (hoy.getMonth() + 1 - mes < 0){ 	//+ 1 porque los meses empiezan en 0
		//No los ha cumplido a�n
		return edad;
	}
	if (hoy.getMonth() + 1 - mes > 0){
  	//S� que los ha cumplido
		return edad+1;
	}
	if (hoy.getMonth() + 1 - mes == 0){
		//Los cumple este mes
	  if (hoy.getUTCDate() - dia >= 0){
			//Ya los ha cumplido
		  return edad + 1;
		}else{
			return edad;
		}
	}
	return edad;
}


function calcular_edad_fechas(fechaCompara,fecha){
	var hoy = new Date();
	var array_fechaC = fechaCompara.split("/");
	if (array_fechaC.length==3) 
	{
		var fano = parseInt(array_fechaC[2],10);
		var fmes = parseInt(array_fechaC[1],10);
		var fdia = parseInt(array_fechaC[0],10);
		if (isNaN(fano) || isNaN(fmes) || isNaN(fdia)) 
		{
			hoy = new Date();
		}
		else 
		{
			if (fano<=99) fano +=1900;
			hoy.setFullYear(fano);
			hoy.setDate(fdia);
			hoy.setMonth(fmes-1);
		}
	} 
	var array_fecha = fecha.split("/");
	if (array_fecha.length!=3) return "";
	var ano;
	ano = parseInt(array_fecha[2],10);
  if (isNaN(ano)) return "";
	var mes;
	mes = parseInt(array_fecha[1],10);
	if (isNaN(mes)) return "";
	var dia;
  dia = parseInt(array_fecha[0],10);
	if (isNaN(dia)) return "";
	if (ano<=99) ano +=1900;
	edad=hoy.getFullYear()- ano - 1; //-1 porque no se si ha cumplido a�os ya este a�o				
	if (hoy.getMonth() + 1 - mes < 0){ //+ 1 porque los meses empiezan en 0
		//No los ha cumplido a�n
		return edad;
	}
	if (hoy.getMonth() + 1 - mes > 0){
  	//S� que los ha cumplido
		return edad+1;
	}
	if (hoy.getMonth() + 1 - mes == 0){
		//Los cumple este mes
	  if (hoy.getUTCDate() - dia >= 0){
			//Ya los ha cumplido
		  return edad + 1;
		}else{
			return edad;
		}
	}
	return edad;
}	



/*------------------------------------------------------------------
	Funcion: getNextDate
	
	Devuelve la fecha resultante de sumar o restar N d�as
	
	Params:
		date, cadena de fecha parseada (dd/mm/yyyy)
		days, tantos dias como quieras avanzar o retroceder
	Return: 
		fecha
------------------------------------------------------------------*/
function getNextDate(date, days) {
	if (date.substring(0, 1) == "0") {
		day = parseInt(date.substring(1, 2), 10);
	} else {
		day = parseInt(date.substring(0, 2), 10);
	}
	if (date.substring(3, 4) == "0") {
		month = parseInt(date.substring(4, 5), 10) - 1;
	} else {
		month = parseInt(date.substring(3, 5), 10) - 1;
	}
	year = parseInt(date.substring(6, 10), 10);
	actualDate = new Date(year, month, day);
	millis = actualDate.getTime() + 12 * 60 * 60 * 1000 + days * 24 * 60 * 60 * 1000;
	actualDate.setTime(millis);
	nday = new Number(actualDate.getDate());
	nmonth = new Number(actualDate.getMonth()) + 1;
	nyear = new Number(actualDate.getFullYear());
	if (nyear < 1000) {
		nyear += 1900;
	}
	if (nday < 10) {
		aux = "0" + nday.toString() + "/";
	} else {
		aux = nday.toString() + "/";
	}
	if (nmonth < 10) {
		aux = aux + "0" + nmonth.toString() + "/";
	} else {
		aux = aux + nmonth.toString() + "/";
	}
	aux = aux + nyear.toString();
	return aux;
}

/*------------------------------------------------------------------
	Funcion: getDays
	
	Devuelve la diferencia de d�as entre date1 y date2
	
	Params:
		date1, cadena de fecha parseada (dd/mm/yyyy)
		date2, cadena de fecha parseada (dd/mm/yyyy)
	Return: 
		int, diferencia de d�as entre date1 y date2
------------------------------------------------------------------*/
function getDays(date1,date2){

	if (!date2) { //Si no se manda el segundo par�metro tomamos el d�a actual
		actualDate1 = new Date();
		actualDate1 = new Date(actualDate1.getFullYear(), actualDate1.getMonth(), actualDate1.getDate());
		millis1 = actualDate1.getTime();
		date2 = date1;
	} else {
		if(date1.substring (0, 1) == "0"){
			day1 = parseInt (date1.substring (1, 2),10);
		}else{
			day1 = parseInt (date1.substring (0, 2),10);
		}
		if(date1.substring (3, 4) == "0"){
			month1 = parseInt (date1.substring (4, 5),10)-1;
		}else{
			month1 = parseInt (date1.substring (3, 5),10)-1;
		}
		year1 = parseInt (date1.substring (6, 10),10);
		actualDate1 = new Date(year1,month1,day1);
		millis1 = actualDate1.getTime();
	}
	if (date2.substring(0, 1) == "0") {
		day2 = parseInt(date2.substring(1, 2), 10);
	} else {
		day2 = parseInt(date2.substring(0, 2), 10);
	}
	if (date2.substring(3, 4) == "0") {
		month2 = parseInt(date2.substring(4, 5), 10) - 1;
	} else {
		month2 = parseInt (date2.substring (3, 5),10)-1;
	}
	year2 = parseInt(date2.substring(6, 10), 10);
	actualDate2 = new Date(year2, month2, day2);
	millis2 = actualDate2.getTime();
	dif = millis2 - millis1;
	days = dif / (24 * 60 * 60 * 1000);
	var resultado = "" + days;
	if (resultado.indexOf(".") != -1) {
		var aux = resultado.substring(resultado.indexOf(".") + 1, resultado
				.indexOf(".") + 2);
		if (parseInt(aux, 10) > 5) {
			days = Math.ceil(days);
		} else {
			days = Math.floor(days);
		}
	}
	return days;
	//return Math.ceil(days);
}

/*------------------------------------------------------------------
Funcion: montarDate

Convierte una cadena de fecha en formato "dd/mm/aaaa"

Params:
	str, cadena con la fecha
	formato, dmy o mdy
Return: 
	cadena con la fecha parseada en el formato indicado)
------------------------------------------------------------------*/
function montarDate(dia, mes, anyo, formatoIn, caracterSeparacion) {
	//alert("montarDate dia[" + dia + "] mes[" + mes + "] anyo[" + anyo + "] formato[" + formato + "] caracterSeparacion[" + caracterSeparacion + "]");
	var resultado = new String();
	var formato = new String(formatoIn);
	for (i = 0; i < formato.length; i++) {
		if (i > 0) {
			resultado = resultado + caracterSeparacion + "";
		}
		if (formato.charAt(i) == "d") {
			resultado = resultado + dia + "";
		} else if (formato.charAt(i) == "m") {
			resultado = resultado + mes + "";
		} else if (formato.charAt(i) == "y") {
			resultado = resultado + anyo + "";
		}
	}
	return resultado;
}


/*------------------------------------------------------------------
	Funcion: parseDate
	
	Convierte una cadena de fecha en formato "dd/mm/aaaa"
	
	Params:
		str, cadena con la fecha
		patron, cadena con el patron del formato de la fecha
		formatoEntrada, dmy o mdy
		formatoSalida, dmy o mdy
	Return: 
		cadena con la fecha parseada en el formato(dd/mm/yyyy)
------------------------------------------------------------------*/
function parseDatePatron(str, patron, formatoEntrada, formatoSalida) {
	var compactedDate = "";
	var arrayStr = "";
	var arrayPatron = "";
	var dia = "";
	var mes = "";
	var anyo = "";
	var indiceDia = 0;
	var indiceMes = 1;
	var indiceAnyo = 2;
	
	if (!formatoSalida || formatoSalida == '') {
		formatoSalida = formatoEntrada;
	}
	
	if (formatoEntrada != '') {
		indiceDia  = formatoEntrada.indexOf('d');
		indiceMes  = formatoEntrada.indexOf('m');
		indiceAnyo = formatoEntrada.indexOf('y');
	}

	compactedDate = str.split("-").join("/");

	if (compactedDate.indexOf("/") != -1 && patron.indexOf("/") != -1
			&& patron.length == compactedDate.length) {
		// Formateamos a partir de un patron con caracter de separacion "/"
		arrayStr = compactedDate.split("/");
		arrayPatron = patron.split("/");

		if (arrayStr.length == 3 && arrayStr.length == arrayPatron.length) {
			//alert("si");
			dia = arrayStr[indiceDia];
			mes = arrayStr[indiceMes];
			anyo = arrayStr[indiceAnyo];
			if (dia && dia.length == 1) {
				dia = "0" + dia;
			}
			if (mes && mes.length == 1) {
				mes = "0" + mes;
			}
			if (anyo && anyo.length == 1) {
				anyo = "200" + anyo;
			} else if (anyo && anyo.length == 2) {
				anyo = "20" + anyo;
			} else if (anyo && anyo.length == 3) {
				anyo = "2" + anyo;
			}
			//compactedDate = dia + "/" + mes + "/" + anyo;
			compactedDate = montarDate(dia, mes, anyo, formatoSalida, '/');
			if (!validateDate(compactedDate, '', '', true, '', '', formatoSalida)) {
				compactedDate = "";
			}
		} else {
			compactedDate = "";
		}

	} else if (compactedDate.indexOf("/") == -1 
			&& patron.indexOf("/") == -1
			&& patron.length == compactedDate.length) {
		
		// Formateamos a partir de un patron sin caracter de separacion
		var numD = patron.lastIndexOf("d") - patron.indexOf("d") + 1;
		var numM = patron.lastIndexOf("m") - patron.indexOf("m") + 1;
		var numY = patron.lastIndexOf("y") - patron.indexOf("y") + 1;
		
		dia  = compactedDate.substr(patron.indexOf("d"), numD);
		mes  = compactedDate.substr(patron.indexOf("m"), numM);
		anyo = compactedDate.substr(patron.indexOf("y"), numY);
		
		if (dia && dia.length == 1) {
			dia = "0" + dia;
		}
		if (mes && mes.length == 1) {
			mes = "0" + mes;
		}
		if (anyo && anyo.length == 1) {
			anyo = "200" + anyo;
		} else if (anyo && anyo.length == 2) {
			anyo = "20" + anyo;
		} else if (anyo && anyo.length == 3) {
			anyo = "2" + anyo;
		}
		compactedDate = montarDate(dia, mes, anyo, formatoSalida, '/');
		if (!validateDate(compactedDate, '', '', true, '', '', formatoSalida)) {
			compactedDate = "";
		}
	} else {
		compactedDate = "";
	}
	return compactedDate;
}


/*------------------------------------------------------------------
	Funcion: parseDate
	
	Convierte una cadena de fecha en formato "dd/mm/aaaa"
	
	Params:
		str, cadena con la fecha
	Return: 
		cadena con la fecha parseada en el formato(dd/mm/yyyy)
------------------------------------------------------------------*/
function parseDate(str){
 var compactedDate = str;
 if(str.length == 10){
  compactedDate = str;
 } else {
   var index = str.indexOf("/");
   if (index == -1) {
     if(str.length == 8) {
       if(str.substring(2,3) == "/"){
         compactedDate = str.substring (0, 6) + "20"+ str.substring (6, 8);
       } else {
         compactedDate = str.substring (0, 2)+"/"+str.substring (2, 4)+"/" + str.substring (4, 8);
       }
     } else if(str.length == 6){
       compactedDate = str.substring (0, 2)+"/" +str.substring (2, 4)+"/" +"20"+ str.substring (4, 6);
     }
   } else {	
     index = compactedDate.indexOf("/");
     var newFecha = compactedDate.substring(0,index)+"/";
     if (index == 1) {
       newFecha = "0"+newFecha;       
     }
     compactedDate = compactedDate.substring(index+1);
     index = compactedDate.indexOf("/");
     var saux = compactedDate.substring(0,index);
     compactedDate = compactedDate.substring(index+1);
     if (index == 1) {
       newFecha = newFecha+"0"+saux;       
     } else {
       newFecha = newFecha+saux;
     }
     if (compactedDate.length == 2) {
       compactedDate = newFecha + "/20" + compactedDate;
     } else {
       compactedDate = newFecha + "/" + compactedDate;
     }
   }
 }
 return compactedDate;
}


/*------------------------------------------------------------------
	Funcion: parseHour
	
	Convierte una cadena de hora a formato "hh:mm"
	
	Params:
		str, cadena con la hora
		separador, caracter de separaci�n entre horas y minutos
	Return: 
		cadena con la hora parseada en el formato(HH:MM)
------------------------------------------------------------------*/
function parseHour(str,separador){
	var compactedHour = str;
	if (separador == null) { separador = ":";}
 	if(str.length < 5){
   	var index = str.indexOf(separador);
   	if (index == -1) {
		// ======================
		// Caso de hora HHMM
		// ======================     
		if(str.length == 4) {
			compactedHour = str.substring (0, 2)+separador+str.substring (2, 4);
		}//if
		 // ======================
		 // Caso de hora HMM
		 // ======================     
		/*if(str.length == 3) {
			compactedHour = str.substring (0,2)+separador+str.substring(2,3)+"0";
		}*/
		 // ======================
		 // Caso de hora HH
		 // ======================     
		if(str.length == 2) {
			compactedHour = str+separador+"00";
		}
		// ======================
		// Caso de hora H
		// ======================     
		if(str.length == 1) {
			compactedHour = "0"+str+separador+"00";
		}
	} else {	
    	if(str.length == 4){
        // ======================
        // Casos de hora :
        // .- H:MM --> 0H:MM
        // .- HH:M --> HH:0M
        // ======================
     	if(index == 1){
     		compactedHour = "0"+str;
        }else if(index == 2){
        	compactedHour = str.substring (0, 2)+separador+"0" +str.substring (3, 4);
        }//if
     }else if(str.length == 3){ 
     	// ======================
        // Casos de hora :
        // .- H:M --> 0H:0M
        // ======================
     	if(index == 1){
     		compactedHour = "0"+str.substring (0, 1)+separador+"0" +str.substring (2, 3);
        }        
     }//if
   }//if
 }//if   
 return compactedHour;
}


/*------------------------------------------------------------------
	Funcion: validaDate
	
	Se comprueba si 'str' es una fecha v�lida, con formato 'dd/mm/yyyy'.
	
	Params:
		str, fecha con formato
		-  'dd/mm/yyyy'
		-  'dd/mm/yy'
		-  'ddmmyyyy'
		-  'ddmmyy'
	Return: 
		true,false
------------------------------------------------------------------*/
function validaDate (str)
{
	if (str.length > 0)
	{
		if(str.length == 10){
			compactedDate = str.substring (0, 2) + str.substring (3, 5) + str.substring (6, 10);
		}else if(str.length == 8){
			if(str.substring(2,3) == "/"){
				compactedDate = str.substring (0, 2) + str.substring (3, 5) + "20"+ str.substring (6, 8);
			}else{
				compactedDate = str;
			}
		}else if(str.length == 6){
			compactedDate = str.substring (0, 4) +"20"+ str.substring (4, 6);
		} else {
			return false;
		}
		if (!validate (compactedDate, DIGITS))
		{
			return false;
		}
		if(compactedDate.substring (0, 1) == "0"){
			day = parseInt (compactedDate.substring (1, 2),10);
		}else{
			day = parseInt (compactedDate.substring (0, 2),10);
		}
		if(compactedDate.substring (2, 3) == "0"){
			month = parseInt (compactedDate.substring (3, 4),10);
		}else{
			month = parseInt (compactedDate.substring (2, 4),10);
		}
		year = parseInt (compactedDate.substring (4, 8),10);
		REGULAR_MONTHS = new Array (31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31);
		LEAP_MONTHS = new Array (31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31);
		curDate = new Date ();

		if((month < 1) || (month > 12)){
			return false;
		}

		if (isLeapYear (year))
		{
			if (day < 1 || day > LEAP_MONTHS[month-1])
			{
				return false;
			}
		}
		else
		{
			if (day < 1 || day > REGULAR_MONTHS[month-1])
			{
				return false;
			}
		}	
	}
	return true;
}


/*------------------------------------------------------------------
	Funcion: validaHour
	
	Se comprueba si 'str' es una hora v�lida, con formato 'hh:mm'.
	
	Params:
		str, fecha con formato 'hh:mm' o 'hhmm'
	Return: 
		true,false
------------------------------------------------------------------*/
function validaHour (str){
	if (str.length > 0){
		if (!validate (str, DIGITS+":")){
			return false;
		}
		if ((str.length != 4) && (str.length != 5)) {
			return false;
		}		
		Phora = parseInt(str.substring(0,2),10);
  		if (str.indexOf(":") == 2) {
			Pminutos = parseInt(str.substring(3,5),10);
		} else {
			Pminutos = parseInt(str.substring(2,4),10);
		}
		if (!(Phora <0  || Phora >23 || Pminutos <0 || Pminutos >59)) {
			return true;
		} else {
			return false;
		}
	}
	return true;
}

/*------------------------------------------------------------------
	Funcion: isLeapYear
	
	Comprueba si el a�o es bisiesto.
	
	Params: year, a�o
	Return: true,false
------------------------------------------------------------------*/
function isLeapYear (year)
{
	return ((((year%4)==0) && !((year%100)==0)) || (((year%4)==0) && ((year%400)==0)));
}

/*------------------------------------------------------------------
	Funcion: calculaDias
	
	Encargada de calcular las noches o la fecha final en funci�n de los otros dos campos
	
	Params:
		objIni, fecha inicio
		objDias, n�mero de dias
		objFin, fecha final
		upd, indicador de qu� campo ha sido el �ltimo modificado
	Return: 
		fecha de hoy en formato dd/mm/aaaa
------------------------------------------------------------------*/
function calculaDias(objIni, objDias, objFin, upd) {
	if (upd == "inicio") {
		if (objIni.value != '') {
			if (validaDate(objIni.value)) {
				objIni.value = parseDate(objIni.value);
				if (objDias.value != '') {
					objFin.value = getNextDate(objIni.value, objDias.value);
				} else {
					if (objFin.value != '') {
						if (validaDate(objFin.value)) {
							objDias.value = getDays(objIni.value, objFin.value);
						}
					}
				}
			}
		} else {
			objDias.value = "";
		}
	}
	if (upd == "dias") {
		if (objDias.value != "") {
			if (objIni.value != '') {
				if (validaDate(objIni.value)) {
					objFin.value = getNextDate(objIni.value, objDias.value);
				}
			} else {
				if (objFin.value != '') {
					if (validaDate(objFin.value)) {
						objIni.value = getNextDate(objFin.value, -objDias.value);
					}
				}
			}
		} else {
			objFin.value = "";
		}
	}
	if (upd == "fin") {
		if (objFin.value != "") {
			if (validaDate(objFin.value)) {
				objFin.value = parseDate(objFin.value);
				if (objIni.value != "") {
					if (validaDate(objIni.value)) {
						objDias.value = getDays(objIni.value, objFin.value);
					}
				} else {
					if (document.forms[0].dias.value != "") {
						objIni.value = getNextDate(objFin.value, -objDias.value);
					}
				}
			}
		} else {
			objDias.value = "";
		}
	}
}

/*------------------------------------------------------------------
	Funcion: getToday
	
	Devuelve una cadena con la fecha del d�a actual
	
	Return: 
		fecha de hoy en formato dd/mm/aaaa
------------------------------------------------------------------*/
function getToday() {
	var fecha = new Date();
	var cadena = fecha.getDate() + '/' + eval(fecha.getMonth()+1) + '/' + fecha.getFullYear();
	return parseDate(cadena);

}


/*------------------------------------------------------------------
	Funcion: validateDate
	
	Valida la fecha en diferentes formatos
	
	Params:
		str,
		desc,
		compulsory
		canBeInTheFuture,
		mostrar,
		noFechaPasada
	Return: 
		fecha de hoy en formato dd/mm/aaaa
------------------------------------------------------------------*/
function validateDate (str, desc, compulsory, canBeInTheFuture, mostrar, noFechaPasada, formato) {
	var nuevoStr = str;
	//alert("formato["+formato+"] str["+str+"]");
	//Si el formato es el americano, intercambiamos dias y meses para validarlo con la función de siempre.
	if(formato && (formato == 'mdy')){
		if(str.length==10){
			nuevoStr = str.substring (3, 5) + '/' + str.substring (0, 2) + '/' +  str.substring (6, 10);
		} else {
			return false;
		}
	}
	return validateDateOriginal(nuevoStr, desc, compulsory, canBeInTheFuture, mostrar, noFechaPasada);
}
/*------------------------------------------------------------------
 * Valida una fecha en formato dd/mm/yyyy. Si tenemos fechas en inglés,
 * antes hay que transformarlas.
 * ----------------------------------------------------------------*/
function validateDateOriginal(str, desc, compulsory, canBeInTheFuture, mostrar, noFechaPasada) {
	mensaje = "La fecha debe ser de la forma\ndd/mm/aaaa";

	if (compulsory && (!isFilled(str) || str == 'dd/mm/aaaa')) {
		if (mostrar)
			alert(desc + " es un campo obligatorio.");
		return false;
	}
	
	if (str.length > 0) {
		if (!validate(str, DATE_VALID)) {
			if (mostrar)
				alert(desc + " no es una fecha valida.\n" + mensaje);
			return false;
		}
		if ((str.length < 6) || (str.length == 7))// || (str.length == 9))
													// //Mod Dani
		{
			if (mostrar)
				alert(desc
						+ " debe ser de la forma ddmmaa, ddmmaaaa, dd/mm/aa o dd/mm/aaaa.\n");
			return false;

		}
		if (str.length == 10) {
			if (str.substring(2, 3) == "/" && str.substring(5, 6) == "/") {
				compactedDate = str.substring(0, 2) + str.substring(3, 5) + str.substring(6, 10);
			} else {
				if (mostrar)
					alert(desc + " no es una fecha valida.\n" + mensaje);
				return false;
			}

// Mod
		} else if (str.length == 9) {
			if (str.substring(1, 2) == "/") { // Caso d/mm/yyyy
				compactedDate = "0" + str.substring(0, 1) + str.substring(2, 4) + str.substring(5, 9);
			} else if (str.substring(2, 3) == "/" && str.substring(4, 5) == "/") { // Caso dd/m/yyyy
				compactedDate = str.substring(0, 2) + "0" + str.substring(3, 4) + str.substring(5, 9);
			} else {
				return false;
			}
// Fin Mod

		} else if (str.length == 8) {
			if (str.substring(2, 3) == "/" && str.substring(5, 6) == "/") {
				compactedDate = str.substring(0, 2) + str.substring(3, 5) + "20" + str.substring(6, 8);

// Mod
			} else if (str.substring(1, 2) == "/" && str.substring(3, 4) == "/") {
				compactedDate = "0" + str.substring(0, 1) + "0" + str.substring(2, 3) + str.substring(4, 8);
// Fin Mod
	
			} else {
				if (str.substring(2, 3) != "/" && str.substring(5, 6) != "/") {
					compactedDate = str;
				} else {
					return false;
				}
			}
		} else if (str.length == 6) {
			compactedDate = str.substring(0, 4) + "20" + str.substring(4, 6);
		}
		if (!validate(compactedDate, DIGITS)) {
			if (mostrar)
				alert(desc + " no es una fecha valida.\n" + mensaje);
			return false;
		}
		if (compactedDate.substring(0, 1) == "0") {
			day = parseInt(compactedDate.substring(1, 2), 10);
		} else {
			day = parseInt(compactedDate.substring(0, 2), 10);
		}
		if (compactedDate.substring(2, 3) == "0") {
			month = parseInt(compactedDate.substring(3, 4), 10);
		} else {
			month = parseInt(compactedDate.substring(2, 4), 10);
		}
		year = parseInt(compactedDate.substring(4, 8), 10);
		REGULAR_MONTHS = new Array(31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31);
		LEAP_MONTHS = new Array(31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31);
		curDate = new Date();

		if ((month < 1) || (month > 12)) {
			if (mostrar)
				alert("Mes no valido.\nDebe estar entre 1 y 12.");
			return false;
		}
		if (!canBeInTheFuture) {
			curYear = curDate.getFullYear();
			curMonth = curDate.getMonth() + 1;
			if (curYear < year || curYear == year && curMonth < month
					|| curYear == year && curMonth == month
					&& curDate.getDate() < day) {
				if (mostrar)
					alert(desc + " es posterior a la fecha actual.");
				return false;
			}
		}
		if (noFechaPasada) {
			// Si es true (o existe) no hay que permitir que la fecha sea a
			// pasado
			curYear = curDate.getFullYear();
			curMonth = curDate.getMonth() + 1;
			if ((curYear > year)
					|| (curYear == year && curMonth > month)
					|| (curYear == year && curMonth == month && curDate.getDate() > day)) {
				if (mostrar)
					alert(desc + " es anterior a la fecha actual.");
				return false;
			}
		}

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

function avoidSubmitOnEnter(e) {
	if (e.keyCode == '13') {
		return false;
	}
	return true;
} 

/*
 * Normaliza una cadena de texto
 * Convierte una cadena de texto cualquiera que representa una fecha, 
 * en una fecha con formato dd/mm/yyyy o mm/dd/yyyy
 * Si la cadena que se pasa como parámetro no se puede interpretar como fecha, devuelve "".
 * formatoEntrada y formatoSalida puede tener los valores dmy(europeo) o mdy(americano)
 */
function normalizarDate(cadena, formatoEntrada, formatoSalida) {
	if (formatoEntrada == 'mdy') {
		var formatos = new Array("m/d/y", "m/d/yy","m/d/yyy", "m/d/yyyy", "m/dd/y", "m/dd/yy", "m/dd/yyy", "m/dd/yyyy", "mm/d/y", "mm/d/yy", "mm/d/yyy", "mm/d/yyyy", "mm/dd/y", "mm/dd/yy", "mm/dd/yyy", "mm/dd/yyyy", "mmddyyyy", "mmdyyyy", "mmddyyy", "mddyyyy", "mmddyy", "mdyyyy", "mmdyyy", "mddyyy", "mddyy", "mmdyy", "mmddy", "mdyyy", "mmdy", "mdyy", "mddy", "mdy");
	} else {
		formatoEntrada = 'dmy';
		var formatos = new Array("d/m/y", "d/m/yy","d/m/yyy", "d/m/yyyy", "d/mm/y", "d/mm/yy", "d/mm/yyy", "d/mm/yyyy", "dd/m/y", "dd/m/yy", "dd/m/yyy", "dd/m/yyyy", "dd/mm/y", "dd/mm/yy", "dd/mm/yyy", "dd/mm/yyyy", "ddmmyyyy", "ddmyyyy", "ddmmyyy", "dmmyyyy", "ddmmyy", "dmyyyy", "ddmyyy", "dmmyyy", "dmmyy", "ddmyy", "ddmmy", "dmyyy", "ddmy", "dmyy", "dmmy", "dmy");
	}
	var newDate = "";

	for (indice = 0; newDate == "" && indice < formatos.length; indice++) {
		newDate = parseDatePatron(cadena, formatos[indice], formatoEntrada, formatoSalida);
	}
	return newDate;
}