/**	------------------------------------------------------------------------------------  	
*	DOCUMENTO JAVASCRIPT - JavaScript Document
*	ARCHIVO: jge00001.js
*	NOMBRE ORIGINAL: forms.js
*	CREADO POR: Camilo Pineda (campineda@gmail.com)
*    VERSION: 1.2.10
*    FECHA ULTIMA MODIFICACION: 03 Octubre 2011
*	DESCRIPCION:  Funciones comunes para manejo de Formularios, garantizadas para Firefox 1.5+ e IExplorer 6+.
* 		Estan agrupadas en las siguientes categorias:
*		   -  HTML DINAMICO - DHTML
*		   -  FORMATO VISUAL
*		   -  MANEJO DE FORMULARIOS, VENTANAS, ALERTAS 
*		   -  VALIDACION DE TECLAS PRESIONADAS 
*		   -  VALIDACION DE DATOS (Con Expresiones Regulares)
*		   -  VALIDACION DE DATOS (por Comparacion de Caracteres)
*		   -  VALIDACION DE OBJETOS DE FORMULARIO, CON  ALERTAS
*		HISTORIAL:
/* ------------------------------------------------------------------------------------ 
	17-Feb-2006	-> Creacion del Archivo, con funciones basicas
	28-Mar-2006	-> Incluye funcion 'imgContinuar'
	21-Abr-2006	-> Incluye funcion 'abrirAyuda'
	09-May-2006	-> Incluye funcion 'formatoNum'
	22-Ago-2006	-> Separa funciones de Restriccion
	28-Sep-2006	-> Incluye funcion 'agregarFila'
	24-Oct-2006	-> Mejora las funciones para deteccion de teclas
	25-Oct-2006	-> Mejora la Documentacion.
	26-Oct-2006	-> Incluye funciones: 'esMail', 'cambiaTexto'
	03-Nov-2006	-> Corrige Funciones de Validacion de Teclas para restringir el uso de simbolos
                -> Mejora en la Funcion 'mostrarCodigoTecla'
                -> Incluye funcion 'esDescripcion'
	20-Nov-2006	-> Incluye Funcion 'mostrarElemento'
	22-Nov-2006	-> Corrige Funcion 'cambiaTexto', para q no muestre error cuando No encuentra IdElemento
	28-Nov-2006	-> Incluye Funciones: 'continuarFormulario', 'direccionarFrame', 'cambiaTxtCampo'
	04-Dic-2006	-> Corrige Funciones: 'direccionarFrame', 'agregarFila'
				-> Incluye Funciones auxiliares a 'agregarfila': 'procesarAtributo', 'procesarEtiqueta'
				-> Incluye Funcion 'continuarFormularioFrame'
	14-Dic-2006	-> Incluye Funciones 'leerCampoEntero' 'leerCampoFlotante'
	03-Ene-2007	-> Incluye Funcion 'eliminarFila'
				-> Mejora Funciones 'leerCampoEntero' 'leerCampoFlotante'
	05-Ene-2007	-> Agrega variable Global 'APP_JS_IdHiddenField' Para corregir un problema con Ie
                    cuando se clonan Filas con campos ocultos, Ie No encuentra estos campos y por tanto tampoco sus valores.
                    por esto es necesario identificar estos campos por medio de un Id. 
                    'APP_JS_IdHiddenField' es una cadena que se antepone y concatena al Nombre del Objeto, 
                    y luego se busca campos con un id = a ese resultado de la concatenacion.
                    por tanto los campos ocultos deben tener su id como 'APP_JS_IdHiddenField' + 'NombreObjeto' para q se puedan encontrar.
                -> Incluye Funcion 'obtenerNumFila'	
    12-Ene-2007	-> Mejora las Funciones 'abrirAyuda' y 'abrirAyudaRetorno' para que puedan Abrir varias Ventanas Ahora es Necesario que donde se utilicen estas funciones se declare la variable 'ventanaAyuda'
    16-Ene-2007	-> Corrige la Funcion 'cambiaTxtCampo', para que coloque en los campos ocultos generados el  valor independientemente si antes estaba establecido este atributo o no. Para la correccion para IE.
	15-Feb-2007	-> Mejora la funcion 'continuar' ahora acepta parametro opcional para indicar 'target'
	01-Mar-2007	-> Corrige la funcion 'redondear', no aceptaba redondeo con 0 decimales
    02-Mar-2007	-> Mejora la funcion 'cambiaTexto' para que cuando se coloque el Texto a vacio, se coloque un espacio en su lugar y el nodo de texto no se pierda
	28-Mar-2007	-> Corrige la funcion 'cambiaValor'
	10-Abr-2007	-> Agrega Funcion 'abrirAyudaFuncionRetorno'
	26-Abr-2007	-> Mejora la funcion 'pasarArregloASelect' para que se ignoren los datos no definidos del arreglo
	17-May-2007	-> Agrega Funcion 'comparaFechas'
                -> Corrige Funcion 'esFecha' por un problema de creacion del objeto Date
	16-Ago-2007	-> Agrega Funciones 'seleccionarValor', 'valorSeleccionado'
	27-Sep-2007	-> Agrega Funciones 'buscarLlaveTablaX', 'ConsultarLlaveServX'
	28-Sep-2007	-> Corrige la funcion 'seleccionarValor'
	09-Oct-2007	-> Corrige la funcion 'consultarLlaveServX'
	11-Oct-2007	-> Corrige la funcion 'buscarLlaveTablaX'
	17-Oct-2007 -> Agrega Funcion 'consultarLlaveServX2' y 'buscarLlaveTablaX2'
                ->	Corrige la funcion 'consultarLlaveServX'
	19-Dic-2007	-> Agrega Funcion 'valorRadio'
                -> Mejora la funcion 'leerCampoX' para poder leer el valor actual de campos 'radio'
                -> Agrega Funcion 'seleccionarRadio'
                -> Mejora la funcion 'cambiaValor' para poder cambiar el valor de elementos 'radio'
	21-Ene-2008	-> Mejora la funcion 'esVacio' para que no tome la cadena cero "0" como vacio
	19-Feb-2008	-> Corrige la funcion 'esVacio' para que tome la cadena false como vacio.
                -> Agrega la funcion 'cambiaHtml' para cambiar el innerHtml de los elementos 
	17-Abr-2008	-> Mejora la funcion 'conFormatoMoneda' para permitir especificar el numero de decimales a formatear
                -> Mejora la funcion 'cambiaCampoValor' para permitir especificar el numero de decimales a formatear
                -> Agrega la funcion 'indiceAct'
                -> Agrega la funcion 'cambiarSelectSegunIndice'
                -> Actualizacion de la documentacion 
	21-Abr-2008	-> Agrega la funcion 'actCampoHora' para CamporHora, actualiza el valor en el campo oculto
	07-Jul-2008	-> Mejora la funcion 'pasarArregloASelect' para que en caso de que no se encuntre el select muestre un mensaje de error
	18-Jul-2008	-> Agrega la funcion 'abrirVentanaFuncion'
	24-Jul-2008	-> Agrega la funcion 'parametroUrl'
	30-Oct-2008	-> Agrega la funcion 'limpiarCampo'
	06-Ene-2009 -> Depuracion de Errores / Warnings
	06-May-2010 -> Depuracion de Errores / Warnings encontrados en browser Mozilla
    14-Jul-2011 -> Agrega la funcion 'quitarFilasTabla'
                -> Mejora documentacion archivo
    05-Sep-2011 -> Cambios en varias funciones para corregir forma de manejar argumentos opcionales en Funciones JS para Firefox
    28-Sep-2011 -> Corrige la funcion 'cambiaCampoValor' ya que no actualizaba correctamente el campo de texto vinculado
                -> Mejora la funcion 'conFormatoMoneda' quitandole la responsabilidad que no le corresponde de actualizar campo de texto
    03-Oct-2011 -> Corrige la funcion 'conFormatoMoneda' ya que debe actualizar el texto cuando se cambia el foco de un campo valor.
------------------------------------------------------------------------------------ */

/*********************
   VARIABLES GLOBALES   
*********************/
var ventanaAyuda = false; // Define si existe una ventana de Ayuda Abierta, Para que solo haya una ventana de Ayuda Abierta a la vez.
var APP_JS_IdSpan = "span";// Identificador para span

/**********************
   HTML DINAMICO - DHTML
**********************/

function agregarFila(idBodyTabla, idFilaGuia, NumFila){
	/* -----------------------
		Esta Funcion Agrega una nueva fila al Cuerpo de la Tabla identificado como 'idBodyTabla'.
		Realiza una copia Exacta de la fila 'idFilaGuia' y luego cambia el nombre de los elementos que contenga
		y de la misma fila esta manera: 'nombre_numeroFila'. 
		El id de la Primera fila 'idPrimeraFila', asi como cada uno de los elementos que contenga la fila, deben 
		tener un caracter '_' que separe el nombre del elemento del numero de la Fila, para asi identificar los
		nuevos elementos correctamente.
		Se pueden Ademas colocar 2 parametros OPCIONALES, 'estiloFilaPar' y destinoIMG
	PARAMETROS:
		idBodyTabla (string) //-- Id del TBODY de la Tabla en la que se agregan Filas (atributo id)
		idPrimeraFila (string) //-- Id de la Fila Guia  (atributo id)
		NumFila (string) //-- Representacion del Numero Actual de Filas en la Tabla
		estiloFilaPar (string)	-- Opcional -- //-- Nombre de la Clase de Estilo que se aplica cuando la fila de la tabla es Par.
		destinoIMG (string) -- Opcional --	 //-- Direccion URL de la pagina de destino para las imagenes en el evento onClick		
	----------------------- */	
    var args;if(window.event){args = agregarFila.arguments;}else{args = arguments;}
	var destinoIMG = "";
	var estiloFilaPar = "";		
	// Vemos Si se colocaron los Parametros Opcionales
	if (args.length > 3)
		estiloFilaPar = args[3];	
	if (args.length > 4)	
		destinoIMG = args[4];
	// Obtenemos el Numero de Fila Actual y lo Actualizamos	
	var nFila = NumFila;
	nFila++;
	// Obtenemos la Fila que vamos a copiar	 y la clonamos
	var Fila = document.getElementById(idFilaGuia).cloneNode(true);	
	procesarAtributo(Fila, "id", nFila); 	//Cambiamos Id de la Nueva Fila*/
	if (nFila % 2 == 0)
		Fila.className = estiloFilaPar;	//Cambiamos Clase de la Nueva Fila si es Par	
	// Procesamos Las siguientes Etiquetas. Actualizando sus IDs y sus NAMEs de acuerdo a la Nueva Fila
	procesarEtiqueta(Fila, "INPUT", nFila);
	procesarEtiqueta(Fila, "SPAN", nFila);
	procesarEtiqueta(Fila, "A", nFila);
	procesarEtiqueta(Fila, "SELECT", nFila);
	procesarEtiqueta(Fila, "IMG", nFila, destinoIMG);
	// Añadimos la Fila que copiamos al final
	document.getElementById(idBodyTabla).appendChild(Fila);	
	return nFila;	// Actualizamos el Numero de la Fila
}

