/*=================================================================================*\
 *  funjvs01.php - Librería de funciones javascript.
 *
 *  (c) 2007 Innovatrium, S.L. <innovatrium@innovatrium.es>
 *  Este archivo NO puede ser libremente distribuido. Reservados todos los derechos.
 *  Para más información visite el sitio: http://www.innovatrium.es/ 
 *
\*=================================================================================*/

// Definición de variables globales
var dracol = "";		// Columna que se está redimensionando
var draxxx1 = 0;		// Variable para almacenar la x inicial
var draxxx2 = 0;		// Variable para almacenar la x final

// Definir eventos para manejar el redimensionamiento de columnas
Event.observe(document, 'mousemove', fjDocumentMove);
Event.observe(document, 'mouseup', fjDocumentUp);
  
/*---------------------------------------------------------------------------------*\
 *  Función    : fjDocumentMove()
 *  Descripción: Redimensiona una columna de un grid en caso necesario.
 *  Parámetros : event: Evento del ratón 
 *  Devuelve   : Nada.
\*---------------------------------------------------------------------------------*/
function fjDocumentMove(event) 
{
	
	if (dracol != "")
	{
		
		draxxx2 = Event.pointerX(event);		

		ver1 = draxxx1;
		ver2 = draxxx2;
		
		var dratam = parseInt(draxxx2) - parseInt(draxxx1);
		
		$(dracol).previous().style.width = (parseInt($(dracol).previous().offsetWidth) - 6 + dratam) + "px";		

		
		
//		if (parseInt($(dracol).offsetLeft) < parseInt(  $(dracol).up().offsetWidth) / 2)
//		{
//		
//			$(dracol).previous().style.width = (parseInt($(dracol).previous().offsetWidth) - 6 + dratam) + "px";
//			
//		}
//		else
//		{
//			
//			$(dracol).next().style.width = (parseInt($(dracol).next().offsetWidth) - 6 - dratam) + "px";
//			
//		}
			
		draxxx1 = draxxx2;
	
		 //document.title = "width: " + $(dracol).previous().style.width + " width: " + $(dracol).next().style.width;		
		
	}

   
}

/*---------------------------------------------------------------------------------*\
 *  Función    : fjDocumentUp()
 *  Descripción: Cuando se levanta el ratón termina el redimensionamiento de columnas
 *  Parámetros : event: Evento del ratón 
 *  Devuelve   : Nada.
\*---------------------------------------------------------------------------------*/
function fjDocumentUp(event) 
{
	if (dracol != "")
	{
		$("inibod").style.cursor = "";
		dracol = "";
	}
}

/*---------------------------------------------------------------------------------*\
 *  Función    : fjDragOn()
 *  Descripción: Cuando se pulsa el ratón en una columna empieza el redimensionamiento
 *  Parámetros : event: Evento del ratón 
 *  Devuelve   : Nada.
\*---------------------------------------------------------------------------------*/
function fjDragOn(event, columna) 
{
	
	if (event.button==0)
	{
		$("inibod").style.cursor = "e-resize";
		
		draxxx1 = Event.pointerX(event);
		dracol = columna;
		Event.stop(event); 
	}
	
}


/*---------------------------------------------------------------------------------*\
 *  Función    : fjMarcarTodos()
 *  Descripción: Marca o desmarca todos los checkbox de un formulario. Para su uso en tablas de datos.
 *  Parámetros : parchk: Checkbox de cabecera que define si se marca o desmarcan los checkbox. 
 *               parfrm: Formulario del cual marcar todos los checkbox.  
 *  Devuelve   : Nada.
\*---------------------------------------------------------------------------------*/
function fjMarcarTodos(parchk, parfrm) 
{

	for (var i=0; i<parfrm.elements.length; i++) 
	{
	
		var auxobj = parfrm.elements[i];

		if (auxobj.name == "arrcla[]")
		{
			auxobj.checked = parchk.checked;
		}

	}

}


/*---------------------------------------------------------------------------------*\
 *  Función    : fjMarcarUno()
 *  Descripción: Marca un check cuyo value coincida con el valor indicado.
 *  Parámetros : parval: Valor a comprobar. 
 *               parfrm: Formulario del cual marcar el checkbox.  
 *  Devuelve   : Nada.
\*---------------------------------------------------------------------------------*/
function fjMarcarUno(parval, parfrm) 
{

	for (var i=0; i<parfrm.elements.length; i++) 
	{
	
		var auxobj = parfrm.elements[i];

		if (auxobj.name == "arrcla[]")
		{
			if (auxobj.value == parval)
			{				
				auxobj.checked = true;
			}
		}

	}

}