function agregarOpciones(IdSelect){
	/* -----------------------
		Agrega Opciones a un control tipo Select. Las opciones se envian como parejas de parametros opcionales 
		(Texto, Valor) para crear una opcion.
	PARAMETROS:
		IdSelect (string) //-- Id del SELECT que se quiere modificar
		Texto (string) //-- El texto que se muestra en el select 
		Valor (srting) //-- Valor para esa opcion		
	----------------------- */
    var args;if(window.event){args = agregarOpciones.arguments;}else{args = arguments;}
	if (args.length == 1){
		return;
    }
	var campoSelect = document.getElementById(IdSelect);
	for (var i = 1; i < args.length ; i=i+2){
		miOpcion = new Option(args[i], args[i+1]);
		campoSelect.options[campoSelect.options.length] = miOpcion;
	}
	return;
}

function cambiaCampoFormato(idCampo, valor){
	/* -----------------------
		Coloca el 'valor' formateado en el campo 'idCampo', puede recibir un ObjFormatoNum Opcional, 
		De lo contrario se establecen un formato predeterminado
	PARAMETROS:
		idCampo (string) //-- Id del Campo al que se quiere dar formato
		valor (double) //-- valor numerico sin formato 
		objFrmtNum (ObjFormato) -- Opcional --  //-- Objeto para dar formato al numero		
	----------------------- */
	var args;if(window.event){args = cambiaCampoFormato.arguments;}else{args = arguments;}
    var objFrmtNum = null;
	if (args.length > 2){
		objFrmtNum = args[2];
    }else{
		objFrmtNum = new NumberFormat();
		objFrmtNum.setInputDecimal('.');
		objFrmtNum.setSeparators(true, '.', ',');
		objFrmtNum.setPlaces('2', false);// Numero de Decimales, Sin Truncar
	}
	objFrmtNum.setNumber(valor);
	cambiaTxtCampo(idCampo, objFrmtNum.toFormatted(), valor);
}

function cambiaCampoValor(idCampo, valor){
	/* -----------------------
		Cambia el valor de un CampoValor y establece el formato
	PARAMETROS:
		idCampo (string) //-- Id del CampoValor
		valor (double) //-- valor numerico sin formato 
		decimales (integer) -- Opcional --  //-- Numero de decimales		
	----------------------- */
	var args;if(window.event){args = cambiaCampoValor.arguments;}else{args = arguments;}
    var decimales = '2';
	if (args.length > 2)
		decimales = args[2];			
	if(cambiaValor(idCampo, valor) ){
		conFormatoMoneda(null, true, idCampo, decimales);
        if(document.getElementById(idCampo)){
            Valor = leerCampoX(idCampo);
        }
        cambiaTxtCampo(idCampo, Valor);
	}
	return;
}

function cambiaChk(idElemento, valor){
	/* -----------------------
		Evalua el Valor, si es verdadero o 1, muestra la Imagen asociada al campo Check y / o selecciona el objeto checkbox
	PARAMETROS:
		idElemento (string) //-- Id del objeto CHECKBOX
		valor (double) //-- valor sobre el que se determina si se chequea o no el objeto		
	----------------------- */
	var HayCampoCheck = false;
	var HayCampoOculto = false;
	var HayImagen = document.getElementById("img"+idElemento);
	if(HayImagen){
		mostrarElemento("img"+idElemento, (valor == true));
	}
	var CampoCheck = document.getElementById(idElemento);
	if(CampoCheck){
		HayCampoCheck = (CampoCheck.type == "checkbox");
		HayCampoOculto = (CampoCheck.type == "hidden");
		if(HayCampoCheck){
			CampoCheck.checked = (valor == true);
		}
		if(HayCampoOculto){
			CampoCheck.value = (valor ? 1 : 0);
		}
	}
}

function cambiaHtml(idElemento, miHtml){
	/* -----------------------
		Busca un Elemento HTML por su ID: 'IdElemento', y luego cambia o establece el HTML que contenga
		Retorna Falso si no se puede cambiar la propiedad.
		
		NOTA, para evitar problemas con IExplorer, evite que los elementos sean (COL, COLGROUP, FRAMESET, HEAD, HTML, STYLE, TABLE, TBODY, TFOOT, THEAD, TITLE, TR)
		 ya que para estos, la propiedad innerHTML es de Solo Lectura
	PARAMETROS:
		IdElemento (string)	 //-- Identificador del Elemento HTML (id).
		miHtml (string)	 //-- valor del Nuevo texto
	----------------------- */
	if (document.getElementById(idElemento) ){
		document.getElementById(idElemento).innerHTML = miHtml;
		return true;
	}
	return false;
}

function cambiaTexto(idElemento, texto){
	/* -----------------------
		Busca un Elemento HTML por su ID: 'IdElemento', y luego cambia o establece el Texto que contenga
		Especial para cambiar Teto de Etiquetas TD.
		Retorna Falso si no se puede cambiar la propiedad.
	PARAMETROS:
		IdElemento (string)	 //-- Identificador del Elemento HTML (id).
		texto (string) //-- valor del Nuevo texto
	----------------------- */
	if(texto == "") texto = " ";
	//texto = texto.replace(/\n/g," "); // Reemplaza saltos de linea por espacio
	
	if(document.getElementById(APP_JS_IdSpan + idElemento) && document.getElementById(APP_JS_IdSpan + idElemento).firstChild){
		document.getElementById(APP_JS_IdSpan + idElemento).firstChild.nodeValue = texto;
		return true;
	}else if(document.getElementById(idElemento) && document.getElementById(idElemento).firstChild){
		document.getElementById(idElemento).firstChild.nodeValue = texto;
		return true;
	}
	return false;
}

function cambiaTxtCampo(ObjOrigen, Texto){
	/* -----------------------
		Busca el Objeto Origen, y cambia los textos que tenga asociados. Si es un Elemento HTML
		busca el elemento por su ID 'ObjOrigen' y cambia su Texto por 'Texto', ademas si existe
		un Campo INPUT (en el Formulario 0) con ese Mismo Nombre lo Busca y establece su nuevo Valor
		si no encuentra el Campo, Lo Busca por un ID especifico, añadiendo "H0" al 'ObjOrigen'.
		
		Especial para Actualizar campos de Lectura generados por PHP
		Retorna El Numero de Cambios de Texto que puedo Realizar.
	PARAMETROS:
		ObjOrigen (string) //-- Identificador del Elemento HTML (id). y/o Nombre del campo input (name)
		Texto (string) //-- Texto a colocar en el elemento HTML.
		TxtValor (string) -- Opcional --  //-- Texto a colocar en el Campo, si No se especifica se coloca el mismo 'Texto'
		frmOrigen (string) -- Opcional -- //-- Nombre o numero del Formulario origen
	----------------------- */
    var args;if(window.event){args = cambiaTxtCampo.arguments;}else{args = arguments;}
	var Encontrado = 0;
	var TxtValor = "";
	var Depurar = false;
	var frmOrigen = "";
	if (args.length > 2)
		TxtValor = args[2];
	else
		TxtValor = Texto;
	if (args.length > 3)
		frmOrigen = args[3];
	if(esVacio(frmOrigen))
		frmOrigen = 0;
	if (args.length > 4)
		Depurar = args[4];		
	if (cambiaTexto(ObjOrigen, Texto) )
		Encontrado++;
	Encontrado += cambiaValor(ObjOrigen, TxtValor, frmOrigen, Depurar);
	return Encontrado;
}

function cambiaTxtListaArreglo(ObjOrigen, Valor, Arreglo){
	/* -----------------------
		Busca el 'ObjOrigen' y le cambia el texto segun la descripcion que corresponda en el Arreglo
		el Arreglo debe estar ordenado de la siguiente forma:
			arreglo[0][0........n] Arreglo en el cual debe estar 'Valor'
			arreglo[1][0........n] Arreglo de las descipciones para cada posible valor
		Ademas coloca en el objeto formulario el 'Valor' actual
		** Especial para Actualizar campos de LecturaLista generados por PHP
		Retorna El Numero de Cambios de Texto que puedo Realizar.
	PARAMETROS:
		ObjOrigen (string) //-- Identificador del Elemento HTML (id). y/o Nombre del campo input (name)
		Valor (string) //-- Valor que debe encontrase en el 'Arreglo' de valores (Arreglo[0])
		Arreglo (string) //-- Nombre del Arreglo
	----------------------- */
    var args;if(window.event){args = cambiaTxtListaArreglo.arguments;}else{args = arguments;}
	var Encontrado = false;	
	var Depurar = false;
	if (args.length > 3)
		Depurar = args[3];
	var Texto = "";
	var codArreglo = "";
	var tamArreglo = eval(Arreglo+"[0].length");
	var i = 0;
	// Buscamos el valor en todo el arreglo
	for(i=0; i<tamArreglo; i++){
		codArreglo = eval(Arreglo+"[0]["+i+"]");
		if(codArreglo == Valor){
			Encontrado = true;
			break;
		}
	}
	if(Encontrado){
		Texto = eval(Arreglo+"[1]["+i+"]");
		return cambiaTxtCampo(ObjOrigen, Texto, Valor, Depurar);
	}
	alert("ERROR cambiaTxtCampoLista :: No se encontro Valor en el Arreglo");
	return 0;
}

function cambiaValor(NombreCampo, valor){
	/* -----------------------
		Busca un campo de un formulario y establece su valor. Lo busca tanto por su nombre como por su Id
		en caso de que por razones extrañas (ie6) no lo encuentre...
		retorna el Numero de veces que encontro el campo
	PARAMETROS:
		NombreCampo (string) //-- Nombre o ID del Campo de formulario
		valor (string) //-- valor del campo texto
		nombreFormulario (string)	 -- Opcional --	//-- Nombre del Formulario donde se encuentran los campos
	----------------------- */
    var args;if(window.event){args = cambiaValor.arguments;}else{args = arguments;}
	var Depurar = false;
	var Encontrado = 0;	
	var frmOrigen = "";
	var elemento;
	var Campo;
	if (args.length > 2)
		frmOrigen = args[2];
	if(esVacio(frmOrigen))
		frmOrigen = 0;
	if (args.length > 3)
		Depurar = args[3];
	elemento = document.forms[frmOrigen].elements[NombreCampo];
	if (elemento){ 
		if(!elemento.type && elemento[0].type && elemento[0].type == "radio"){
			if (Depurar) alert("cambiaValor :: Encontro Campo Radio = "+NombreCampo+" por Formulario, Valor = "+valor);
			if (seleccionarRadio(NombreCampo, valor) )
				Encontrado++;
		}else{
			elemento.value = valor;
			if (Depurar) alert("cambiaValor :: Encontro Campo = "+NombreCampo+" por Formulario, Valor = "+valor);
			Encontrado++;
		}
	}else{
		Campo = document.getElementById(NombreCampo);
		if(Campo){
			if(Campo.type != undefined && (Campo.type == 'select-one' || Campo.type == 'checkbox' || Campo.type == 'text' || Campo.type == 'password' || Campo.type == 'hidden') ){
				Campo.value = valor;
				if (Depurar) alert("cambiaValor :: Encontro Campo = "+NombreCampo+" por Id, Valor = "+valor);
				Encontrado++;
			}
		}
	}
	return Encontrado;
}