/*---------------------------------------------------------------------------------*\
 *  Función    : fjMarcarDesmarcar()
 *  Descripción: Marca un check cuyo value coincida con el valor indicado.
 *  Parámetros : parval: Valor a comprobar. 
 *               parfrm: Formulario del cual marcar el checkbox.  
 *  Devuelve   : Nada.
\*---------------------------------------------------------------------------------*/
function fjMarcarDesmarcar(parval, parfrm) 
{

	for (var i=0; i<parfrm.elements.length; i++) 
	{
	
		var auxobj = parfrm.elements[i];

		if (auxobj.name == "arrcla[]")
		{
			if (auxobj.value == parval)
			{				
				if(auxobj.checked == true)
				{
					auxobj.checked = false;
				}
				else
				{
					auxobj.checked = true;
				}				
			}
		}

	}

}


/*---------------------------------------------------------------------------------*\
 *  Función    : fjConfirmar()
 *  Descripción: Confirma si se puede postear desde una tabla de datos y valida en caso de eliminar.
 *  Parámetros : pareli: Define si se debe validar el eliminar o no. 
 *               parfrm: Formulario a someter.  
 *  Devuelve   : Nada.
\*---------------------------------------------------------------------------------*/
function fjConfirmar(pareli, parfrm) 
{
	
		// Comprobamos si hay algún check marcado
		var auxchk = false;
		var auxtip = "";
		for (var i=0; i<parfrm.elements.length; i++) 
		{
			
			var obj=parfrm.elements[i];
			
			if (obj.type=="checkbox" && obj.value!="") 
			{
				if (obj.checked==true) auxchk=true;
			}
			
		}
	
		if (auxchk==true) 
		{
			if (pareli != "")
			{
			
				if (confirm("¿Está seguro de " + pareli + " los registros seleccionados?"))
				{
					return true;
				} 
				else
				{
					return false;
				}
				
			}
			else
			{
				return true;
			}
			
		}
		else
		{
			alert('No se ha seleccionado ningún registro');
			return false;
		}

}

/*---------------------------------------------------------------------------------*\
 *  Función    : fjAccion()
 *  Descripción: Ejecuta los procesos necesarios para redirigir una acción desde un grid de datos.
 *  Parámetros : parmod: Módulo al que dirigir. 
 *               parsec: Sección a la que dirigir.  
 *               parpro: Proceso al que dirigir.   
 *               partip: Tipo de acción. 1=Llamada directa. 2=Someter formulario. 3=Navegación por get.
 *               parfrm: Formulario con el que trabajar. 
 *  Devuelve   : Nada.
\*---------------------------------------------------------------------------------*/
function fjAccion(parmod, parsec, parpro, parpar, partip, parfrm, parcfm) 
{

	if (parmod != "" && parsec != "")
	{

		switch(partip) {
		
			case 1:			// Llamada directa (Ej.: Nuevo)
	
				parfrm.mod.value = parmod; 
				parfrm.sec.value = parsec; 
				parfrm.parcla.value = parpar; 			
	
				parfrm.method = 'get'; 
				
				if (parcfm != "")
				{
				
					if (confirm("¿Está seguro de " + parcfm + "?"))
					{
						parfrm.submit();
					} 
				}
				else
				{
					parfrm.submit();
				}

				
				// parfrm.submit();
					
				// location.search = "?mod=" + parmod + "&sec=" + parsec + "&pro=" + parpro;
				
				break;   
		
			case 2:    		// Someter formulario (Ej.:Editar)
	
				parfrm.mod.value = parmod; 
				parfrm.sec.value = parsec; 
				//parfrm.parcla.value = parpar; 			

				if (parpar == "htm")
				{
					parfrm.htm.value = 0; 
				}


				parfrm.method = 'get'; 			
				
				if (fjConfirmar(parcfm, parfrm))
				{
					parfrm.submit();
				}
				
				break;   
			
			case 3:    		// Navegar por get
	
				parfrm.mod.value = parmod; 
				parfrm.sec.value = parsec; 
				parfrm.parcla.value = parpar; 			
	
				parfrm.method = 'get'; 
	
				if (fjConfirmar(parcfm, parfrm))
				{
					parfrm.submit();
				}
					
				break;   
				
			case 4:    		// Abrir vantana nueva. Imprimir.

				strenl = "index.php?sel=true&mod=" + parmod + "&sec=" + parsec + "&parcla=" + parpar;
				
				var wndSele = window.open(strenl, null, "menubar=yes,dependent=yes,resizable=yes,status=no,scrollbars=yes,width=630,height=600");

				break;   				
				
			case 5:    		// Abrir vantana nueva. Imprimir sometiendo el formulario.

				parfrm.mod.value = parmod; 
				parfrm.sec.value = parsec; 
				parfrm.sel.value = "true"; 				
				parfrm.target = parfrm.name;
				parfrm.method = 'get'; 			
				
				if (fjConfirmar(parcfm, parfrm))
				{
					
					var wndSele = window.open("", parfrm.name, "toolbar=yes,menubar=yes,dependent=yes,resizable=yes,status=no,directories=no,personalbar=no,scrollbars=yes,width=630px,height=600px");					
					
					parfrm.submit();
				}
				
				parfrm.sel.value = ""; 								
				parfrm.target = "_top";				
				
				break;   
			
			default:   
						
				break;   
		
		} 
		
	}

}

/*---------------------------------------------------------------------------------*\
 *  Función    : fjAddOpcion()
 *  Descripción: Añade un valor determinado a una lista de valores (select).
 *  Parámetros : parval: Valor a añadir (objeto). 
 *               parsel: Select donde añadir el valor.
 *               parcam: Campo donde se serializa la lista 
 *  Devuelve   : Nada.
\*---------------------------------------------------------------------------------*/
function fjAddOpcion(parval, parsel, parcam)
{

	if (parval.value != "")
	{

		if (parsel.selectedIndex < 0 && parsel.length > 0)
		{
			var selind = parsel.length - 1;
		}
		else
		{
			var selind = parsel.selectedIndex;
		}
	
		// hago hueco para el elemento a añadir
		var i;
		
		var optult = new Option();
		parsel.options[parsel.length] = optult;
	
	
		if (parsel.length > 1)
		{
			for (i = parsel.length -1; i > selind; i--)
			{
				parsel.options[i].text = parsel.options[i - 1].text;
				parsel.options[i].value = parsel.options[i - 1].value;
		
			}
		}
	
		parsel.options[selind + 1].text = parval.value;
		parsel.options[selind + 1].value = parval.value;
	
	
		// Serializamos la lista
		arrcam = new Array();			
		for (i = 0; i < parsel.length; i++)
		{
			arrcam[i] = parsel.options[i].text;
		}
	
		//var php = new PHP_Serializer(true);
		//parcam.value = php.serialize(arrcam);		
		
		parcam.value = encodeURIComponent(Object.toJSON(arrcam));				
	
		parsel.selectedIndex = -1;
		parval.value = "";
		parval.focus();
	}
	
	
}

/*---------------------------------------------------------------------------------*\
 *  Función    : fjDelOpcion()
 *  Descripción: Elimina un valor determinado a una lista de valores (select).
 *  Parámetros : parsel: Select donde añadir el valor. 
 *               parcam: Campo donde se serializa la lista 
 *  Devuelve   : Nada.
\*---------------------------------------------------------------------------------*/
function fjDelOpcion(parsel, parcam)
{

	if (parsel.selectedIndex >= 0 && parsel.length > 0)
	{

		parsel.options[parsel.selectedIndex] = null;
	
		parcam.value = fjSerializarSelect(parsel);		

	}

	parsel.selectedIndex = -1;
	
}

/*---------------------------------------------------------------------------------*\
 *  Función    : fjInsertarOpcion()
 *  Descripción: Inserta un valor y su descripción a una lista de valores (select).
 *  Parámetros : parval: Valor a añadir (objeto). 
 *               pardes: Descripción que se visualiza en el select.
 *               parsel: Campo select del formulario 
 *  Devuelve   : Nada.
\*---------------------------------------------------------------------------------*/
function fjInsertarOpcion(parval, pardes, parsel)
{
	if (parval != "")
	{

		// Averiguo si se ha seleccionado un elemento en la lista
		if (parsel.selectedIndex < 0 && parsel.length > 0)
		{
			var selind = parsel.length - 1;
		}
		else
		{
			var selind = parsel.selectedIndex;
		}
	
		// hago hueco para el elemento a añadir
		var i;
		var optult = new Option();
		parsel.options[parsel.length] = optult;
		if (parsel.length > 1)
		{
			for (i = parsel.length -1; i > selind; i--)
			{
				parsel.options[i].text = parsel.options[i - 1].text;
				parsel.options[i].value = parsel.options[i - 1].value;
		
			}
		}

		// Inserto en valor y descripción indicados
		parsel.options[selind + 1].text = pardes;
		parsel.options[selind + 1].value = parval;
	
		// Deselecciono cualquier elemento.
		parsel.selectedIndex = -1;
	}
	
}


/*---------------------------------------------------------------------------------*\
 *  Función    : fjSerializarSelect()
 *  Descripción: Convierte los valores de un campo select en una cadena JSON.
 *  Parámetros : parsel: Campo select de un formulario. 
 *  Devuelve   : Cadena JSON.
\*---------------------------------------------------------------------------------*/
function fjSerializarSelect(parsel)
{

	// Montamos un array con los valores
	arrcam = new Array();			
	for (i = 0; i < parsel.length; i++)
	{
		arrcam[i] = parsel.options[i].value;
	}

	// devolvemos la cadena JSON de array montado
	return encodeURIComponent(Object.toJSON(arrcam));				
	
}



/*---------------------------------------------------------------------------------*\
 *  Función    : fjSiEnter()
 *  Descripción: Comprueba si se ha pulsado enter en un campo.
 *  Parámetros : pareve: Evento de pulsación de tecla. 
 *  Devuelve   : True si se pulsa enter y false en caso contrario.
\*---------------------------------------------------------------------------------*/
function fjSiEnter(pareve)
{
	var iAscii;

	if (pareve.keyCode)
		iAscii = pareve.keyCode;
	else if (pareve.which)
		iAscii = pareve.which;
	else
		return false;

	if (iAscii == 13) 
	{
		return true;
	}
	
	return false;
} 