function eliminarFila(idBodyTabla, idFila, numFilas){
	/* -----------------------
		Elimina la Fila 'NumFila' de la Tabla especificada por 'idBodyTabla' y reindexa o actualiza los 'ids'
		de las Filas siguientes.
	PARAMETROS:
		idBodyTabla (string) //-- Id del TBODY de la Tabla en la que se agregan Filas (atributo id)
		idFila (string) //-- Id de la Fila que se va a eliminar (debe tener el numero dela fila separada por '_', ej: 'Fila_1')
		numFilas (string) //-- Numero de  Filas que se van a actualizar
		estiloFilaPar (string)	-- Opcional --	//-- Nombre de la Clase de Estilo que se aplica cuando la fila de la tabla es Par.
	----------------------- */
	// Validamos q el NumFila exista.
    var args;if(window.event){args = eliminarFila.arguments;}else{args = arguments;}
	var Tabla = document.getElementById(idBodyTabla);
	var Fila = document.getElementById(idFila);
	var destinoIMG = "";
	var estiloFilaPar = "";		
	if (args.length > 3)
		estiloFilaPar = args[3];
	// Debe Haber Tabla, con Filas, Debe Haber Fila con atributo 'id'
	if (!Tabla || !Tabla.rows || !Fila || !Fila.getAttribute("id")){
		alert("Error eliminarFila :: Tabla o Fila No Existen o sin ID");
		return false;
	}
	// Obtenemos Numero de Fila Actual
	var nombreFilas = Fila.getAttribute("id").split("_");
	var numFila = parseInt(nombreFilas[1]);
	nombreFilas = nombreFilas[0];	
	if (numFila > numFilas) {
		alert("Error eliminarFila :: Fila a Eliminar sobrepasa el Maximo");
		return false;
	}	
	// Eliminamos Fila Actual
	document.getElementById(idBodyTabla).removeChild( document.getElementById(idFila) );
	Tabla = document.getElementById(idBodyTabla);
	// Actualizamos las Filas siguientes
	var str = "";
	for(var i = (numFila + 1); i <= numFilas; i++){
		str = nombreFilas + "_" + String(i);
		if(!document.getElementById(str) ){
			alert("Error eliminarFila :: No encontre Fila: "+str);
		}else{
			Fila = document.getElementById(str);
			if ( (i-1) % 2 == 0){
				Fila.className = estiloFilaPar;	//Cambiamos Clase de la Nueva Fila si es Par	
			}else{
				Fila.className = "";
			}
			procesarAtributo(Fila, "id", i-1);//Cambiamos Id de la Nueva Fila
			procesarEtiqueta(Fila, "INPUT", i-1);
			procesarEtiqueta(Fila, "SPAN", i-1);
			procesarEtiqueta(Fila, "SELECT", i-1);
			procesarEtiqueta(Fila, "IMG", i-1, destinoIMG);
		}		
	}
	return true;
}

function limpiarCampo(campo){
	/* -----------------------
		Limpia determinado Campo
	PARAMETROS:
		campo (string) //-- Id del Campo a Limpiar
	----------------------- */
	cambiaTxtCampo(campo,"");
	return;
}

function limpiarSelect(IdSelect){
	/* -----------------------
		Elimina las opciones de un campo select, Si no se especifica el segundo parametro se deja solo una opcion en el select
	PARAMETROS:
		IdSelect (string) //-- Id del SELECT
		MinOpc (string) -- Opcional -- //-- Numero de Opciones que NO se van a eliminar
	----------------------- */
	var args;if(window.event){args = limpiarSelect.arguments;}else{args = arguments;}
    var MinOpc = 1;
	if (args.length > 1)
		MinOpc = parseInt(args[1]);	
	var campoSelect = document.getElementById(IdSelect);
	var MaxOpts = campoSelect.options.length;
	for (var i = MaxOpts; i >= MinOpc; i--){
		campoSelect.options[i] = null;
	}
}

function mostrarBoton(nombre, mostrar){
	/* -----------------------
		Muestra o Oculta un Boton, compuesto de una Imagen y un Boton que tienen un mismo nombre
	PARAMETROS:
		nombre (string) //-- Nombre del Boton Compuesto o Nombre que comparten los 2 elementos (IMG, BTN)
		mostrar (boolean) //-- Indica si muestra o oculta el boton
	----------------------- */
	mostrarElemento("img"+ nombre, mostrar);
	mostrarElemento("btn"+ nombre, mostrar);
}

function mostrarElemento(idElemento, mostrar){
	/* -----------------------
		Busca un Elemento HTML por su ID: 'IdElemento', y lo muestra o lo oculta dependiendo de la variable 'mostrar'
	PARAMETROS:
		IdElemento (string)	 //-- Identificador del Elemento HTML (id).
		mostrar (boolean) //-- Determina si se Muestra o se Oculta el Elemento
	----------------------- */
	if (document.getElementById(idElemento)){
		document.getElementById(idElemento).style.display = mostrar ? '' : 'none';
		return true;
	}
	return false;
}

function procesarAtributo(Nodo, Atributo, nFila){
		/* -----------------------
		Ajusta el Atributo del Nodo Indicado, colocandole el Numero de la Fila. PARTE DE LA FUNCION DE agregarFila
	PARAMETROS:
		Nodo (string) //-- Referencia del Objeto-Nodo sobre el cual se va a trabajar
		Atributo (string) //-- Nombre de Atributo a Modificar
		nFila (integer) //-- Numero de Fila
	----------------------- */
	var Nombre = "";
	// Examinamos Si existe el Atributo Indicado
	if(Nodo.getAttribute(Atributo) ){
		Nombre = Nodo.getAttribute(Atributo).split("_");
		Nombre = Nombre[0] + "_" + nFila;
		Nodo.setAttribute(Atributo, Nombre);
	}
}

function procesarEtiqueta(ObjFila, Etiqueta, nFila){
		/* -----------------------
	Ajusta los Atributos de De cada Etiqueta en la Fila Nueva (ObjFila). PARTE DE LA FUNCION DE agregarFila
	PARAMETROS:
		ObjFila (string) //-- Referencia del Objeto-Fila sobre el cual se va a trabajar
		Etiqueta (string) //-- Nombre de la Etiqueta (TAG HTML) a Trabajar
		nFila (integer) //-- Numero de Fila
	----------------------- */
	var args;if(window.event){args = procesarEtiqueta.arguments;}else{args = arguments;}
    var i;
	if (args.length > 3){
		destinoIMG = args[3];
    }
	var ListaNodos = ObjFila.getElementsByTagName(Etiqueta);
	for (i = 0; i < ListaNodos.length; i++){
		procesarAtributo(ListaNodos[i], "name", nFila);
		procesarAtributo(ListaNodos[i], "id", nFila);
		if(Etiqueta == "SELECT")
			ListaNodos[i][0].selected = true;
		/*if(Etiqueta == "IMG")
			;//ListaNodos[i].setAttribute("onClick", "imgContinuar('" + document.forms[0].name + "','" + destinoIMG + nFila + "')");*/
	}
}

/**
 * Quita filas de una tabla hasta dejar solo un numero de filas dado
 * @param idTabla -- Nombre de la tabla
 * @param numFilas -- Numero de filas a dejar. Opcional por defecto 1
 **/
function quitarFilasTabla(idTabla, numFilas){
    if(!numFilas){
        numFilas = 1;
    }
    var cuerpoTabla = $(idTabla);
	while (cuerpoTabla && cuerpoTabla.rows && cuerpoTabla.hasChildNodes() && cuerpoTabla.rows.length > numFilas){
		cuerpoTabla.removeChild(cuerpoTabla.lastChild);
	}
}


/*****************
		FORMATO VISUAL
*****************/

function aMayusculas(object){
	/* -----------------------
		Cambia a mayuscula las letras que se escriban en un campo de texto (INPUT type=text).
		Se debe usar con el evento 'OnkeyUp', Despues de haber presionado la tecla
	PARAMETROS:
		object (objeto) := 'this.form.NombreCampo' //-- Objeto, Campo del Form Actual.
	----------------------- */
	object.value = object.value.toUpperCase();
}

function aMinusculas(object){
	/* -----------------------
		Cambia a minuscula las letras que se escriban en un campo de texto (INPUT type=text).
		Se debe usar con el evento 'OnkeyUp', Despues de haber presionado la tecla
	PARAMETROS:
		object (objeto) := 'this.form.NombreCampo' //-- Objeto, Campo del Form Actual.
	----------------------- */
	object.value = object.value.toLowerCase();
}

function cambiarClase(IdElemento,nuevaClase){
	/* -----------------------
		Busca un Elemento HTML por su ID: 'IdElemento', y luego cambia su estilo de clase.
	PARAMETROS:
		IdElemento (string)	 //-- Identificador del Elemento HTML (id).
		nuevaClase (string) //-- Nombre de la nueva clase de estilo (atributo class).
	----------------------- */
	if(document.getElementById(APP_JS_IdSpan + IdElemento)){
		document.getElementById(APP_JS_IdSpan + IdElemento).className = nuevaClase;
		return true;
	}else if(document.getElementById(IdElemento)){
		document.getElementById(IdElemento).className = nuevaClase;
		return true;
	}
	return false;
}

function conFormatoMoneda(ObjCampoFormato, ActFormato){
	/* -----------------------
		Actualiza el Formato de Moneda de Campos Valor
	PARAMETROS:
		ObjCampoFormato (string)	 //-- Nombre del Campo Formato
		ActFormato (boolean) //-- Indica si debe o no Actualizar el formato del objeto
		idCampoNormal (string) -- Opcional -- //-- Nombre del campo que tiene el valor sin Formato
		decimales (string) -- Opcional -- //-- Numero de decimales en el formato
	----------------------- */
    var args;if(window.event){args = conFormatoMoneda.arguments;}else{args = arguments;}
	var Valor = "";
	var idCampoNormal = "";	
	var idCampoFormato = "";
	if (args.length > 2){
		idCampoNormal = String(args[2]);
		idCampoFormato = "Val" + idCampoNormal;
        if(document.getElementById(idCampoNormal)){
            Valor = leerCampoX(idCampoNormal);
        }
	}else{
		idCampoFormato = ObjCampoFormato.name;
		idCampoNormal = ObjCampoFormato.name.substr(3); // Quitamos los primeros 3 caracteres del Nombre del CampoValor 'Val'
		Valor = ObjCampoFormato.value;	
	}
	if (ActFormato && document.getElementById(idCampoFormato)){
		var objFrmtNum = new NumberFormat();
		objFrmtNum.setInputDecimal('.');
		objFrmtNum.setSeparators(true, '.', ',');
		objFrmtNum.setNumber(Valor); // Establecemos el Numero a formatear
		var decimales = '2';
		if (args.length > 3)
			decimales = String(args[3]);
		objFrmtNum.setPlaces(decimales, false);// Numero de Decimales, Sin Truncar
		cambiaTxtCampo(idCampoFormato, objFrmtNum.toFormatted());
	}
    cambiaTxtCampo(idCampoNormal, Valor);
	return;
}