/*---------------------------------------------------------------------------------*\
 *  Función    : fjFocoPrimero()
 *  Descripción: Ajusta el foco en el primero campo de formulario de la página.
 *  Parámetros : Ninguno. 
 *  Devuelve   : Nada.
\*---------------------------------------------------------------------------------*/
function fjFocoPrimero()
{

	if (document.forms.length > 0)
	{
		for (var i=0; i < document.forms[0].elements.length; i++)
		{
			var oField = document.forms[0].elements[i];
			if (oField.type != "hidden")
			{
				oField.focus();
				return;
			}
		}
	}
	
} 


/*---------------------------------------------------------------------------------*\
 *  Función    : fjValidarCampo()
 *  Descripción: Valida el campo indicado según la cadena de caracteres dada.
 *  Parámetros : parcam: Input textbox que necesita ser validado. 
 *               parchr: Caracteres que se permiten en el campo. 
 *  Devuelve   : Nada.
\*---------------------------------------------------------------------------------*/
function fjValidarCampo(parcam, parexp)
{

	$(parcam).title = "";
	$(parcam).style.borderColor='';

	if (parexp)
	{

		var auxchr = $(parcam).value;
	
		if (auxchr.length > 0)
		{
	
			if(!auxchr.match(parexp))
			{

				$(parcam).title = "Se han introducido caracteres erróneos";				
				$(parcam).style.borderColor='red';
				$(parcam).focus();
				return;
			}
		}
	}
	return;
	
} 

/*---------------------------------------------------------------------------------*\
 *  Función    : fjPermitirCaracteres()
 *  Descripción: Comprueba si se ha introducido un caracter válido o no
 *  Parámetros : parcam: Input textbox que necesita ser validado. 
 *               pareve: Evento que se produce en el campo. 
 *               parexp: Expresión regular que controla los caracteres que se pueden introducir.  
 *               parpas: True si no se permite el copypaste o false en caso contrario.  
 *  Devuelve   : El caracter válido.
\*---------------------------------------------------------------------------------*/
function fjPermitirCaracteres(parcam, pareve, parexp, parpas) 
{

	if (parexp)
	{

		pareve = EventUtil.formatEvent(pareve);
	
		var auxchr = String.fromCharCode(pareve.charCode);
		
		var auxkey = pareve.keyCode;
		
		// Permitir teclas que no son de caracteres
		if ((auxkey > 0 && auxkey < 32) || (auxkey >= 33 && auxkey <= 46) || (auxkey >= 112 && auxkey <= 123))
		{
			return true;
		}	
	
		var auxval = auxchr.match(parexp);
		
		if (parpas) {
			return auxval && !(pareve.ctrlKey && auxchr == "v");
		} else {
			return auxval || pareve.ctrlKey;
		}
		
	}
	
	return true;
	
}


/*---------------------------------------------------------------------------------*\
 *  Función    : fjContinuarEvento()
 *  Descripción: Permite continuar un evento tanto en IE como en Firefox
 *  Parámetros : pareve: Variable de evento. 
 *             : parcon: Permite continuar con TRUE o se detiene con FALSE  
 *  Devuelve   : TRUE si continua, FALSE si se detiene.
\*---------------------------------------------------------------------------------*/
function fjContinuarEvento(pareve, parcon)
{ 
	if (pareve.preventDefault && !parcon)
	{
		pareve.preventDefault();
		pareve.stopPropagation();
	}
	
	return parcon;
	
}


/*---------------------------------------------------------------------------------*\
 *  Función    : fjMostarMenu()
 *  Descripción: Muestra el submenú indicado o lo oculta si estaba visible
 *  Parámetros : parmnu: Muestra la tabla del menú indicado. 
 *  Devuelve   : Nada.
\*---------------------------------------------------------------------------------*/
function fjMostarMenu(parmnu)
{
	if (document.images) 
	{
		var imgnor = new Image();
		imgnor.src = "0ima/estcue03.png";
		var imgabj = new Image();
		imgabj.src = "0ima/estcue02.png";
	}
	
	if ($("mnuchk[" + parmnu + "]").value == "false")
	{
		
		$("mnupun[" + parmnu + "]").style.display = "";
		$("mnuchk[" + parmnu + "]").value = "true";
		if (document.images) 
		{
			document.images["mnuimg[" + parmnu + "]"].src = imgabj.src;
		}

	}
	else
	{
		
		$("mnupun[" + parmnu + "]").style.display = "none";
		$("mnuchk[" + parmnu + "]").value = "false";
		if (document.images) 
		{
			document.images["mnuimg[" + parmnu + "]"].src = imgnor.src;
		}

	}
		

}

/*---------------------------------------------------------------------------------*\
 *  Función    : fjMostarMenuSiempre()
 *  Descripción: Muestra el submenú indicado en todos los casos
 *  Parámetros : parmnu: Muestra la tabla del menú indicado. 
 *  Devuelve   : Nada.
\*---------------------------------------------------------------------------------*/
function fjMostarMenuSiempre(parmnu)
{

	if (document.images) 
	{
		var imgnor = new Image();
		imgnor.src = "0ima/estcue03.png";
		var imgabj = new Image();
		imgabj.src = "0ima/estcue02.png";
	}

	$("mnupun[" + parmnu + "]").style.display = "";
	$("mnuchk[" + parmnu + "]").value = "true";
	if (document.images) 
	{
		document.images["mnuimg[" + parmnu + "]"].src = imgabj.src;
	}

}


/*---------------------------------------------------------------------------------*\
 *  Función    : fjMostrarCampos()
 *  Descripción: Muestra los campos ocultos de un formulario
 *  Parámetros : partbl: Tabla que contiene las filas de los campos a visualizar u ocultar. 
 *  Devuelve   : Nada.
\*---------------------------------------------------------------------------------*/
function fjMostrarCampos(partbl)
{
	// Montamos el objeto tabla
	var objtbl=$('tblcam');

	// Recuperamos imagenes de la flecha a mostrar
	if (document.images) 
	{
		var imgnor = new Image();
		imgnor.src = "0ima/estcue03.png";
		var imgabj = new Image();
		imgabj.src = "0ima/estcue02.png";
	}	
	
	
	// Recorremos las filas que tienen id y que son susceptibles de ser ocultadas.
	for (i=0; i<objtbl.rows.length; i++)
	{
		if (objtbl.rows[i].id.substring(0, 9) == "row" +  partbl)
		{
			if (objtbl.rows[i].style.display != "")
			{	
				document.images[partbl].src = imgabj.src;
				objtbl.rows[i].style.display = "";
			}
			else
			{	
				document.images[partbl].src = imgnor.src;
				objtbl.rows[i].style.display = "none";
			}
		}
	}

}


/*---------------------------------------------------------------------------------*\
 *  Función    : fjAbrirConsulta()
 *  Descripción: Abre la ventana de consulta para seleccionar un registro
 *  Parámetros : parmnu: Muestra la tabla del menú indicado. 
 *  Devuelve   : Nada.
\*---------------------------------------------------------------------------------*/
function fjAbrirSeleccion(seleccion) 
{

	// Crear el nombre de la nueva ventana
	var auxfec = new Date();
	var auxhor = auxfec.getHours();     	// Devuelve la hora
	var auxmin = auxfec.getMinutes();    	// Devuelve los minutos
	var auxsec = auxfec.getSeconds();		// Devuelve los segundos
	var auxmil = auxfec.getMilliseconds();	// Deuelve los milisegundos
	var nueven = auxhor + auxmin + auxsec + auxmil;

	var wndSele = window.open("index.php?sel=true&" + seleccion, nueven, "toolbar=yes,dependent=yes,menubar=yes,resizable=yes,status=no,scrollbars=yes,width=750,height=800");

}

/*---------------------------------------------------------------------------------*\
 *  Función    : fjDevolverCampoForm()
 *  Descripción: Devuelve un determinado valor a un determinado campo del formulario que lo llama
 *  Parámetros : parcam: Nombre del campo en el formulario. 
 *             : parval: Valor a colocar en el campo.  
 *  Devuelve   : Nada.
\*---------------------------------------------------------------------------------*/
function fjDevolverCampoForm(parcam, parval)
{
	var auxtex;
	do { 
	
		auxtex = parval;
		parval = parval.replace("<br />", "\r\n");

	} while (auxtex != parval);

	// Descodificamos del url
	parval = decodeURIComponent(parval);
	
	// Averiguamos si tenemos que devolver en un select de base de datos
	var valsel = parval.split("|");
	
	if (valsel.length > 1)
	{
		// Averiguamos si hay más de un campo a devolver en un select
		var camsel = valsel[0].split("#");
		if (camsel.length == 1)
		{
			valsel[0] = camsel[0]; 
		}

		fjInsertarOpcion(valsel[0], valsel[1], window.opener.document.getElementsByName("lst"+parcam)[0]);
		window.opener.document.getElementsByName(parcam)[0].value = fjSerializarSelect(window.opener.document.getElementsByName("lst"+parcam)[0]);
	}
	else
	{
		// Averiguamos si tenemos que devolver un checkbox
		if (window.opener.document.getElementsByName(parcam)[0].type == "checkbox" )
		{
			if (window.opener.document.getElementsByName(parcam)[0].value == parval)
			{			
				window.opener.document.getElementsByName(parcam)[0].checked = true;
			}
			else
			{
				window.opener.document.getElementsByName(parcam)[0].checked = false;
			}
		}
		else
		{
			window.opener.document.getElementsByName(parcam)[0].value = parval;
		}
	}

	//window.opener.document.getElementsByName(parcam)[0].value = decodeURIComponent(parval);	

}