function formatNum(Numero){
	/* -----------------------
		Da Formato visual (Separacion de Miles) DE NUMEROS ENTEROS POSITIVOS
		Utilizamos el caracter "," (coma) para la separacion de miles.
	PARAMETROS:
		Numero (string) //-- Representacion en Cadena (string) del Numero Entero.
	----------------------- */
	var Separador = ".";
	var Resultado = "";
	var j = 0;
	var i = 0;
	for (i = Numero.length - 1, j = 0; i >= 0; i--, j++)
		Resultado = Numero.charAt(i) + ((j > 0) && (j % 3 == 0)? Separador: "") + Resultado;
	return Resultado;
}

function redondear(num, dec){
	/* -----------------------
		Redondear un numero (num) con la cantidad de decimales (dec) especificada.
	PARAMETROS:
		num (Double) //-- Numero que se va a Redondear.
		dec (Integer) //-- Numero de decimales.
	----------------------- */
	num = parseFloat(num);
	dec = parseInt(dec);
	return Math.round(num * Math.pow(10, dec)) / Math.pow(10, dec);
} 

function sinFormatoMoneda(obj){
	/* -----------------------
		Quita el formato moneda de un campo valor
	PARAMETROS:
		obj (Objeto Formulario) //-- Objeto Formulario del campoValor
	----------------------- */
	if(obj.name){
		var idCampoNormal = obj.name.substr(3); // Quitamos los primeros 3 caracteres del Nombre del CampoValor 'Val'
		pasarCampo(idCampoNormal, obj.id);
	}
}

/*****************************************************
		REDIRECCIONAMIENTO DE FORMULARIOS, VENTANAS, ALERTAS 
*****************************************************/

function abrirAyuda(pagina,titulo,ancho,alto){
	/* -----------------------
		Abre una ventana de Ayuda como POPUP, solo permite una a la vez, se puede especificar Ancho y Alto.
	PARAMETROS:
		pagina (string) //-- Direccion URL de la pagina que se va abrir.
		titulo (string) //-- Titulo de la Ventana, No se dejan Abrir 2 Ventanas Con el Mismo Nombre
		ancho (string) //-- Numero de pixeles para ancho de la ventana.
		alto	(string) //-- Numero de pixeles para ancho de la ventana.
	----------------------- */	
	if (ventanaAyuda && typeof ventanaAyuda.document == "object") {// Solo permite una ventana a la vez
		ventanaAyuda.close();
	}
	ventanaAyuda = window.open(pagina,titulo,"width="+ancho+",height="+alto+",left=100,top=100,location=NO,menubars=NO,resizable=YES,scrollbars=YES,statusbar=NO,status=NO,toolbar=NO");
}

function abrirAyudaFuncionRetorno(pagina,titulo,ancho,alto,funcion){
	/* -----------------------
		Abre una ventana de Ayuda como POPUP identificada con el 'titulo' indicado. En la ventana se ejecutara
		la funcion de JavaScript indicada.		
		Se puede especificar el Alto y Ancho
	PARAMETROS:
		pagina (string) //-- Direccion URL de la pagina que se va abrir.
		titulo (string) //-- Titulo de la Ventana, No se dejan Abrir 2 Ventanas Con el Mismo Nombre
		ancho (string) //-- Numero de pixeles para ancho de la ventana.
		alto	(string) //-- Numero de pixeles para ancho de la ventana.
		funcion (string) //-- Nombre de la funcion de JS del Documento Origen que se ejecuta
	----------------------- */
	if (ventanaAyuda && typeof ventanaAyuda.document == "object")
		ventanaAyuda.close();
	ventanaAyuda = window.open(pagina+'&funretorno2='+funcion,titulo,"width="+ancho+",height="+alto+",left=100,top=100,location=NO,menubars=NO,resizable=YES,scrollbars=YES,statusbar=NO,status=NO,toolbar=NO");
}

function abrirAyudaRetorno(pagina,titulo,ancho,alto,formulario,campo){
	/* -----------------------
		Abre una ventana de Ayuda como POPUP que ademas permite especificar el formulario y el campo donde se 
		pueden retornar datos, solo permite una a la vez, se puede especificar Ancho y Alto.
		Ademas permite especificar el nombre de una funcion javascript que se ejecute cuando se retorne el valor
		Para que funcione, es necesario que la pagina destino procese los parametros ('formulario', 'nomcampo' y
	  opcionalmente 'funretorno')
	PARAMETROS:
		pagina (string) //-- Direccion URL de la pagina que se va abrir.
		titulo (string) //-- Titulo de la Ventana, No se dejan Abrir 2 Ventanas Con el Mismo Nombre
		ancho (string) //-- Numero de pixeles para ancho de la ventana.
		alto	(string) //-- Numero de pixeles para ancho de la ventana.
		formulario (string) //-- Nombre del formulario donde se retornan los datos.
		campo	(string) //-- Nombre del campo donde se retornan los datos.
		funcion (string) -- Opcional --  //-- Nombre de la funcion de JS del Documento Origen que se ejecuta
	----------------------- */
	var args;if(window.event){args = abrirAyudaRetorno.arguments;}else{args = arguments;}
    var funcion = false;	
	// Vemos Si se colocaron los Parametros Opcionales
	if (args.length > 6)
		funcion = args[6];
	if (ventanaAyuda && typeof ventanaAyuda.document == "object")
		ventanaAyuda.close();
	if (!funcion)
		ventanaAyuda = window.open(pagina+'&formulario='+formulario+'&nomcampo='+campo,titulo,"width="+ancho+",height="+alto+",left=100,top=100,location=NO,menubars=NO,resizable=YES,scrollbars=YES,statusbar=NO,status=NO,toolbar=NO");
	else
		ventanaAyuda = window.open(pagina+'&formulario='+formulario+'&nomcampo='+campo+'&funretorno='+funcion,titulo,"width="+ancho+",height="+alto+",left=100,top=100,location=NO,menubars=NO,resizable=YES,scrollbars=YES,statusbar=NO,status=NO,toolbar=NO");
}

function abrirVentana(url,titulo){
	/* -----------------------
		Abre una ventana window prototype, estableciendo el URL y el titulo.
		Debe existir el objeto 'win' como un objeto prototype 
	PARAMETROS:
		url (string) //-- Direccion URL de la pagina que se va abrir.
		titulo (string) //-- Titulo de la Ventana.
	----------------------- */
	if (win){
		win.setURL(url);
		win.setTitle(titulo);
		win.showCenter(true);
	} 
}

function abrirVentanaFuncion(url,titulo,funcion){
	/* -----------------------
		Abre una ventana window prototype  que devuelve un valor al formulario actual.
		ademas opcionalmente indicar una funcion que se ejecuta cuando se retorna el valor
		Permiter establecer el URL y el titulo Debe existir el objeto 'win' como un objeto prototype. 
	PARAMETROS:
		url (string) //-- Direccion URL de la pagina que se va abrir.
		titulo (string) //-- Titulo de la Ventana.
		funcion (string) //-- Nombre de la funcoin a ejecutar
	----------------------- */
	abrirVentana(url+'&funretorno='+funcion,titulo);
}

function abrirVentanaRetorno(url,titulo,campo){
	/* -----------------------
		Abre una ventana window prototype  que devuelve un valor al formulario actual.
		ademas opcionalmente indicar una funcion que se ejecuta cuando se retorna el valor
		Permiter establecer el URL y el titulo Debe existir el objeto 'win' como un objeto prototype. 
	PARAMETROS:
		url (string) //-- Direccion URL de la pagina que se va abrir.
		titulo (string) //-- Titulo de la Ventana.
	----------------------- */
	var args;if(window.event){args = abrirVentanaRetorno.arguments;}else{args = arguments;}
    var funcion = false;
	// Vemos Si se colocaron los Parametros Opcionales
	if (args.length > 3)
		funcion = args[3];
	if (!funcion)
		abrirVentana(url+'&nomcampo='+campo,titulo);
	else
		abrirVentana(url+'&nomcampo='+campo+'&funretorno='+funcion,titulo);
}

function actCampoHora(nombre){
	/* -----------------------
		Actualiza el valor de un Campo Hora de acuerdo al valor de los selects Hora, Minutos y Meridiano (Am/Pm) 
	PARAMETROS:
			nombre (String) //-- Nombre del campoHora
	----------------------- */
	if(document.getElementById(nombre)){
		var H = document.getElementById("h_"+nombre).value;
		var M = document.getElementById("m_"+nombre).value;
		var APM = document.getElementById("apm_"+nombre).value;
		document.getElementById(nombre).value = H+":"+M+" "+APM;
	}	
}

function buscarEnArreglo(valor,arreglo){
	/* -----------------------
		Evalua si un valor se encuentra en un Arreglo, si se encuentra retorna true, en caso contrario false.
	PARAMETROS:
			valor (String) //-- Nombre del valor a buscar.
			arreglo (String) //-- Nombre del Array en el que se debe buscar el campo valor.
	----------------------- */
	for(var i=0;i<=arreglo.length;i++){
			if(valor == arreglo[i]) return true;
	}
	return false;
}

function buscarLlaveTablaX(FuncConsulta){
	/* -----------------------
		Funcion Comun para tratar las busquedas de Llaves de las Tablas, con X campos
	  Se consulta siempre que alguno de los campos tenga un valor diferente al ultimo consultado
	  los demas parametros son el numero de campos que se evaluan para realizar la consulta,
	  van en parejas de campoLlave y campoUltimaLlave donde el primero es donde el usuario interviene y el ultimo
	  es la ultima consulta realizada por el usuario (para que la consulta solo se lleve a cabo cuando se cambie)
	  El numero de parametros siempre sera impar
	PARAMETROS:
			FuncConsulta (String) //-- Nombre de la funcion javascript que se llama para realizar la consulta
			LlaveX (String) //-- Nombre del Campo que se puede modificar.
			UltimaLlaveX (String) //-- Nombre del Campo que tiene el valor de la ultima consulta
	----------------------- */
    var args;if(window.event){args = buscarLlaveTablaX.arguments;}else{args = arguments;}
	if( (args.length % 2) == 0 ){
		alert("buscarLlaveTablaX :: Numero de Parametros Incorrecto");
		return false;
	}
	var numCampos = args.length -1;
	var LlaveX;
	var UltimaLlaveX;
	for(var i = 1; i <= numCampos; i = i + 2){
		LlaveX = leerCampoX(args[i]);
		if(esVacio(LlaveX))	
			return true;
	}
	for(i = 1; i <= numCampos; i = i + 2){
		LlaveX = leerCampoX(args[i]);
		UltimaLlaveX = leerCampoX(args[i+1]);
		if(LlaveX != UltimaLlaveX)
			eval(FuncConsulta);
	}
	return true;
}

function buscarLlaveTablaX2(FuncConsulta){
	/* -----------------------
		Similar a buscarLlaveTablaX solo que evalua la FuncionConsulta siempre que exista un cambio
	  Pero esta funcion no tiene en cuenta si el nuevo valor es Vacio
	PARAMETROS:
			FuncConsulta (String) //-- Nombre de la funcion javascript que se llama para realizar la consulta
			LlaveX (String) //-- Nombre del Campo que se puede modificar.
			UltimaLlaveX (String) //-- Nombre del Campo que tiene el valor de la ultima consulta
	----------------------- */
    var args;if(window.event){args = buscarLlaveTablaX2.arguments;}else{args = arguments;}
	if( (args.length % 2) == 0 ){
		alert("buscarLlaveTablaX2 :: Numero de Parametros Incorrecto");
		return false;
	}
	var numCampos = args.length -1;
	for(i = 1; i <= numCampos; i = i + 2){
		var LlaveX = leerCampoX(args[i]);
		var UltimaLlaveX = leerCampoX(args[i+1]);
		if(LlaveX != UltimaLlaveX)
			eval(FuncConsulta);
	}
	return true;
}