/*---------------------------------------------------------------------------------*\
 *  Función    : fjMontarFecha()
 *  Descripción: Monta en un campo oculto la concatenación de tres campos formando una fecha.
 *  Parámetros : parcam: Input que hay que montar. 
 *  Devuelve   : Nada.
\*---------------------------------------------------------------------------------*/
function fjMontarFecha(parcam)
{

	$(parcam).value = fjRellenar($(parcam + 'aaaa').value, 4) + fjRellenar($(parcam + 'mm').value, 2) + fjRellenar($(parcam + 'dd').value, 2);

} 

/*---------------------------------------------------------------------------------*\
 *  Función    : fjMontarFecha2()
 *  Descripción: Monta en un campo oculto la concatenación de tres campos formando una fecha.
 *  Parámetros : parcam: Input que hay que montar. 
 *  Devuelve   : Nada.
\*---------------------------------------------------------------------------------*/
function fjMontarFecha2(parcam)
{

	var auxarr = $(parcam+'f').value.split("/");

	if (typeof(auxarr[0]) == "undefined")
	{
		auxarr[0] = "00";
	}


	if (typeof(auxarr[1]) == "undefined")
	{
		auxarr[1] = "00";
	}


	if (typeof(auxarr[2]) == "undefined")
	{
		auxarr[2] = "0000";
	}

	var auxfec = auxarr[2]+auxarr[1]+auxarr[0];   

	if (auxfec == "00000000" || auxfec == "000000" || auxfec == "0000" || auxfec == "00")
	{
		$(parcam).value = "";
	}
	else
	{
		$(parcam).value = auxarr[2]+auxarr[1]+auxarr[0];   
	}

} 


/*---------------------------------------------------------------------------------*\
 *  Función    : fjRellenar()
 *  Descripción: Rellena con ceros a la izquiera teniendo como base un tamaño definido.
 *  Parámetros : parvar: valor de base. 
 *               partam: tamaño máximo del campo a rellenar.  
 *  Devuelve   : cadena rellena de ceros.
\*---------------------------------------------------------------------------------*/
function fjRellenar(parvar, partam)
{ 
	auxcad = '';
	
	for(i=0;i<(partam-parvar.length);i++)
	{
		auxcad+='0';
	}
	parvar = auxcad + parvar;
	return parvar;
} 


/*---------------------------------------------------------------------------------*\
 *  Función    : fjMostrarAyuda()
 *  Descripción: Muestra un cuadro siguiendo al cursor y mostrando un texto de ayuda.
 *  Parámetros : partxt: Texto a mostrar. 
 *               parevt: Evento del ratón en el objeto que contiene la ayuda.  
 *  Devuelve   : Nada.
\*---------------------------------------------------------------------------------*/ 
function fjMostrarAyuda(partxt, parevt)
{
	
	var auxtip = $('auxtip') ;
	
	auxtip.innerHTML = partxt ;

	auxtip.style.top = parevt.clientY + document.documentElement.scrollTop + 20 + "px";
	auxtip.style.left = parevt.clientX + document.documentElement.scrollLeft + "px";

	
	auxtip.style.visibility = 'visible' ;

	$('auxtip').show();

} 

/*---------------------------------------------------------------------------------*\
 *  Función    : fjOcultarAyuda()
 *  Descripción: Oculta el cuadro de ayuda previamente visualizado.
 *  Parámetros : Ninguno. 
 *  Devuelve   : Nada.
\*---------------------------------------------------------------------------------*/
function fjOcultarAyuda()
{ 

	$('auxtip').hide();

}

/*---------------------------------------------------------------------------------*\
 *  Función    : fjLimpiarFormulario()
 *  Descripción: Limpia y vacia los campos de un formulario.
 *  Parámetros : parfrm: Nombre del formulario a limpiar. 
 *  Devuelve   : Nada.
\*---------------------------------------------------------------------------------*/
function fjLimpiarFormulario(parfrm)
{
	
	
   var form = $(parfrm); 
   
   var arr = form.getElements();
   
   arr.each(function(item) 
   {
	   if (item.type == "text" || item.type == "select-one") // Añadir nuevos tipos según sea necesario. Averiguarlos con alert(item.type)
	   {
		   item.clear();
	   }
   }
   );
   
}


/*---------------------------------------------------------------------------------*\
 *  Función    : fjAjaxCargarCamposFormulario()
 *  Descripción: Recupera datos para los campos de un formulario a través de Ajax
 *  Parámetros : parsel: selección de campos con la consulta, la clave y los campos a devolver, como query string 
 *  Devuelve   : Nada.
\*---------------------------------------------------------------------------------*/
function fjAjaxCargarCamposFormulario(parsel) 
{

	//var url = encodeURIComponent(fuente_datos);
	
	// Programa que gestiona las consultas y las devoluciones
	var url = 'congen01.php';
	
	new Ajax.Request
	(url, 
		{
			method: 'post', 
			parameters: parsel,
			onSuccess: 
				function(transport) 
				{
					if(transport.responseText.length > 0)
					{
						// Transformamos la cadena JSON en un objeto
						var auxdat = decodeURIComponent(transport.responseText);
						var auxdat = auxdat.evalJSON();

						// Convertimos el objeto en un array
						var arrdat = $H(auxdat);
						
						// Recorremos el array y colocamos los valores en los campos.
						arrdat.each
						(		
							function(eledat)
							{
								
								// Colocamos los valores dependiente del tipo
								
								//alert($(eledat.key).type);
								
								switch($(eledat.key).type) 
								{
								
									case "select-one":			

										$(eledat.key).value = eledat.value;
										
										break;
									
									default:
										
										
										$(eledat.key).value = eledat.value;
										
										break;
										
								}
								
								
								
//								fjDevolverCampoForm(eledat.key, encodeURIComponent(eledat.value));
								
								
							}
						);						
						
					}
				},
			onFailure: 
				function(transport) 
				{
					//alert('Fallo!');
				},
			onComplete: 
				function(transport) 
				{
					//alert('Complete!');
				},
			onLoaded: 
				function(transport) 
				{
					//alert('Loaded!');
				},
			on404: 
				function(transport) 
				{
					//alert('404!');
				},
			on500: 
				function(transport) 
				{
					//alert('500!');
				},
			onException: 
				function(transport, exception) 
				{
					alert('Exception! ' + exception);
				}
				
	
		}
	);
	

}

/*---------------------------------------------------------------------------------*\
 *  Función    : fjAjaxBorrarCamposFormulario()
 *  Descripción: Borrar los campos del formulario para usarlo en el onkeypress cuando se van a recuperar valores de consulta
 *  Parámetros : parcam: campo en el que estoy y que no hay que borrar 
 *             : parsel: campos clave y a recuperar  
 *             : pareve: controlador de eventos para decidir cuando borrar los campos             
 *  Devuelve   : Nada.
\*---------------------------------------------------------------------------------*/
function fjAjaxBorrarCamposFormulario(parcam, parsel, pareve) 
{
	// Comprobar que no se ha pulsado ninguna tecla especial, y por tanto no hay que borrar los campos
		pareve = EventUtil.formatEvent(pareve);
		
		var auxchr = String.fromCharCode(pareve.charCode);
		
		var auxkey = pareve.keyCode;
		
		// Si es una tecla especial nos salimos sin hacer nada. Para que el tabulador u otras teclas no borren el campo
		if ((auxkey > 0 && auxkey < 32 && auxkey !=8) || (auxkey >= 33 && auxkey <= 45) || (auxkey >= 112 && auxkey <= 123))
		{
			//alert(auxkey);
			return true;
		}	

		
	// Obtenemos un objeto con todo el query string
	var parqry = parsel.toQueryParams()
	
	// Obtenemos el array de campos en el querystring
	var arrqry = $H(parqry);	
	
	// Transformamos el parámetos arrtxt que contiene los valores a devolver que es una cadena JSON en un objeto
	var auxdat = decodeURIComponent(parqry.arrtxt);
	var auxdat = auxdat.evalJSON();

	// Convertimos el objeto en un array
	var arrdat = $H(auxdat);
	
	// Recorremos el array y borramos los valores en los campos.
	arrdat.each
	( 
		function(eledat)
		{
			// Si no es el propio campo que estoy editando y no pertenece a la clave de recuperación lo borro
			// Si no encuentro el campo a borrar en el array de parámetros
			if (typeof(arrqry.get(eledat.value)) === 'undefined')
			//if (arrqry.get(eledat.value) === "undefined")
			{
				$(eledat.key).value = "";
				
				// Para borrar los campos de tipo fecha.
				if ($(eledat.key + "f"))
				{
					$(eledat.key + "f").value = "";
				}
				
				//$(eledat.key).innerHTML = "";
			}
		}
	);						
	
	
	
	
}

/*---------------------------------------------------------------------------------*\
 *  Función    : fjConfirmarCerrarVentana()
 *  Descripción: Solicita confirmación a la hora de cerrar la ventana en la que se encuentra ARCCOS abierto.
 *  Parámetros : Ninguno 
 *  Devuelve   : Nada.
\*---------------------------------------------------------------------------------*/
function fjConfirmarCerrarVentana()
{
	result=window.confirm("¿Está seguro de querer salir?");
	{
		if (result==true)
		{
			return false;
		}
		else
		{
			return true;
		}
	}
}