function	cambiarSelectSegunIndice(idSelect, idOpcion, Arreglo){
	/* -----------------------
		Cambia las opciones de un campo select, de acuerdo al Indice seleccionado en el Campo Opcion
		Debe existir un Arreglo de opciones de select para cada Opcion Seleccionada del campo 'idOpcion'
		(Arreglo de 3 dimensiones) [indiceSeleccionado][TextoOpcion][ValorOpcion]
	PARAMETROS:
			idSelect (String) //-- Nombre del campo SELECT que se quiere modificar
			idOpcion (String) //-- Nombre del campo al que se va a laeer el Indice Actual (OPTION,SELECT) que se va a leer
			Arreglo (String) //-- Nombre del arreglo del que se obtienen los valores
	----------------------- */
	var Opc = indiceAct(idOpcion);
	if(Opc > -1){
		limpiarSelect(idSelect);
		pasarArregloASelect(idSelect, Arreglo+"["+Opc+"]");
	}
}

function confirmarBorrado(form, mensaje){
	/* -----------------------
		Muestra una ventana que pide confirmacion para que se limpie un formulario
	PARAMETROS:
		form (objeto) := this.form	 //-- Representa el Objeto del Formulario
		mensaje (string) //-- Mensaje que mostrara la ventana de confirmacion al usuario.
	----------------------- */
	var borrar = window.confirm(mensaje);
	if(borrar) return true;
	else return false;
}

function confirmarEnvio(form, mensaje){
	/* -----------------------
		Muestra una ventana que pide confirmacion para que se envie un formulario
	PARAMETROS:
		form (objeto) := this.form	 //-- Representa el Objeto del Formulario
		mensaje (string) //-- Mensaje que mostrara la ventana de confirmacion al usuario.
	----------------------- */
	var enviar = window.confirm(mensaje);
	if(enviar)
		return true;
	else
		return false;
}

function continuar(form, destino){
	/* -----------------------
		Redirecciona un Formulario (form) a la Pagina indicada (destino).
		Solo funciona con Objetos que pertenezcan a un formulario (input). 
		Para redireccionar un formulario por su nombre utilice la funcion 'imgContinuar'		
	PARAMETROS:
		form (objeto) := this.form //-- Representa el Objeto del Formulario
		destino (string) := 'dir.html' //-- Direccion URL de la Pagina de Destino
		ventana (string) OPCIONAL //-- Define el Target del destino (_self, _parent, _blank)
	----------------------- */
	var args;if(window.event){args = continuar.arguments;}else{args = arguments;}
    var ventana = "_self";
	if (args.length > 2){
		ventana = args[2];
	}
	form.action = destino;
	form.target = ventana;
	form.submit();
}

function continuarFormulario(destino){
	/* -----------------------
		Redirecciona el  Formulario 0  a la Pagina indicada (destino).
	PARAMETROS:
		destino (string) := 'dir.html' //-- Direccion URL de la Pagina de Destino
		ventana (string) OPCIONAL //-- Define el Target del destino (_self, _parent, _blank)
	----------------------- */
    var args;if(window.event){args = continuarFormulario.arguments;}else{args = arguments;}
	if (args.length > 1)
		continuar(document.forms[0], destino, args[1]);
	else
		continuar(document.forms[0], destino);
	return;
}

function continuarFormularioFrame(NombreFrame, destino){
	/* -----------------------
		Redirecciona el  Formulario 0  a la Pagina indicada (destino).
		ADVERTENCIA, si luego se desea redireccionar el Formulario en la Pagina Actual debe
		asignarse al atributo 'target' el valor "_self", de lo contrario el formulario siempre
		se dirigira al Frame.
	PARAMETROS:
		NombreFrame (string) // nombre del frame o Iframe de Destino del Formulario.
		destino (string) := 'dir.html' //-- Direccion URL de la Pagina de Destino
		frmOrigen (string) --OPCIONAL-- //-- Nombre del Formulario Origen
	----------------------- */
    var args;if(window.event){args = continuarFormularioFrame.arguments;}else{args = arguments;}
	var frmOrigen = "";
	if (args.length > 2){
		frmOrigen = args[2];	
		if (!document.forms[frmOrigen])
			frmOrigen = "";
	}
	if(esVacio(frmOrigen)){
		document.forms[0].action = destino;
		document.forms[0].target = NombreFrame;
		document.forms[0].submit();
	}else{
		document.forms[frmOrigen].action = destino;
		document.forms[frmOrigen].target = NombreFrame;
		document.forms[frmOrigen].submit();
	}
	return;
}

function consultarLlaveServX(txtError){
	/* -----------------------
		Funcion comun para tratar las consultas al Servidor con una llave compuesta por X campos
		los demas parametros son opcionales y deben estar por parejas de campo y parametro
		Por tanto el numero de Argumentos siempre sera impar
		Requiere que exista la funcion consultarServidor
	PARAMETROS:
		txtError (string) // Texto de Error q muestra cuando falta un valor
		campo (string) -- Opcional -- //-- Nombre del campo del formulario que se evalua
		parametro (string) -- Opcional -- //-- Parametro URL donde se envian los datos
	----------------------- */
    var args;if(window.event){args = consultarLlaveServX.arguments;}else{args = arguments;}
	if( (args.length % 2) == 0 ){
		alert("consultarLlaveServX :: Numero de Parametros Incorrecto");
		return false;
	}
	var numCampos = args.length -1;
	var cadenaServ = '?';	
	for(var i = 1; i <= numCampos; i = i + 2){
		var campoX = leerCampoX(args[i]);
		if(esVacio(campoX)){
			alert(txtError);
			return false;
		}
		if(esVacio(args[i+1]) ){
			return false;
		}
		cadenaServ += '&' + args[i+1] + '=' + encodeURIComponent(campoX);
	}	
	if(!esVacio(cadenaServ))
		consultarServidor(cadenaServ);
	return true;
}

function consultarLlaveServX2(){
	/* -----------------------
		Funciona de la misma forma que 'consultarLlaveServX' solo que no valida si los campos estan vacios
		por lo tanto no pide un mensaje de error.
	PARAMETROS:
		campo (string) -- Opcional -- //-- Nombre del campo del formulario que se evalua
		parametro (string) -- Opcional -- //-- Parametro URL donde se envian los datos
	----------------------- */
    var args;if(window.event){args = consultarLlaveServX2.arguments;}else{args = arguments;}
	if( (args.length % 2) != 0 ){
		alert("consultarLlaveServX2 :: Numero de Parametros Incorrecto");
		return false;
	}
	var numCampos = args.length;
	var cadenaServ = '?';	
	for(var i = 0; i < numCampos; i = i + 2){
		var campoX = leerCampoX(args[i]);
		if(esVacio(args[i+1]) ){
			return false;
		}
		cadenaServ += '&' + args[i+1] + '=' + encodeURIComponent(campoX);
	}
	if(!esVacio(cadenaServ))
		consultarServidor(cadenaServ);
	return true;
}

function direccionarFrame(NombreFrame, destino){
	/* -----------------------
		Direcciona un Frame o Iframe al Destino Especificado
	PARAMETROS:
		NombreFrame (string) //-- nombre e ID (debe tener los 2) del frame o Iframe.
		destino (string) := 'dir.html'	 //-- Direccion URL de la Pagina de Destino
	----------------------- */
	var bodyIframe;
	if(document.frames){
		bodyIframe = document.frames[NombreFrame]; // Para IE
	}else{
		bodyIframe = document.getElementById(NombreFrame).contentDocument; //Para Verdaderos Browsers
	}
	bodyIframe.location = destino;	
}

function indiceAct(NombreObjeto){
	/* -----------------------
		Encuentra el indice actual seleccionado para controles SELECT y RADIO,
		En caso de q no lo encuentre devuelve -1
	PARAMETROS:
		NombreObjeto (string) //-- nombre e ID del control a revizzar 
	----------------------- */
	var Campo = document.getElementById(NombreObjeto);
	if(Campo && Campo.type == "radio" || Campo.type == "select-one"){
		if(Campo.type == "radio"){
			for (var i = 0; i < Campo.length; i++) {	
				if (Campo[i].checked) return i;
			}
		}else
			return Campo.selectedIndex;
	}else{
		alert("Error indiceAct :: No se encuentra "+NombreObjeto);
	}
	return -1;
}

function imgContinuar(origen, destino){
	/* -----------------------
		Redirecciona un Formulario (origen) por su Nombre, a la Pagina indicada (destino).
		funciona para cualquier elemento HTML, especialmente para Imagenes (img). 
	PARAMETROS:
		origen (string) := 'frmMyForm'	 //-- Nombre del Formulario Origen
		destino (string) := 'dir.html'	 //-- Direccion URL de la Pagina de Destino
	----------------------- */
	document.forms[origen].action = destino;
	document.forms[origen].submit();	
}

function leerCampoX(NombreCampo){
	/* -----------------------
		Lee el valor contenido en el Campo que se llama 'NombreCampo'
	PARAMETROS:
		NombreCampo (string) := 'txtCampoEntero'	//-- Nombre (atributo name) del Campo (input) que se va a leer
		frmOrigen (string) --Opcional-- //-- Nombre o Num del Formulario Origen, si no se especifica se asume el Formulario 0
	----------------------- */	
	var args;if(window.event){args = leerCampoX.arguments;}else{args = arguments;}
    var frmOrigen = "";
	var Valor;
	if (args.length > 1){
		frmOrigen = args[1];
    }
	if(esVacio(frmOrigen)){
		frmOrigen = 0;
    }
	if (document.forms[frmOrigen].elements[NombreCampo] && document.forms[frmOrigen].elements[NombreCampo].value != undefined){
		Valor = document.forms[frmOrigen].elements[NombreCampo].value;
		//alert("Encontro "+NombreCampo+" Por Formulario, Valor: " + Valor);
	}else if(document.getElementById(NombreCampo) && document.getElementById(NombreCampo).value != undefined){
		Valor = document.getElementById(NombreCampo).value;
		//alert("Encontro "+NombreCampo+" Por ID, Valor: " + Valor);
	}else if(document.getElementById(NombreCampo) && document.getElementById(NombreCampo).type == "radio"){
		Valor = document.getElementById(NombreCampo).value;
		//alert("Encontro "+NombreCampo+" Por ID (Radio), Valor: " + Valor);
	}else{
		alert("Error leerCampoX :: NO SE ENCUENTRA '" + NombreCampo + "'");
    }
	return Valor;
}