/*---------------------------------------------------------------------------------*\
 *  Función    : fjResize()
 *  Descripción: Asigna al div central, el panel 1 o el panel 2, la altura más alta del div central, del panel 1 o del panel 2
 *  Parámetros : Ninguno 
 *  Devuelve   : Nada.
\*---------------------------------------------------------------------------------*/
function fjResize()
{  

	var heicen01, heipan01, heipan02;
	
	// Si hay div central calcularmos su altura
	heicen01 = 0;
	if ($('estcen01'))
	{
		heicen01 = $('estcen01').getHeight();
	}
	
	// Si hay div panel 01 calcularmos su altura
	heipan01 = 0;
	if ($('estpan01'))
	{
		heipan01 = $('estpan01').getHeight();
	}

	// Si hay div panel 02 calcularmos su altura
	heipan02 = 0;
	if ($('estpan02'))
	{
		heipan02 = $('estpan02').getHeight();
	}
	
	// Asignamos el máximo de cada altura. OJO no olvidar el  + "px" al final para que funcione
	if ($('estcen01'))
	{
		$('estcen01').style.height = Math.max( heicen01, heipan01, heipan02 )   + "px";
	}
	if ($('estpan01'))
	{
		$('estpan01').style.height = Math.max( heicen01, heipan01, heipan02 )   + "px";
	}
	if ($('estpan02'))
	{	
		$('estpan02').style.height = Math.max( heicen01, heipan01, heipan02 )   + "px";
	}
	
	
	
	//document.title = Math.max( $('estcen01').getHeight() , $('estpan01').getHeight() , $('estpan02').getHeight() );
	
	//document.title = navigator.appName + "/" + arrwin[0] + "/" + arrwin[1] + "/" + arrwin[2] + "/" + arrwin[3] + "/" + arrwin[4] + "/" + arrwin[5] + "/" + document.body.style.height;
	
} 

/*---------------------------------------------------------------------------------*\
 *  Función    : fjgetWindowData()
 *  Descripción: Devuelve los parámetros de la página cargada. ¡por que no lo hará el navegador solo dios!
 *  Parámetros : Ninguno 
 *  Devuelve   : Nada.
\*---------------------------------------------------------------------------------*/
function fjgetWindowData()
{
    var widthViewport,heightViewport,xScroll,yScroll,widthTotal,heightTotal;

    if (typeof window.innerWidth != 'undefined')
    {
        widthViewport= window.innerWidth-17;
        heightViewport= window.innerHeight-17;
    }
    else if(typeof document.documentElement != 'undefined' && typeof document.documentElement.clientWidth !='undefined' && document.documentElement.clientWidth != 0)
    {
        widthViewport=document.documentElement.clientWidth;
        heightViewport=document.documentElement.clientHeight;
    }
    else
    {
        widthViewport= document.getElementsByTagName('body')[0].clientWidth;
        heightViewport=document.getElementsByTagName('body')[0].clientHeight;
    }
    
    xScroll=self.pageXOffset || (document.documentElement.scrollLeft+document.body.scrollLeft);
    yScroll=self.pageYOffset || (document.documentElement.scrollTop+document.body.scrollTop);
    widthTotal=Math.max(document.documentElement.scrollWidth,document.body.scrollWidth,widthViewport);
    heightTotal=Math.max(document.documentElement.scrollHeight,document.body.scrollHeight,heightViewport);
    
    
    return [widthViewport,heightViewport,xScroll,yScroll,widthTotal,heightTotal];
    
}


/*---------------------------------------------------------------------------------*\
 *  Función    : fjPonerOpacidad()
 *  Descripción: Marca una opacidad a un elemento HTML independientemente del navegador.
 *  Parámetros : ele. elemento según $('elemento')
 *             : opa. opacidad de 0 a 100. 
 *  Devuelve   : Nada.
\*---------------------------------------------------------------------------------*/
function fjPonerOpacidad(ele, opa)
{
	var IE;
	
	(navigator.userAgent.match('MSIE')) ? IE = true : IE = false;
	
	(IE) ? ele.style.filter='alpha(opacity='+opa+')' : ele.style.opacity=opa/100;

}

/*---------------------------------------------------------------------------------*\
 *  Función    : fjFadeIn()
 *  Descripción: Hace una transición del elemento 1 al elemento 2 utilizando opacidad
 *  Parámetros : ele1. elemento según $('elemento')
 *             : ele2. elemento según $('elemento') 
 *  Devuelve   : Nada.
\*---------------------------------------------------------------------------------*/
function fjFadeIn(ele1, ele2)
{
	
	var IE;
	
	(navigator.userAgent.match('MSIE')) ? IE = true : IE = false;	
	
    var i = 100;
    
    // El Internet Explorer no admite hacer un cambio de imagen con canal alpha
    if (IE)
    {
		ele1.src = ele2.src;
    	
    }
    else
    {
    
	    intv = setInterval(
	    					function()
	    					{
	    						i = i-5;
	    						
	    						ele2.style.display = "";
							      
	    						if(i>=0)
	    						{
	    							fjPonerOpacidad(ele1, i);
	    							fjPonerOpacidad(ele2, (100-i));
	    						} 
	    						else 
	    						{
	    							
	    							clearInterval(intv);
	    							
	    							ele1.src = ele2.src;
	    							fjPonerOpacidad(ele1, 100);
	    							fjPonerOpacidad(ele2, 0);
	    							
	    						}
	    					},50);
	    
    }
   
}