function leerCampoEntero(NombreCampo){
	/* -----------------------
		Lee el valor contenido en el Campo que se llama 'NombreCampo' y convierte su valor a Entero
		si no es un Entero Retorna 0, si no existe el campo retorna falso.
	PARAMETROS:
		NombreCampo (string) := 'txtCampoEntero'	//-- Nombre (atributo name) del Campo (input) que se va a leer
		frmOrigen (string) --Opcional-- //-- Nombre o Num del Formulario Origen, si no se especifica se asume el Formulario 0
	----------------------- */
    var args;if(window.event){args = leerCampoEntero.arguments;}else{args = arguments;}
	var frmOrigen = "";
	var Num = 0;
	if (args.length > 1)
		frmOrigen = args[1];
	Num = leerCampoX(NombreCampo, frmOrigen);
	Num =  parseInt(Num);
	if (isNaN(Num) )
		Num = 0;
	return Num;
}

function leerCampoFlotante(NombreCampo){
	/* -----------------------
		Lee el valor contenido en el Campo que se llama 'NombreCampo' y convierte su valor a Entero
		si no es un Entero Retorna 0, si no existe el campo retorna falso.
	PARAMETROS:
		NombreCampo (string) := 'txtCampoEntero'	//-- Nombre (atributo name) del Campo (input) que se va a leer
		frmOrigen (string) --Opcional-- //-- Nombre o Num del Formulario Origen, si no se especifica se asume el Formulario 0
	----------------------- */
    var args;if(window.event){args = leerCampoFlotante.arguments;}else{args = arguments;}
	var frmOrigen = "";
	var Num = 0;
	if (args.length > 1)
		frmOrigen = args[1];
	Num = leerCampoX(NombreCampo, frmOrigen);
	Num =  parseFloat(Num);
	if (isNaN(Num) )
		Num = 0;
	return Num;
}

function obtenerNumFila(obj){
	/* -----------------------
		Retorna numero de Fila para objetos que tengan definido el atributo name como: "nombreobj_numfila",
		separado por el caracter '_'
		Recibe un objeto, Lee su atributo NAME o y lo separa de acuerdo al caracter '_' retornando cualquier 
		cadena despues de este.
	PARAMETROS:
		obj (objeto) := 'this'	//-- Objeto que tenga el atributo name
	----------------------- */
	var Nombre = "";
	if (obj.name)	Nombre = obj.name.split("_");
	else if (obj.id)	Nombre = obj.id.split("_");
	if(Nombre.length > 1)
			return Nombre[Nombre.length - 1];
	return false;
}

function pasarArregloASelect(IdSelect, NombArreglo){
	/* -----------------------
		Agrega opciones a un campo select de un arreglo tipo Matriz.
		La lista (arreglo) de valores (value) para cada opcion debe estar en la posicion 0 de la arreglo: (arreglo[0])
		La lista (arreglo) de descipciones para cada opcion debe estar en la posicion 1 de la arreglo: (arreglo[1])
		Ej:  arreglo[0][0] = "1", arreglo[1][0] = "Opcion 1", 
		Corresponde a una opcion con valor = "1", y Texto: "Opcion 1"	
	PARAMETROS:
		IdSelect (string) //-- Id del control Select
		NombArreglo (string) //-- Nombre del arreglo de donde se toman los datos 
	----------------------- */ 
	var Arreglo = eval(NombArreglo);
	var campoSelect = document.getElementById(IdSelect);
	if(!campoSelect){
		alert("Error pasarArregloASelect :: NO SE ENCUENTRA '" + IdSelect + "'");
		return false;
	}
	var miOpcion;
	for (var i = 0; i < Arreglo[0].length ; i++){
		//alert("Opc:   "+Arreglo[1][i]+" ==> "+Arreglo[0][i] );
		if(Arreglo[1][i] == undefined || Arreglo[0][i] == undefined)
			continue;
		miOpcion = new Option(Arreglo[1][i], Arreglo[0][i]);
		campoSelect.options[campoSelect.options.length] = miOpcion;
	}
	campoSelect.selectedIndex = 0;
	return true;
}

function pasarACheckBox(Origen, Destino){
	/* -----------------------
		Si el Valor del Campo Origen tiene algun valor distinto de 0 o vacio, el CheckBox quedara seleccionado
	PARAMETROS:
		Origen (string) //-- Id o Nombre del Objeto de Origen de los datos
		Destino (string) //-- Id o Nombre del Objeto de Destino de los datos 
	----------------------- */ 
	document.forms[0].elements[Destino].checked = leerCampoEntero(Origen);
}

function pasarCampo(Origen, Destino){
	/* -----------------------
		pasa el Contenido de un campo a otro
	PARAMETROS:
		Origen (string) //-- Id o Nombre del Objeto de Origen de los datos
		Destino (string) //-- Id o Nombre del Objeto de Destino de los datos 
	----------------------- */ 
	var ValorOrigen = leerCampoX(Origen);
	if (ValorOrigen != undefined )
		cambiaTxtCampo(Destino, ValorOrigen);
}

function pasarCampoChk(Origen, Destino){
	/* -----------------------
		Si el Campo CheckBox esta seleccionado Pasa al Destino '1' de lo contrario '0'
	PARAMETROS:
		Origen (string) //-- Id o Nombre del Objeto de Origen de los datos
		Destino (string) //-- Id o Nombre del Objeto de Destino de los datos 
	----------------------- */ 
	if (document.forms[0].elements[Origen].checked )
		cambiaTxtCampo(Destino, "1");
	else
		cambiaTxtCampo(Destino, "0");
}

function pasarCampoSel(Origen, Destino){
	/* -----------------------
		Pasa la Descripcion y el Codigo de un Campo Select a un Campo lectura (Descripcion y Codigo)
	PARAMETROS:
		Origen (string) //-- Id o Nombre del Objeto de Origen de los datos
		Destino (string) //-- Id o Nombre del Objeto de Destino de los datos 
	----------------------- */ 
	var ValorOrigen = leerCampoX(Origen);
	var Indice = document.forms[0].elements[Origen].selectedIndex;
	var Texto = document.forms[0].elements[Origen].options[Indice].text;
	if(Indice != undefined){
		//alert("Campo: "+Origen+", Indice: "+Indice+", Texto: "+Texto);
		cambiaTxtCampo(Destino, Texto, ValorOrigen);
	}
}

function pasarCampoVal(Origen, Destino){
	/* -----------------------
		Pasa el valor de un campo a un Campo Tipo Valor
	PARAMETROS:
		Origen (string) //-- Id o Nombre del Objeto de Origen de los datos
		Destino (string) //-- Id o Nombre del Objeto de Destino de los datos 
	----------------------- */ 
	var ValorOrigen = leerCampoX(Origen);
	if (ValorOrigen != undefined )
		cambiaCampoValor(Destino, ValorOrigen);
}

function pasarCampoFormato(Origen, Destino){
	/* -----------------------
		Pasa el valor de un campo a un Campo Lectura con Formato
	PARAMETROS:
		Origen (string) //-- Id o Nombre del Objeto de Origen de los datos
		Destino (string) //-- Id o Nombre del Objeto de Destino de los datos
		objFrmtNum (Objeto) //-- Objeto para realizar el formato 
	----------------------- */
    var args;if(window.event){args = pasarCampoFormato.arguments;}else{args = arguments;}
	var objFrmtNum = null;	
	valor = leerCampoFlotante(Origen);	
	if (args.length > 2){
		objFrmtNum = args[2];
		cambiaCampoFormato(Destino, valor, objFrmtNum);
	}else{
		cambiaCampoFormato(Destino, valor);
	}
}

function seleccionarRadio(IdRadio, Valor){
	/* -----------------------
		Selecciona una opcion especifica de un campo Radio Button 
	PARAMETROS:
		IdRadio (string) // nombre del objeto RADIO
		Valor (string) // Valor o Opcion a Seleccionar
		frmOrigen (string) --OPCIONAL-- // Nombre o Numero del Formulario Origen
	----------------------- */
    var args;if(window.event){args = seleccionarRadio.arguments;}else{args = arguments;}
	var frmOrigen = 0;
	if (args.length > 2){
		frmOrigen = args[2];
		if (!document.forms[frmOrigen])
			frmOrigen = 0;
	}
	var Campo = document.forms[frmOrigen].elements[IdRadio];
	if(Campo){
		for (var i = 0; i < Campo.length; i++) {
			if (Campo[i].value == Valor)
				Campo[i].checked = true;
			else
				Campo[i].checked = false;
		}
		return true;
	}else{
		alert("Error seleccionarRadio :: No se encuentra "+IdRadio);
	}
	return false;
}

function seleccionarValor(IdSelect, Valor){
	/* -----------------------
		Selecciona una opcion especifica de un campo select de acuerdo a su valor 
	PARAMETROS:
		IdSelect (string) // nombre del objeto SELECT
		Valor (string) // Valor o Opcion a Seleccionar
		frmOrigen (string) --OPCIONAL-- // Nombre o Numero del Formulario Origen
	----------------------- */
    var args;if(window.event){args = seleccionarValor.arguments;}else{args = arguments;}
	var frmOrigen = 0;
	if (args.length > 2){
		frmOrigen = args[2];
		if (!document.forms[frmOrigen])
			frmOrigen = 0;
	}
	for(var i=0;i<document.forms[frmOrigen].elements[IdSelect].options.length;i++){
		if(Valor == document.forms[frmOrigen].elements[IdSelect].options[i].value){
			document.forms[frmOrigen].elements[IdSelect].selectedIndex = i;
			return true;
		}
	}
	return false;
}

function parametroUrl(nombre, texto){
	/* -----------------------
		construye un parametro de URL valido, validando el 'texto' enviado no se encuentre vacio y codificando en formato URL, 
	PARAMETROS:
		NombreRadio (string) // nombre del objeto RADIO
	----------------------- */
	var url = "";
	if(!esVacio(nombre) && !esVacio(texto) ){
		url = "&" + nombre + "=" + encodeURIComponent(texto); 
	}
	return url;
}

function valorRadio(NombreRadio){
	/* -----------------------
		Examina un control 'radio' de formulario, y devuelve el valor actual seleccionado. 
		En caso de q no lo encuentre devuelve falso
	PARAMETROS:
		NombreRadio (string) // nombre del objeto RADIO
	----------------------- */
	var Campo = document.forms[0].elements[NombreRadio];
	if(Campo){
		for (var i = 0; i < Campo.length; i++) {
			if (Campo[i].checked) return Campo[i].value;
		}
	}else{
		alert("Error valorRadio :: No se encuentra "+NombreRadio);
	}
	return false;
}

function valorSeleccionado(IdSelect){
	/* -----------------------
		Retorna el valor de la opcion seleccionada de un campo SELECT 
	PARAMETROS:
		IdSelect (string) // nombre del objeto SELECT
		frmOrigen (string) --OPCIONAL-- // Nombre o Numero del Formulario Origen
	----------------------- */
    var args;if(window.event){args = valorSeleccionado.arguments;}else{args = arguments;}
	var frmOrigen = 0;
	if (args.length > 1){
		frmOrigen = args[1];
		if (!document.forms[frmOrigen])
			frmOrigen = 0;
	}
	var indice = document.forms[frmOrigen].elements[IdSelect].selectedIndex;
	var valor = document.forms[frmOrigen].elements[IdSelect].options[indice].value;
	//alert(valor);
	return valor;
}


/**********************************
		VALIDACION DE TECLAS PRESIONADAS 
**********************************/

function campoFecha(e) { 
	/* -----------------------
		Esta funcion valida un campo para que solo se ingresen Digitos y '/', especial para campos de Fecha
		Para uso con el evento onKeyDown. Se debe llamar la funcion con return (onKeyDown=' return campo...')
	PARAMETROS:
		e (objeto) := 'event' //-- Debe enviarse el Objeto que controla los eventos. (event) 
	----------------------- */	
	var evento_key;
	if (window.event)
		evento_key = e.keyCode; 	
	else
		evento_key = e.which; 	
	// Validamos que sea un numero. Ya sea con una tecla del PAD numerico o con las de encima del Alfabetico
	// ademas del caracter de separacion '/'
	if ( (evento_key >= 48 && evento_key <= 57) || (evento_key >= 96 && evento_key <= 105) || evento_key == 111){
		// Validamos que NO se presionen las teclas SHIFT, ni ALT (Para evitar los caracteres especiales)
		// Pero permitimos las teclas del caracter de '/' 
		if ( evento_key != 55 && evento_key != 111 && (e.shiftKey || e.altKey) )
			return false; 
		return true;			
	}
	// Y otros caracteres validos (Tabulacion, retroceso, suprimir, F5, Fin, Inicio, flechas)
	if ( (evento_key >= 8 && evento_key <= 13)  || (evento_key >= 19 && evento_key <= 31) ||  (evento_key >= 33 && evento_key <= 46) || (evento_key >= 91 && evento_key <= 93) || (evento_key >= 112 && evento_key <= 145) )		
		return true;
	return false;
} 

function campoHora(e) { 
	/* -----------------------
		Esta funcion valida un campo para que solo se ingresen Digitos, ':'	"AM-PM", ' ', especial para Hora.
		Para uso con el evento onKeyDown. Se debe llamar la funcion con return (onKeyDown=' return campo...')
	PARAMETROS:
		e (objeto) := 'event' //-- Debe enviarse el Objeto que controla los eventos. (event) 
	----------------------- */
	var evento_key;
	if (window.event)
		evento_key = e.keyCode; 	
	else
		evento_key = e.which;
	// Validamos que sea un numero. Ya sea con una tecla del PAD numerico o con las de encima del Alfabetico
	if ( (evento_key >= 48 && evento_key <= 57) || (evento_key >= 96 && evento_key <= 105) ){
		// Validamos que NO se presionen las teclas SHIFT, ni ALT (Para evitar los caracteres especiales)
		// Pero permitimos las teclas del caracter de '/' 
		if ( e.shiftKey || e.altKey )
			return false; 
		return true;			
	}
	// Aceptamos las letras A, M, P el espacio y el caracter ':'
	if(evento_key == 65 || evento_key == 77 || evento_key == 80 || evento_key == 32 || evento_key == 190){
		// Para el caracter del ':' es obligatorio el uso del Shift
		if(evento_key == 190 && !e.shiftKey)
			return false;
		return true;
	}		
	// Y otros caracteres validos (Tabulacion, retroceso, suprimir, F5, Fin, Inicio, flechas)
	if ( (evento_key >= 8 && evento_key <= 13)  || (evento_key >= 19 && evento_key <= 31) ||  (evento_key >= 33 && evento_key <= 46) || (evento_key >= 91 && evento_key <= 93) || (evento_key >= 112 && evento_key <= 145) )		
		return true;
	return false;
} 

function campoNumerico(e, Decimal) { 
	/* -----------------------
		Esta funcion valida un campo para que solo se ingresen Digitos. 
		Para uso con el evento onKeyDown. Se debe llamar la funcion con return (onKeyDown=' return campo...')
	PARAMETROS:
		e (objeto) := 'event' //-- Debe enviarse el Objeto que controla los eventos. (event) 
		Decimal (boolean) //-- si es 'true' se acepta el punto decimal, de lo contrario no.
	----------------------- */
	var evento_key;
	if (window.event)
		evento_key = e.keyCode; 	
	else
		evento_key = e.which;
	// Validamos que sea un numero. Ya sea con una tecla del PAD numerico o con las de encima del Alfabetico
	if ( (evento_key >= 48 && evento_key <= 57) || (evento_key >= 96 && evento_key <= 105) ){
		// Validamos que NO se presionen las teclas SHIFT, ni ALT (Para evitar los caracteres especiales)
		if (e.shiftKey || e.altKey)
			return false; 
		return true;			
	}
	// Validamos las teclas para punto Decimal
	if (Decimal){
		if(evento_key == 110 || evento_key == 109 || evento_key == 190){
			// Validamos que NO se presionen las teclas SHIFT, ni ALT (Para evitar los caracteres especiales)
			if (e.shiftKey || e.altKey)
				return false; 
			return true;	
		}
	}
	// Y otros caracteres validos (Tabulacion, retroceso, suprimir, F5, Fin, Inicio, flechas)
	// -- Antiguo --  if (evento_key == 8 || evento_key == 9 || evento_key == 46 || evento_key == 116 || evento_key == 35 || evento_key == 36 || (evento_key >= 37 && evento_key <= 40) )
	if ( (evento_key >= 8 && evento_key <= 13)  || (evento_key >= 19 && evento_key <= 31) ||  (evento_key >= 33 && evento_key <= 46) || (evento_key >= 91 && evento_key <= 93) || (evento_key >= 112 && evento_key <= 145) )		
		return true; 	
	//window.event.keyCode = 0;  //Lo desactivamos porque puede ocurrir Error de Acceso denegado
	return false;
} 

function campoTexto(e, Numeros, Separacion, Mail){
	/* -----------------------
		Esta funcion valida un campo para que solo se ingresen caracteres validos de Texto
		Para uso con el evento onKeyDown. Se debe llamar la funcion con return (onKeyDown=' return campo...')
	PARAMETROS:
		e (objeto) := 'event' //-- Debe enviarse el Objeto que controla los eventos. (event) 
		Numeros (boolean) //-- si es 'true' se aceptan Digitos Numericos
		Separacion (boolean) //-- si es 'true' se acepta caracteres de separacion como espacios, guiones, puntos y comas
		Mail (boolean) //-- si es 'true' aceptamos los caracteres necesarios para validar un email '_' '@' '.'
	----------------------- */
	var evento_key;
	if (window.event)
		evento_key = e.keyCode;
	else
		evento_key = e.which;	
	// var aceptar = true;
	// Aceptamos las Teclas que representan las Letras (No se aceptan Tildes, ni signos de puntuacion)
	if ( (evento_key >= 65 && evento_key <= 90) || evento_key == 192)
		return true; 
	// Aceptamos Numeros
	if (Numeros){
		if ( (evento_key >= 48 && evento_key <= 57) || (evento_key >= 96 && evento_key <= 105) ){
			// Validamos que NO se presionen las teclas SHIFT, ni ALT (Para evitar los caracteres especiales)
			if (e.shiftKey || e.altKey)
				return false; 
			return true;			
		}
	}
	// Aceptamos Espacio ' ', guiones '-','_' , slash '/', punto '.' y coma ','
	if(Separacion){
		if(evento_key == 32 || evento_key == 109  || evento_key == 110 || evento_key == 111 || evento_key == 188 || evento_key == 189  || evento_key == 190 )
			return true;
	}
	// Aceptamos puntos '.', guion  '_' 
	if (Mail){
		if (evento_key == 109 || evento_key == 110 || evento_key == 189 || evento_key == 190)
			return true;
	}
	// Y otras Teclas validas (Ctrl, Alt, Shift, Tabulacion, retroceso, suprimir, F5, Fin, Inicio, flechas)
	if ( (evento_key >= 8 && evento_key <= 13)  || (evento_key >= 19 && evento_key <= 31) ||  (evento_key >= 33 && evento_key <= 46) || (evento_key >= 91 && evento_key <= 93) || (evento_key >= 112 && evento_key <= 145) )		
		return true; 	
	return false;
}

function mostrarCodigoTecla(e) {
	/* -----------------------
		Muestra el Codigo de una tecla presionada, el Caracter que la respresenta (No siempre funciona bien) y 
		si ademas se mantuvo presionadas las Teclas SHIFT, CTRL, ALT. 
		Para uso con el evento onKeyDown.
	PARAMETROS:
		e (objeto) := 'event' //-- Debe enviarse el Objeto que controla los eventos. (event) 
	----------------------- */
	var evento_key;
	if (window.event)
		evento_key = e.keyCode; 	// Para IExplorer
	else
		evento_key = e.which; 	// Para Mozilla y Netscape
	var msg = "";	
	if (e.shiftKey)
		msg += "SHIFT ";
	if (e.altKey)
		msg += " ALT ";
	if (e.ctrlKey)
		msg += " CTRL ";	
	msg += " Codigo Tecla: " + evento_key + ", Caracter que Representa = " + String.fromCharCode(evento_key);
	alert(msg);
} 

function presionaEnter(e) {
	/* -----------------------
		Detecta cuando en el campo/ventana se presiono la tecla Enter
	PARAMETROS:
		e (objeto) := 'event' //-- Debe enviarse el Objeto que controla los eventos. (event) 
	----------------------- */
	var evento_key;
	if (window.event)
		evento_key = e.keyCode; 	
	else
		evento_key = e.which; 
	if (evento_key == 13)
		return true;
	return false;
}


/********************************************
	VALIDACION DE DATOS (Con Expresiones Regulares)
********************************************/

function comparaFechas(Fecha1, Fecha2){
	/* -----------------------
		Retorna la diferencia entre la fecha2 y la fecha1.
		Si retorna 0, las fechas son iguales, 
		Si retorna 1, entonces fecha1 > fecha2
		Si retorna -1,entonces fecha1 < fecha2
		Recibe Fechas en Formato dd/mm/aaaa tipo Texto
	PARAMETROS:
		Fecha1 (string) //-- Fecha 1 en formato dd/mm/aaaa
		Fecha2 (string) //-- Fecha 2 en formato dd/mm/aaaa
	----------------------- */
	var DatosFecha1 = Fecha1.split('/'); // Separamos la Fecha1
	var DatosFecha2 = Fecha2.split('/'); // Separamos la Fecha2
	var FechaInicial = new Date(DatosFecha1[2], DatosFecha1[1]-1, DatosFecha1[0]);
	var FechaFinal = new Date(DatosFecha2[2], DatosFecha2[1]-1, DatosFecha2[0]);
	if(FechaInicial > FechaFinal){
		//alert("Fecha1 > Fecha2");
		return 1;
	}
	if(FechaInicial < FechaFinal){
		//alert("Fecha1 < Fecha2");
		return -1;
	}
	//alert("Fechas Iguales");
	return 0;
}

function comparaFechaHoy(Fecha1){
	/* -----------------------
		Retorna la diferencia entre la fecha dada y la fecha del dia actual
		Si retorna 0, las fechas son iguales, 
		Si retorna 1, entonces fecha1 > HOY
		Si retorna -1,entonces fecha1 < HOY
		Recibe Fechas en Formato dd/mm/aaaa tipo Texto
	PARAMETROS:
		Fecha1 (string) //-- Fecha 1 en formato dd/mm/aaaa
	----------------------- */
	var DatosFecha1 = Fecha1.split('/'); // Separamos la Fecha1
	var FechaInicial = new Date(DatosFecha1[2], DatosFecha1[1]-1, DatosFecha1[0]);
	var FechaFinal = new Date();
	/*alert("FechaIni--->"+FechaInicial);
	alert("FechaFin--->"+FechaFinal);*/
	if(FechaInicial > FechaFinal){
		//alert("Fecha1 > Fecha2");
		return 1;
	}
	if(FechaInicial < FechaFinal){
		//alert("Fecha1 < Fecha2");
		return -1;
	}
	//alert("Fechas Iguales");
	return 0;
}

function esCodigo(Numero){
	/* -----------------------
	Validamos un Codigo Numerico de dos partes enteras separado por caracter '-' 
	PARAMETROS:
		Numero //-- Representacion del Numero a evaluar.
	----------------------- */
	var expre = /^[0-9]+[-]{1}[0-9]+$/;
	if (!expre.test(Numero))
		return false;
	return true;
}

function esDescripcion(Texto){
	/* -----------------------
	Validamos 	que los caracteres  del Texto pertenezcan a una Descripcion (Texto - Numeros - Separadores)
	PARAMETROS:
		Texto //-- Representacion del Texto a evaluar.
	----------------------- */
	var expre = /^[\sa-zA-Z0-9\/_\.áéíóúÁÉÍÓÚüÜñÑ,:;\-]+$/;
	if (!expre.test(Texto))		
		return false;
	return true;
}

function esDigito(Numero) { 
	/* -----------------------
	Evalua si los caracteres de la cadena de entrada son solo Digitos 0-9, especial para numeros enteros
	PARAMETROS:
		Numero //-- Representacion del Numero a evaluar.
	----------------------- */
	var expre = /^[0-9]+$/;
	if (!expre.test(Numero))		
		return false;
	return true;
}

function esFecha(Fecha) { 
	/* -----------------------
		Evalua si los caracteres de la cadena de entrada pertenecen a una fecha de tipo dd/mm/aaaa,  y
		determina si la fecha es correcta (si existe)
	PARAMETROS:
		Fecha //-- Representacion de la Fecha a evaluar.
	----------------------- */
	var expre = /^([1-9]{1}|0[1-9]{1}|[12]{1}[0-9]{1}|3[01]{1})([\/]{1})(0[1-9]{1}|[1-9]{1}|1[012]{1})([\/]{1})(19[0-9]{2}|20[0-9]{2})$/;
	if (!expre.test(Fecha)){
		//alert("Fecha "+Fecha+" Invalidada por Expresion Regular");		
		return false;
	}
	// Revizamos si es una Fecha Valida	
	var DatosFecha = Fecha.split('/'); // Splits a String object into an array of strings by separating the string into substrings.
	//var miFecha = new Date();
	var mesIgual = false;
	// Colocamos la Fecha al Objeto (Año, Mes, Dia)
	//miFecha.setFullYear(DatosFecha[2],DatosFecha[1]-1,DatosFecha[0]);
	var miFecha = new Date(DatosFecha[2], DatosFecha[1]-1, DatosFecha[0]);
	if (isNaN(miFecha)){
		//alert("Fecha "+Fecha+" Invalidada por objeto Fecha");
		return false;
	}
	// Cuando se coloca una Fecha Fuera de Rango, el Objeto Adecua la Fecha a una Correcta.
	// Por esto para saber si la fecha es correcta simplemente miramos si el mes no cambio
	mesIgual = Boolean(miFecha.getMonth() == DatosFecha[1]-1);
	/*if(!mesIgual){
		alert("Fecha "+Fecha+" Invalidada por comprobacion de mes");
	}*/
	return mesIgual;
}

function esMail(eMail) { 
	/* -----------------------
		Evalua si los caracteres de la cadena de entrada pertenecen a una direccion de Email Valida
	PARAMETROS:
		eMail //-- Representacion del eMail a evaluar.
	----------------------- */
	var expre = /^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/; // Evaluacion Normal NO ACEPTA DIRECCIONES IP
	if (!expre.test(eMail))		
		return false;
	return true;
}

function esTexto(Texto) { 
	/* -----------------------
		Evalua si los caracteres de la cadena de entrada son Texto (acepta espacio y punto)
	PARAMETROS:
		Texto  //-- Representacion del Texto a evaluar.
	----------------------- */
	var expre = /^\sa-zA-Z\/_\.áéíóúÁÉÍÓÚüÜñÑ+$/;
	if (!expre.test(Texto))		
		return false;
	return true;
}

function esVacio(cadena){
	/* -----------------------
		Evalua si la cadena es Vacia o Nula
	PARAMETROS:
		cadena  //-- cadena a comprobar
	----------------------- */
	if(cadena === null || cadena === "" || cadena === undefined || cadena === false)
		return true;
	return false;
}

function esValor(Numero) { 
	/* -----------------------
		Evalua si los caracteres de la cadena de entrada	son de un valor decimal,
		especial para numeros de coma flotante.
	PARAMETROS:
		Numero //-- Representacion del Numero a evaluar.
	----------------------- */
	var expre = /^[0-9]+[\.]{0,1}[0-9]*$/;
	if (!expre.test(Numero))		
		return false;
	return true;
}

function fechasDiferencia(Fecha1, Fecha2, Dif){
	/* -----------------------
		Determina si la Diferencia entre dos Fechas es inferior a la Diferencia Permitida (Dif)
		Recibe Fechas en Formato dd/mm/aaaa tipo Texto
	PARAMETROS:
		Fecha1 (string) //-- Fecha 1 en formato dd/mm/aaaa
		Fecha2 (string) //-- Fecha 2 en formato dd/mm/aaaa
		Dif (entero) //-- Numero de Dias de diferencia permitido
	----------------------- */
	var DatosFecha1 = Fecha1.split('/'); // Separamos la Fecha1
	var DatosFecha2 = Fecha2.split('/'); // Separamos la Fecha2
	var FechaInicial = new Date();
	var FechaFinal = new Date();

	FechaInicial.setFullYear(DatosFecha1[2],DatosFecha1[1]-1,DatosFecha1[0]);
	FechaFinal.setFullYear(DatosFecha2[2],DatosFecha2[1]-1,DatosFecha2[0]);
	var diferencia = FechaFinal.getTime() - FechaInicial.getTime();
	var diasDiferencia = Math.abs(Math.floor(diferencia / (1000 * 60 * 60 * 24)));
	// Verificamos la Diferencia en Dias
	//alert(diasDiferencia + "-" + Dif);
	if ( diasDiferencia > Dif )
		return false;
	return true;
}


/************************************************
		VALIDACION DE DATOS (por Comparacion de Caracteres)
************************************************/

function validarNum(Numero) { 
	/* -----------------------
		Evalua si los caracteres de la cadena de entrada	son solo Numeros. 
	PARAMETROS:
		Numero (string) //-- Representacion del Numero a evaluar.
	----------------------- */
	var i;
	for(i=0;i<Numero.length;i++){        
		if ( Numero.charAt(i) < '0' || Numero.charAt(i) > '9')
			return false;
	}
	return true;
} 	

function validarTxt(Texto) { 
	/* -----------------------
		Evalua si los caracteres de la cadena de entrada son solo Letras y Espacios. 
	PARAMETROS:
		Texto (string) //-- Representacion del Texto a evaluar.
	----------------------- */
	var i;
	for(i=0;i<Texto.length;i++){        
		if ( (Texto.charAt(i) < 'A' || Texto.charAt(i) > 'Z') && (Texto.charAt(i) < 'a' || Texto.charAt(i) > 'z') && Texto.charAt(i) != ' ' )
			return false;
	}
	return true;
}

function validarMail(Email) { 
	/* -----------------------
		Evalua si los caracteres de la cadena de entrada pertenecen a una direccion de Email. 
	PARAMETROS:
		Email (string) //-- Representacion del Email a evaluar.
	----------------------- */
	var i;
	for(i=0;i<Email.length;i++){        
		if (  (Email.charAt(i) < 'A' || Email.charAt(i) > 'Z') && (Email.charAt(i) < 'a' || Email.charAt(i) > 'z') && (Email.charAt(i) < '0' || Email.charAt(i) > '9') && Email.charAt(i) != '@' && Email.charAt(i) != '.' && Email.charAt(i) != '_')
			return false;
	}
	return true;
}

function validarFecha(CFecha) { 
	/* -----------------------
		Evalua si los caracteres de la cadena de entrada son solo numeros y /. 
	PARAMETROS:
		CFecha (string) //-- Representacion de la Fecha a evaluar.
	----------------------- */
	var i;
	for(i=0;i<CFecha.length;i++){        
		if (  (CFecha.charAt(i) < '0' || CFecha.charAt(i) > '9') &&  CFecha.charAt(i) != '/' )
			return false;
	}
	return true;
}

function validarHora_12(Hora) {
	/* -----------------------
		Evalua si los caracteres de la cadena de entrada son son numeros, :, AM, PM, ' '.  para una Hora
		en formato de 12 Horas.
	PARAMETROS:
		Hora (string) //-- Representacion de la Hora a evaluar.
	----------------------- */
	var i;
	for(i=0;i<Hora.length;i++){
		if (  (Hora.charAt(i) < '0' || Hora.charAt(i) > '9') &&  Hora.charAt(i) != ' ' && Hora.charAt(i) != ':' && Hora.charAt(i) != 'A' && Hora.charAt(i) != 'P' && Hora.charAt(i) != 'M' && Hora.charAt(i) != 'a' && Hora.charAt(i) != 'p' && Hora.charAt(i) != 'm')
			return false;
	}
	return true;
} 


/*************************************************
		VALIDACION DE OBJETOS DE FORMULARIO, CON  ALERTAS
*************************************************/

function maximaLongitud(texto,maxlong){ 
	/* -----------------------
		Evalua la longitud maxima de una cadena
	PARAMETROS:
		texto (objeto) := 'this.form.NombreCampo' //-- Objeto, Campo del Form Actual que se va a evaluar.
		maxlong (Integer) //-- longitud maxima de caracteres
	----------------------- */
	var in_value, out_value; 
	if (texto.value.length > maxlong){ 
		in_value = texto.value; 
		out_value = in_value.substring(0,maxlong); 
		texto.value = out_value; 
		alert("Excede la cantidad maxima de caracteres.");
		return false; 
	}
	return true; 
}

function objEsDigito(obj) { 
	/* -----------------------
		Evalua si el objeto que se pasa tiene un valor apropiado para un numero entero y en caso contrario 
		muestra una mensaje de error y coloca el campo en Foco.
	PARAMETROS:
		object (objeto) := 'this.form.NombreCampo'			//Objeto, Campo del Form Actual.
	----------------------- */
	if (!esDigito(obj.value, false)){
		alert("Debe introducir un Numero Entero");
		obj.focus();
		return false;
	}
	return true;
}

function objEsFecha(obj) { 
	/* -----------------------
		Evalua si el objeto que se pasa tiene un valor apropiado para una Fecha dd/mm/aaaa y en caso contrario 
		muestra una mensaje de error y coloca el campo en Foco.
	PARAMETROS:
		object (objeto) := 'this.form.NombreCampo'			//Objeto, Campo del Form Actual.
	----------------------- */
	if (!esFecha(obj.value)){
		alert("Debe escribir una Fecha en el Formato DD/MM/AAAA");
		obj.focus();
		return false;
	}
	return true;
}