/************************************************************************************************
		FUN??ES DEFINIDAS PELO SCRIPT

		1. LTrim( aValue )
			Param:
				aValue - Valor String.

			Fun??o que recebe um valor String e retira os espa?os do lado esquerdo da String.

		2. RTrim( aValue )
			Param:
				aValue - Valor String.

			Fun??o que recebe um valor String e retira os espa?os do lado direito da String.

		3. trim( aValue )
			Param:
				aValue - Valor String.

			Fun??o que recebe um valor String e retira os espa?os do lado direito e esquerdo da String.

		4. setComponentClassErro( aComponent )
			Param:
				aComponent - Referencia para o componente
			
			Fun??o que altera o class do componente para exibir o class definido para componentes que
			apresentam erro.

		5. resetComponetClassErro( aComponent )
			Param:
				aComponent - Referencia para o componente

			Fun??o que retira o class de erro definido para o componente retornando para o classe padr?o
			definido para o componente

		
		6. setComponentClass( aComponent, aClassName )
			Param:
				aComponent - Referencia para o componente
				aClassName - String contendo o class a ser configurado
			
			Fun??o respons?vel por alterar o class do componente determinado para o class informado.


		7. getComponentClass( aComponent )
			Param:
				aComponent - Referencia para o componente
			
			Return:
				String contendo a class do componente referenciado


		8. onlyNumber( aComponent )
			Param:
				aComponent - Referencia para o componente
			
			Fun??o respons?vel por limpara todos os elementos que n?o ser?o n?mero 0123456789 no valor do
			componente

		9. setFocusOnElement( aComponent )
			Param:
				aComponent - Referencia para o componente
	
			Fun??o atrav?s da qual se configura o foco para um determinado componente


		10. canReceiveFocus(  aComponent  )
			Param:
				aComponent - Referencia para o componente
			
			Return:
				Valor boolean indicando se o componente pode ou n?o receber o foco

		11. getComponentLabel( aComponent )
			Param:
				aComponent - Referencia para o componente
			
			Return:
				String contendo o label a ser utilizado para o componente

		12. getFormByName( aFormName )
			Param:
				aFormName - String que contem o nome do formul?rio que ser deseja obter

			Return:
				Referencia para o formul?rio em quest?o

			Fun??o que retorna uma referencia para o formul?rio especificado por nome.


		13. getComponentValue( aComponent )
			Param:
				aComponent - Referencia para o componente
			
			Return:
				Retorna o valor de um determinado componente, podendo ser um valor String ou array, a depender do 
				componente. (Checkbox, select-multiple: array)

			Fun??o que retorna o valor de um determinado componente


		14. disabledComponent( aComponent, aValue )
			Param:
				aComponent - Referencia para o componente
				aValue - Valor boolean que informa se deve se habilitado ou desabilitado o componente

			Fun??o respons?vel por desabilitar um determinado componente
		

		15. disabledForm( aFormName , aValue )
			Param:
				aFormName - Nome do formul?rio que deseja se desabilitar
				aValue - Valor boolean que informa se deve se habilitado ou desabilitado os componentes do formul?rio
			
			Fun??o respons?vel por desabilitar todos os componentes do formul?rio
			

		16. disabledFormExcept( aFormName , aArrayExcept,  aValue )
			Param:
				aFormName - Nome do formul?rio
				aArrayExcept - Array com o nome dos componentes que n?o devem ser especificados
				aValue - Campo que contem um valor boolean que indica se deve ser desabilitado ou n?o

			Fun??o respons?vel por desabilitar todos os elementos de um determinado formul?rio, 
			a menos os componentes cujos nomes se encontram no array tamb?m passado como par?metro


		17. setComponentRequired( aComponent, aValue )
			Param:
				aComponent - Componente que ter? a sua obrigatoriedade alterada
				aValue - Propriedade que contem um valor boolean que indica se o componente ser? posto 
	 					como obrigat?rio ou n?o
				
			Fun??o que configura um determinado componente como obrigat?rio


		18. sendForm( aFormName, aArrayProperty )
			Param:
				aFormName - Nome do formul?rio que ter? os seus input enviados
				aArrayProperty - Array contendo o nome das propriedades a serem obtidas caso um objeto 
									seja colocado no requiest

			Fun??o respons?vel por enviar todos os valores dos input existentes no formul?rio em quest?o 
			para a URL especificada no atributo action do formul?rio 


		19. sendAndValidateForm( aFormName, aArrayProperty )
			Param:
				aFormName - Nome do formul?rio que ter? os seus input enviados			
				aArrayProperty - Array contendo o nome das propriedades a serem obtidas caso um objeto 
									seja colocado no requiest

			Fun??o respons?vel por validar os valores existentes nos componentes de acordo com os 
			atributos nos respectivos componentes e enviar as informa??es para a URL existente na action
			no formul?rio.


		20. sendAndValidateToAction( aFormName, aAction, aArrayProperty )
			Param:
				aFormName - Nome do formul?rio que ter? os seus input enviados			
				aAction - URL para a qual ser? enviado os dados do formul?rio
				aArrayProperty - Array contendo o nome das propriedades a serem obtidas caso um objeto 
									seja colocado no requiest

			Fun??o respons?vel por validar os valores existentes nos componentes de acordo com os 
			atributos nos respectivos componentes e enviar as informa??es para a URL especificada.


		21. sendFormToAction( aFormName, aAction, aArrayProperty )
			Param:
				aFormName - Nome do formul?rio que ter? os seus input enviados			
				aAction - URL para a qual ser? enviado os dados do formul?rio
				aArrayProperty - Array com o nome das propriedade a serem obtidas quando o elemento ? colocado no request

			Fun??o respons?vel por enviar todos os valores dos input existentes no formul?rio em quest?o 
			para a URL especificada no par?metro.


		22. getDateFormat( aComponent )
			Param:
				aComponent - Componente que ter? a sua obrigatoriedade alterada
			
			Fun??o que retorna o formato especificado para um determinado componente HTML atrav?s do atributo date


		23. getDate( aComponent, aValidate )
			Param:
				aComponent - Componente que ter? a sua obrigatoriedade alterada
				aValidate - Valor boolean que indica se deve ser feita cr?tica quando ocorrer erros na transferencia
							do valor obtido no componente para o componente date
			
			Fun??o que retorna um objeto do tipo Date que representa a hora armazenada em um determinado componente


		24. setDateToComponent( aComponent, aDate )
			Param:
				aComponent - Componente que ter? a sua obrigatoriedade alterada
				aDate - Data a ser configurada no componente

			Fun??o que configura o valor contido em uma determinada data para um determinado componente de acordo com 
			o atributo date existente no componente


		25. addYear( aComponent, aDate )
			Param:
				aDate - Objeto que representa um objeto da classe Date 
				aYear - N?mero que representa a quantidade de anos a serem inseridos

			Fun??o que ir? inserir adiciona ao valor(positivo ou negativo) obtido do componente, 
			o qual cont?m uma data a quantidade de anos especificada


		26. addMonth( aDate, aMonth  )
			Param:
				aDate - Objeto que representa um objeto da classe Date 
				aMonth - N?mero que representa a quantidade de meses a serem inseridos

			Fun??o que ir? inserir adiciona ao valor(positivo ou negativo) obtido do componente, 
			o qual cont?m uma data a quantidade de meses especificada


		27. getFormElement( aFormName, aElementName )
			 Param:
	 			aFormName - Nome do formul?rio do qual se deseja obter o elemento
			 	aElementName - Nome do elemento do qual se deseja a referencia

			Fun??o que retorna uma referencia para o elemento de um determinado formul?rio

		28. setComponentValue( aComponent, aValue )
			 Param:
				aComponent - Referencia para o componente que ser deseja configurar o valor
				aValue - Valor a ser configurado para o componente

			Fun??o respons?vel por configurar o valor de um determinado componente


		29. addDate( aDate, aDay  )
			Param:
				aDate - Objeto que representa um objeto da classe Date 
				aMonth - N?mero que representa a quantidade de meses a serem inseridos

			Fun??o que ir? inserir adiciona ao valor(positivo ou negativo) obtido do componente, 
			o qual cont?m uma data a quantidade de meses especificada


		30. validateForm( aFormName )
			Param:
				aFormaName - Nome do formul?rio para o qual ser? feita a valida??o
			
			Return:
				Retorna um valor boolean informando se foi validado com sucesso ou n?o
			
			Fun??o respons?vel por validar os elementos do formul?rio de acordo com a defini??o dos atributos
			no formul?rio

		31. clearForm( aFormName )
			Param:
				aFormName - Nome do m?todo respons?vel por limprar todos os componentes do formul?rio
			


		32. getParamConfiguration( aRef )
			Fun??o respons?vel por obter um array com os par?metros de configura??o a ser utilizada por um 
			determinado elemento atrav?s da indica??o do ref dos par?metros, normalmente para uso interno.
			Param:
				aRef - Nome da referencia dos elementos
			
			Return:
				Array com todos os elementos de par?metros existentes

		33. getRefParameterToPost( aRef )
			Fun??o que retorna uma string com os valores configurados atrav?s das tags param no formato a ser
			submetido para o servidor, normalmente para uso interno
			Param:
				aRef - Nome da referencia dos elementos
			
			Return:
				String com os valores dos par?metros


		34. loadProperties( aDatasource, aArrayProperty , aFormName )
			Fun??o que carrega do servidor parametros informados de um datasource especificado.
			interno

			Return:
				Array com todos os valores para as propriedades



		35. loadPropertiesWithParam( aDatasource, aArrayProperty , aFormName , aRef )

			M?todo respons?vel por carrega apartir de um determinada datasource no servidor um array com os valores
			das propriedades desejadas
			
			Param:
				aDatasource - DataSource a ser utilizado para se carregar os valores das propriedades
				aArrayProperty - Array contendo o nome das proriedades desejadas
				aFormName - Nome do formul?rio desejado
				aRef - Id da referencia das configura??es a serem utilizadas



		35. getParameterToPost( aFormName )
			Fun??o que retorna uma string com a lista formatada de todos os par?metros do formul?rio
			cujo nome ? passado como par?metro
			Param:
	 			aFormName - Nome do formul?rio


		
		36. clearFormExcept( aFormName, aArrayExcept)
			Fun??o que limpa todos os elementos do formul?rio, a menos os passados atrav?s do array contendo 
			os elementos q n?o devem ser limpos.
			Param:
				aFormName - Nome do formul?rio q deve ser limpo
				aArrayExcept - Array contendo o nome dos elementos q n?o devem ser limpos


		37. loadObjectFromServer( aParameter, aArrayProperty )
			Fun??o de uso interno do Script respons?vel por carregar um array cujos indices s?o 
			os nomes das propriedades desejadas e o valor, o valor das propriedades
			
			Param:
				aParameter - String no formato para os par?metros desejados
				aArrayProperty - Array contendo o nome das propriedades desejadas
				
				
		38. getComponent( aFormName, aComponentName )
			Fun??o que retorna uma referencia para o componente desejado
			
			Param:
				aFormName - Nome do formul?rio que deseja se obter o componente
				aComponentName - Nome do componente que deseja se obter a referencia
	

		39. innerTrim ( aValue )
	 		Funcao responsAvel por retirar os espacos internos da String passada como parametro
	 		
	 		Param:
				aValue - Valor String.
				
		40. validateYear ( aValue, aKeyPress )
			Funcao responsavel por validar se o ano passado como parametro tem um formato valido.
			
			Param:
				aValue - Valor do ano
				aKeyPress - Tecla pressionada
				
		41. lpad(valor, tamanho, caracter)
			Preenche a String ? esquerda com o caractere fornecido, at? que ela atinja o tamanho especificado.
			
			Param:
				valor - String do valor a ser alterado
	 			tamanho - Tamanho maximo que deve possuir o valor mais os caracteres adicionados
	 			caracter - Caracter utilizado para preenher o valor
		
		42. dvCpfCnpj(pEfetivo, isCnpj)
			Calcula os 2 d?gitos verificadores para o n?mero-efetivo pEfetivo de CNPJ (12 d?gitos) 
			ou CPF (9 d?gitos) fornecido. isCnpj ? booleano e informa se o n?mero-efetivo fornecido 
			? CNPJ (default = false).
			
			Param:
				pEfetivo - String do n?mero-efetivo (SEM d?gitos verificadores) de CNPJ ou CPF.
	 			isCnpj - Indica se a string fornecida ? de um CNPJ. Caso contr?rio, ? CPF. Default = false (CPF).
		
		43. isCpf(aCpf)
			Testa se a String aCpf fornecida ? um CPF v?lido. Qualquer formata??o que n?o seja algarismos ? desconsiderada.
			 
			Param:
				aCpf - String fornecida para ser testada.
		
		44. isCnpj(aCnpj)
			Testa se a String aCnpj fornecida ? um CNPJ v?lido. Qualquer formata??o que n?o seja algarismos ? desconsiderada.
			
			Param:
				aCnpj - String fornecida para ser testada.
		
		45. formatCpfCnpj(form, event, compName, isCnpj)
			Formata a string fornecida como CNPJ ou CPF.
			
			Param:
				form - Nome do formulario
				event - Evento onKeyPress
				compName - Nome do componente
				isCnpj - Indica se a string fornecida ? um CNPJ. Caso contr?rio, ? CPF. Default = false (CPF).
				
		46. formatCep(form, event, compName)
			Formata a string fornecida como Cep.
			
			Param:
				form - Nome do formulario
				event - Evento onKeyPress
				compName - Nome do componente


	************************************************************************************************/

	///////////////////////////////////////////////////////////////////////////////////////////////////
	//  VARI?VEIS A SEREM CONFIGURADAS COM O INTEUITO DE EFETIVAR ALGUMAS CUSTOMIZA??ES
	///////////////////////////////////////////////////////////////////////////////////////////////////
	
	/**
	 * Array que contem os poss?veis style a serem configurados nos input
	 * quando da existencia de algum erro na valida??o, o padr?o a ser seguido 
	 * nos nomes deve ser "validate_erro", para a configura??o padr?o ou "validate_erro_<component.type>"
	 * para as configura??es especificas para cada tipo de componente
	 */
	var CLASS_ERRO = new Array();
	CLASS_ERRO["validate_erro"] = "input_required";
	
	
	/**
     * Indica o label a ser apresentado como valor para os campos data quando o mesmo n?o contiver nenhum
	 * valor com o objetivo de apresentar o padr?o para a data
	 */
	var VALUE_LABEL_DATE = 'DD/MM/AAAA';
	var VALUE_LABEL_MES_ANO = 'MM/AAAA';
		
	///////////////////////////////////////////////////////////////////////////////////////////////////
	//  VARI?VEIS DE USO INTERNO N?O SENDO SUGEITO A ALTERA??O
	///////////////////////////////////////////////////////////////////////////////////////////////////
	
	var HIST_CLASS_ORIG		= new Array(); // contem a hist?rico do atributo class dos componentes
	var TAG_MESSAGE_ERRO    = 'message-erro';
	var TAG_MESSAGE_CONFIRM = 'message-confirm';
	var TAG_WINDOW_ERRO		= 'window-erro';
	var TAG_COLLECTION		= 'collection';
	var TAG_OBJECT			= 'object';
	var TAG_PROPERTY		= 'property';
	var TAG_NAME			= 'name';
	var TAG_VALUE			= 'value';
	var TAG_ITEM			= 'item';
	var TAG_ITEMS			= 'items';	

	/**
	 * Fun??o respons?vel por retirar os espa?os ? esquerda
	 * da String passada como par?metro
	 *
	 * Return - String sem os espa?os ? direita nem ? esquerda
	 */
	function LTrim( aValue ){
	   var whitespace = new String(" \t\n\r");
	   var s = new String( aValue );
	   if (whitespace.indexOf(s.charAt(0)) != -1) {
		  var j=0, i = s.length;
		  while (j < i && whitespace.indexOf(s.charAt(j)) != -1)
			 j++;
		  s = s.substring(j, i);
	   }
	   return s;
	}

	/**
	 *	Fun??o que retorna uma referencia para o componente desejado
	 *	Param:
	 *		aFormName - Nome do formul?rio que deseja se obter o componente
	 *		aComponentName - Nome do componente que deseja se obter a referencia
	 *	
	 *	Return:
	 *		Referencia para o componente
	 *
	 */
	function getComponent( aFormName, aComponentName ){
		var form = getFormByName( aFormName );
		if( form ){
			return form.elements[ aComponentName ];
		}else{
			return null;
		}
	}

	/**
	 * Fun??o respons?vel por retirar os espa?os ? direita
	 * da String passada como par?metro
	 *
	 * Return - String sem os espa?os ? direita nem ? esquerda
	 */
	function RTrim( aValue ){
	   var whitespace = new String(" \t\n\r");
	   var s = new String( aValue );
	   if (whitespace.indexOf(s.charAt(s.length-1)) != -1) {
		  var i = s.length - 1;      
		  while (i >= 0 && whitespace.indexOf(s.charAt(i)) != -1)
			 i--;
		  s = s.substring(0, i+1);
	   }
	   return s;
	}	

	
	/**
	 * Fun??o respons?vel por retirar os espa?os ? direita e ? esquerda
	 * da String passada como par?metro
	 *
	 * Return - String sem os espa?os ? direita nem ? esquerda
	 */
	function trim( aValue ){
		return RTrim(LTrim( aValue ));
	}
	

	/**
	 * Funcao responsAvel por retirar os espacos internos
	 * da String passada como parametro
	 *
	 * Return - String sem os espacos internos
	 */
	function innerTrim( aValue ){
		var whitespace = new String(" \t\n\r");
	   	var s = new String( aValue );
	   	var retorno = "";
	   	for ( i = 0; i < s.length; i++) {
	   		if (whitespace.indexOf(s.charAt(i))) {
	   			retorno = retorno + s.charAt(i);
	   		}
	   	}
		return retorno;
	}
	
	/**
	 * Fun??o respons?vel por configurar o style adequado para o componente no intuito de
	 * resaltar o componente que apresenta o erro
	 */
	function setComponentClassErro( aComponent ){
		if( validateRefComponent( aComponent ) ){	
			if( CLASS_ERRO ){
				var type  = aComponent.type;
				var className = CLASS_ERRO[ "validate_erro_" + type ];
	
				if( !className ){
					className = CLASS_ERRO[ "validate_erro" ];
				}
					
				if( className ){
					var histClassName = getComponentClass( aComponent );
					if( histClassName != className ){
						HIST_CLASS_ORIG[ aComponent.name ] = ( histClassName ? histClassName : '' );
					}
					setComponentClass( aComponent, className );
				}
			}
		}
		return;
	}
	
	/**
	 * Fun??o respons?vel por reestabelecer a apresenta??o original do componente
	 * possivelmente alterada mediante a altera??o para o className de erro
	 * 
	 * aComponent - Componente que ter? a sua apresenta??o restaurada, tendo o class alterado
	 *				para o class original do componente
	 */
	function resetComponetClassErro( aComponent ){
		if( validateRefComponent( aComponent ) ){
			var className = HIST_CLASS_ORIG[ aComponent.name ];
			if( className != undefined && className != null){
				setComponentClass( aComponent, className );
			}
		}
		return;
	}
	
	/**
	 * Fun??o respons?vel por configurar o style de um determinado componente
	 *
	 * aComponent - Componente para o qual o style ser? configurado
	 * aStyle - Style para o qual ser? configurado
	 */	
	function setComponentClass( aComponent, aClassName ){
		if( validateRefComponent( aComponent ) ){
			if( aComponent.type == 'radio' 
						|| aComponent.type == 'checkbox' ) {
				
				var itens = aComponent.form.elements[ aComponent.name ];
				for( var i = 0 ; i < itens.length ; i++ ){
					itens[i].className = aClassName;
				}
				
			}else{
				aComponent.className = aClassName;
				
			}		
			
		}
		return;
	}
	
	
	/**
	 * Fun??o respons?vel por retornar o className para o componente indicado
	 */	
	function getComponentClass( aComponent ){
		var className = null;
		if( validateRefComponent( aComponent ) ){
			className = aComponent.className;
		}		
		return className;
	}
	
	/**
	 * Objeto a ser utilizada para o retorno dos metodos de valida??o para os campos
	 * do formul?rio
	 */	
	function ValidationResult( aValid, aMessage ){
		this.valid 	 = aValid;
		this.message = aMessage;
		return this;
	}


	/**
	 * Fun??o respons?vel por verificar se o valor de um determinado componente ? um valor
	 * de data v?lido, esse valida??o pode ser indicada no pr?prio input atrav?s do 
	 * atributo date="<formato>", o qual recebe como valor o formato da data em quest?o
	 *
	 * Return - Objeto ValidationResult que contem o resultado da avalia??o juntamente 
	 *			com a mensagem a ser exebida caso a valida??o tenha encontrado erros
	 */	
	function validateDate( aComponent, aLabel, aDateFormat ){

		var valid	= true;
		var date	= trim(aComponent.value);
		var pattern = aComponent.getAttribute('date');
		
		if( date == VALUE_LABEL_DATE || date == VALUE_LABEL_MES_ANO  ){
			return new ValidationResult( true, null );
		}

		if( date && pattern == 'dd/MM/yyyy' ){
		
			var split = "/";
			var splitDate = new RegExp(split);
			itens = date.split(splitDate);
	
			if( itens.length == 3 ){
				var ano = itens[2];
				var expDate30 = "^((0[1-9])|((1|2)\\d)|(30))/(0?4|0?6|0?9|11)/(\\d{4})";
				var expDate31 = "^((0[1-9])|((1|2)\\d)|(3(0|1)))/(0?1|0?3|0?5|0?7|0?8|10|12)/(\\d{4})";
				var expDate28 = "^((0[1-9])|(1\\d)|(2[0-8]))/(0?2)/(\\d{4})";
				var expDate29 = "^((0[1-9])|(1\\d)|(2[0-9]))/(0?2)/(\\d{4})";
				
				expDate = "(" + expDate30 + ")|(" + expDate31 + ")|(";
				
				if( ano % 4 == 0 ) {
					expDate += expDate29;
				} else {
					expDate += expDate28;
				}
	
				expDate += ")"; 
		
				var reDate = new RegExp(expDate);
				valid = reDate.test(date);
	
			}else{
				valid = false;
				
			}	
		
		}else if( date && pattern == 'MM/yyyy' ){

			var split = "/";
			var splitDate = new RegExp(split);
			itens = date.split(splitDate);
	
			if( itens.length == 2 ){
				var ano = itens[2];
				var exp = "(^(0?1|0?2|0?3|0?4|0?5|0?6|0?7|0?8|0?9|10|11|12)/(\\d{4}))";
				var reDate = new RegExp(exp);
				valid = reDate.test(date);
	
			}else{
				valid = false;
				
			}
		}
		return new ValidationResult( valid, ( valid ? null : aLabel + ': Campo precisa conter uma data v\u00e1lida e no formato apropriado.' ) );		
	}
	
	
	/**
	 * Metodo respons?vel por formatar a data criando uma marcara para a mesma no formato dd/MM/yyyy,
	 * a priore somente essa mascara ? aceita, podendo futuramente ser extendida para aceitas todas as mascaras
	 * mediante a indica??o de uma express?o
	 */
	function formatDate(){
	  
	  var aComponent = this;
	  var validos = "1234567890/";

	  var datePattern = this.getAttribute('date');
	  var valueLabel  = '';
	  
	  for (i = 0; i < aComponent.value.length; i++) {
		if (validos.indexOf( aComponent.value.charAt(i) ) == -1) {
		  temp1 = aComponent.value.substr(0, i);
		  temp2 = aComponent.value.substr(i + 1, aComponent.value.length);
		  aComponent.value = temp1 + temp2;
		  i = 0;
		}
	  }
	  if ((aComponent.value.length > 2) && (aComponent.value.charAt(2) != '/')) {
		temp = aComponent.value;
		aComponent.value = temp.substr(0, 2) + '/' + temp.substr(2, temp.length);
	  }

	  // CODIGO RESPONSAVEL POR TRATAR A FORMATACAO PARA O ANO
	  if( datePattern == 'dd/MM/yyyy' ){
		  if ((aComponent.value.length > 5) && (aComponent.value.charAt(5) != '/')) {
			temp = aComponent.value;
			aComponent.value = temp.substr(0, 5) + '/' + temp.substr(5, temp.length);
		  }		
	  }

	  return true;
	}
	
	
	/**
	 * M?todo respons?vel por exibir o label padr?o para os componentes que 
	 * recebem uma data, no qual ? apresentado o label indicado na vari?vel VALUE_LABEL_DATE
	 */
	function configLabelValueDate(){
		var datePattern = this.getAttribute('date');
		var valueLabel  = '';
		if( datePattern == 'dd/MM/yyyy' ){
			valueLabel = VALUE_LABEL_DATE;
		}else{
			valueLabel = VALUE_LABEL_MES_ANO;
		}
		
		if( trim( this.value ) == '' ){
			this.value = valueLabel;
		}		
		return true;
	}


	/**
	 * M?todo respons?vel por limpar o label padr?o para os componentes que 
	 * recebem uma data, no qual ? apresentado o label indicado na vari?vel VALUE_LABEL_DATE
	 */
	function clearLabelValueDate(){
		var datePattern = this.getAttribute('date');
		var valueLabel  = '';
		if( datePattern == 'dd/MM/yyyy' ){
			valueLabel = VALUE_LABEL_DATE;
		}else{
			valueLabel = VALUE_LABEL_MES_ANO;
		}

		if( trim( this.value ) == valueLabel ){
			this.value = '';
		}
	}


	/**
	 * Fun??o respons?vel por verificar se o valor de um determinado componente ? um valor
	 * de n?mero v?lido, esse valida??o pode ser indicada no pr?prio input atrav?s do 
	 * atributo number="<integer|real>", o qual pode receber uma valida??o dizendo se o n?mero 
	 * ? um n?mero inteiro ou real
	 *
	 * Return - Objeto ValidationResult que contem o resultado da avalia??o juntamente 
	 *			com a mensagem a ser exebida caso a valida??o tenha encontrado erros
	 */	
	function validateNumber( aComponent, aLabel, aNumberFormat ){
		var valid = true;

		var value	= aComponent.value;
		var number	= aComponent.getAttribute("number");

		if( number == 'real' ){
		  while(value.indexOf(" ") >= 0) value = value.replace(" ", "");
		  while(value.indexOf(".") >= 0) value = value.replace(".", "");
		  while(value.indexOf(",") >= 0) value = value.replace(",", ".");


		}else if( number == 'integer' ){
		  while(value.indexOf(" ") >= 0) value = value.replace(" ", "");
		  while(value.indexOf(".") >= 0) value = value.replace(".", "");
			
		}

		valid = !isNaN( value );

		return new ValidationResult( valid, ( valid ? null : aLabel + ': Campo precisa conter um n\u00famero v\u00e1lido.' ) );		
	}	
	
	/**
	 * Fun??o que retirar todas as marca??es de um determinado componente
	 * deixando somente os valores num?ricos
	 */
	function onlyNumber( aComponent ) {
	  var caracteresIvalidos = "1234567890";
	  for (i = 0; i < aComponent.value.length; i++) {
		if (caracteresIvalidos.indexOf(aComponent.value.charAt(i)) == -1) {
	      temp1 = aComponent.value.substr(0, i);
		  temp2 = aComponent.value.substr(i + 1, aComponent.value.length);
	      aComponent.value = temp1 + temp2;
		  i = 0;
	    }
	  }
	  return;
	}
	
	/**
	 * Fun??o destinada a coloca??o de uma marcara para os n?meros reais que 
	 * est?o sendo colocados
	 */
	function formatRealNumber(aNumDecimal) {
	  
	  var negative = false;

	  if( this.value.length > 0 
			&& this.value.substring(0,1) == '-' ){
		 negative = true;
	  }

	  onlyNumber( this );

	  var qtdDecimal = this.getAttribute("fractionDigits");
	  if( !qtdDecimal ){
		qtdDecimal = 2;
	  }

	  valor = this.value;
	  while(valor.indexOf(" ") >= 0) valor = valor.replace(" ", "");
	  while(valor.indexOf(".") >= 0) valor = valor.replace(".", "");
	  while(valor.indexOf(",") >= 0) valor = valor.replace(",", "");

	  if (valor.length < 2) {
		this.value = negative ? '-' + valor : valor;
	    return;
	  }

	  saida = valor.substring(0,1);
	  valor = valor.substring(1, valor.length);
	  
	  while (valor.length - qtdDecimal > 0) {
		if ((valor.length - qtdDecimal) % 3 == 0) {
	      saida += ".";
		}
	    saida += valor.substring(0,1);
		valor = valor.substring(1, valor.length);
	  }

	  saida += "," + valor;
	  this.value = negative ? '-' + saida : saida;

	  return true;
	}


	/**
	 * Fun??o destinada a coloca??o de uma marcara para os n?meros reais que 
	 * est?o sendo colocados
	 */
	function formatIntegerNumber() {
	  
	  onlyNumber( this );

	  valor = this.value;
	  while(valor.indexOf(" ") >= 0) valor = valor.replace(" ", "");
	  while(valor.indexOf(".") >= 0) valor = valor.replace(".", "");

	  if (valor.length < 2) {
		this.value = valor;
	    return;
	  }

	  saida = valor.substring(0,1);
	  valor = valor.substring(1, valor.length);
	  
	  while (valor.length > 0) {
		if ((valor.length ) % 3 == 0) {
	      saida += ".";
		}
	    saida += valor.substring(0,1);
		valor = valor.substring(1, valor.length);
	  }

	  this.value = saida;

	  return true;
	}
	

	/**
	 * Fun??o que controla o tamanho m?ximo dos componentes
	 */
	function controlMaxLength(){
		var max = parseInt( this.getAttribute("maxLength") );
		if( this.value && this.value.length > max ){
			this.value = this.value.substring( 0, max );
		}
		return true;
	}

	/**
	 * M?todo que deve ser chamado ap?s a contru??o do formul?rio para a configura??o de eventos 
	 * de marcara e valida??es para os input dos formul?rios
	 */
	function configInputForm(){
		// Vari?vel que ir? armazenar uma referencia para o primeiro elemento 
		// que possa receber o foco
		var firstCompFocus = null;
		
		var forms = document.forms;
		// Itera??o sobre todos os formul?rios existentes na p?gina
		for( var iForm = 0 ; iForm < forms.length ; iForm++ ){
			
			// itera??o sobre os elementos do formul?rio que est?
			// sendo avaliado
			var elements = forms[ iForm ].elements;

			for( var iElement = 0 ; iElement < elements.length; iElement++ ){
				
				var compElement = elements[ iElement ];


				// Verifica se o elemento pode receber o foco, e caso possa armazena para
				// posterios configura??o
				if( !firstCompFocus && canReceiveFocus( compElement ) ){
					firstCompFocus = compElement;
				}

				
				// Configura??o dos elementos para data e number, os quais somente s?o v?lidos para
				// campos do tipo input (text, hidden, password, textarea)
				var date	= compElement.getAttribute("date");
				var number	= compElement.getAttribute("number");


				if( compElement.type == 'hidden' 
						|| compElement.type == 'text' 
						|| compElement.type == 'textarea'
						|| compElement.type == 'password' ){
					
					// Valida??o, pois deve haver somente um tipo de configura??o por componentes, 
					// n?o podendo existir configura??o de data e n?mero em um mesmo componente
					if( date && number ){
						alert('ERRO:O campo \'' + compElement.name + '\' cont?m configura??es tanto para data\n'
								+ ' como para n?mero, sendo que deve haver somente um tipo de \n'
								+ ' configura??o por componente (Input HTML).\n'
								+ ' Devido a esse problema esse campo n?o ter? nenhuma configura??o.');
						continue;
					
					}else if( date && !number ){
					// Executa as configuracoes para os elementos de data
						var value = trim( compElement.value );
						
							// Configura para a apresentacao do valor do patter a ser utilizada para
							// a apresentacao da data
							if( date == 'dd/MM/yyyy' && !value ){
								compElement.value = VALUE_LABEL_DATE;
							}else if( date == 'MM/yyyy' && !value ){
								compElement.value = VALUE_LABEL_MES_ANO;
							}

							compElement.onfocus = compElement.onfocus ? 
													( clearLabelValueDate && ( compElement.onfocus ) ) : clearLabelValueDate;

							compElement.onblur = compElement.onblur ? 
													( configLabelValueDate && ( compElement.onblur ) ) : configLabelValueDate;


						// Configura para a exibi??o da mascara para a data
							compElement.onkeyup = compElement.onkeyup ? 
													( formatDate && ( compElement.onkeyup ) ) : formatDate;
							
							compElement.onblur  = ( formatDate && ( compElement.onblur ) );

						
					}else if( !date && number ){
					// Executa as configura??es para os elementos de n?mero
							if( number == 'real' ){
								compElement.onkeyup = compElement.onkeyup ? 
													( formatRealNumber && ( compElement.onkeyup ) ) : formatRealNumber;

								compElement.onblur = compElement.onblur ? 
													( formatRealNumber && ( compElement.onblur ) ) : formatRealNumber;

							}else if( number == 'integer' ){
								compElement.onkeyup = compElement.onkeyup ? 
													( formatIntegerNumber && ( compElement.onkeyup ) ) : formatIntegerNumber;

								compElement.onblur = compElement.onblur ? 
													( formatIntegerNumber && ( compElement.onblur ) ) : formatIntegerNumber;

							}
					}

					
					if( compElement.getAttribute("maxLength") ){
						// Configura??o geral para qualquer tipo de componente
						compElement.onkeyup =  compElement.onkeyup ?
													( controlMaxLength && ( compElement.onkeyup ) ) : controlMaxLength;
						compElement.onblur =  compElement.onblur ?
													( controlMaxLength && ( compElement.onblur ) ) : controlMaxLength;
						compElement.onfocus =  compElement.onfocus ?
													( controlMaxLength && ( compElement.onfocus ) ) : controlMaxLength;

					}

				// final do teste pois s? pode haver configura??es de data e n?mero para os
				// input do tipo (hidden, text, textarea, password)
				}else if( compElement.type == 'select-one' ||  compElement.type == 'select-multiple' ){

					// Caso o combobox estiver configurado para carregar como datasource
					// configurar o m?todo apropriado a ser chamado
					var datasource = compElement.getAttribute('datasource');
					if( datasource ){
						loadCombobox( forms[ iForm ].name, compElement.name );
					}

				}

			}// final da itera??o sobre os elementos do formul?rio

		}// final da itera??o sobre o formul?rio

		// Configura o foco para o primeiro elemento que possa receber o foco
		if( firstCompFocus ){
			setFocusOnElement( firstCompFocus );
		}

		return;
	}
	
	/**
	 * Fun??o respons?vel pelo in?cio do processo de carga dos dados de uma determinada
	 * combobox
	 */
	function loadCombobox( aFormName, aName ){
		var combobox   = getComponent( aFormName, aName );
		var datasource = combobox.getAttribute('datasource');
		var label 	   = combobox.getAttribute('label');
		var value 	   = combobox.getAttribute('value');
		var param 	   = combobox.getAttribute('param');
		
		combobox.length = 0;
		combobox.options[0] = new Option("CARREGANDO ...","");
		combobox.selectedIndex = 0;
		
		var array = null;
		
		if( param ){
			array = loadPropertiesWithParam( datasource, new Array(label,value) , aFormName , param );
		}else{
			array = loadProperties( datasource, new Array(label,value) , aFormName );
		}
		
		if( array ){
			var tam = array.length;
			for( i = 0 ; i < tam ; i++ ){
				combobox.options[ (i + 1) ] = new Option(array[i][label],array[i][value]);
			}
		}

		combobox.options[0] = new Option("..:: SELECIONE ::..","");
		combobox.value = "";		
		
		return;
	}


	/**
	 * Fun??o respons?vel pela valida??o de obrigatoriedade no preenchimento do valor de um
	 * determinado input, essa obrigatoriedade pode ser indicada no pr?prio input atrav?s do
	 * atributo required="true"
	 *
	 * Return - Objeto ValidationResult que contem o resultado da avalia??o juntamente 
	 *			com a mensagem a ser exebida caso a valida??o tenha encontrado erros
	 */	
	function validateRequired( aComponent, aLabel ){

		var valid = true;
		if( validateRefComponent( aComponent ) ){
		
			var value = getComponentValue( aComponent );
			
			var dtPattern = aComponent.getAttribute('date');
			if( !dtPattern ){
				if( !value ) valid = false;

			}else if( dtPattern ){
				if( !value || (value == VALUE_LABEL_MES_ANO || value == VALUE_LABEL_DATE) ) valid = false;

			}
 
	
			return new ValidationResult( valid, ( valid ? null : aLabel + ':Campo de preenchimento obrigat\u00f3rio.' ) );					
		}
		return null;
	}
	
	/**
	 * M?todo respons?vel por ajustar o foco para um determinado
	 * input
	 * 
	 * aComponent - Referencia para o componente para o qual se deseja configurar o foco
	 */	
	function setFocusOnElement( aComponent ){
		if( canReceiveFocus(  aComponent  ) ){
			aComponent.focus();
		}
		return;
	}
	
	/**
	 * Fun??o que retorna um valor boolean indicando se o componente em quest?o
	 * pode ou n?o receber o foco
	 */
	function canReceiveFocus(  aComponent  ){
		if( validateRefComponent( aComponent ) ){
			if( aComponent.getAttribute("type") != 'hidden' 
				&& !aComponent.disabled
				&& aComponent.focus){
					return true;
				}
		}
		
		return false;
	}

	
	/**
	 * M?todo respons?vel por objter o label de um determinado componente
	 * 
	 * aComponent - Referencia para o componente para do qual se deseja obter o label
	 */	
	function getComponentLabel( aComponent ){
		if( validateRefComponent( aComponent ) ){
			var label = aComponent.getAttribute("label");
			if( !label ){
				label = aComponent.name;
			}	
		
			return label
		}
		return null;
	}
	
	
	/**
	 * Fun??o de uso interno respons?vel pela valida??o das referencias para componente
	 * passada
	 *
	 * aComponent - Refencia que deseja se validar
	 */	
	function validateRefComponent( aComponent ){
		if( !aComponent 
				|| !(aComponent.type) 
				|| (	aComponent.type != 'select-multiple' 
					 && aComponent.type != 'radio'
					 && aComponent.type != 'checkbox'
					 && aComponent.type != 'select-one'
					 && aComponent.type != 'textarea'
					 && aComponent.type != 'password'
					 && aComponent.type != 'text' 
					 && aComponent.type != 'button' ) ){
			return false;
		}else{
			return true;
		}
	}

	
	/**
	 * Fun??o respons?vel por validar e retornar uma referencia para o formul?rio
	 * especificado atrav?s do nome
	 *
	 * aFormName - Nome do formul?rio que se deseja objeter
	 */
	function getFormByName( aFormName ){
		
		var form = null;
		
		// Valida??o dos par?metros passados
		if( !aFormName ){
			alert( 	 'ERRO: Deve ser especificado o nome do formul\u00e1rio a ser validado\n'
				   + 'na fun\u00e7\u00e3o \'validateForm( aFormName )\'' );
				   
		}else{
			form = document.forms[ aFormName ];
			
			if( !form ){
				alert( 	  'ERRO: O formul?rio com o nome \'' + aFormName + '\' n?o foi encontrado,\n' 
						+ 'ou existe algum erro de HTML que impede esse de ser encontrado.');
						
			}else{
				return form;
				
			}
			
		}
		
		return form;
	}

		
	/**
	 * Fun??o respons?vel por validar os campos input existentes no formul?rio
	 * especificado de acordo com os atributos colocados no formul?rio:
	 *
	 * aFormName - Nome do formul?rio a ser validado
	 * Return - O retorno da fun??o ? um valor booleano indicando se a fun??o
	 * 			foi bem sucedida ou n?o
	 *
	 * Atributos dos input HTML:
	 * label - Attributo abrigat?rio, pois esse ser? utilizado para efetuar 
	 *		   compor as mensagens a serem apresentadas, caso n?o seja colocado o nome do 
	 *		   element ser? utilizado para compor as mensagens
	 *
	 * required - Pode assumir dois valores true ou false, indicando se o campo ? 
	 *		   obrigat?rio ou n?o, sendo que a sua auzencia coloca o campo como n?o
	 *		   obrigat?rio.
	 * 		   
	 */
	function validateForm( aFormName ){
		
		// Declara??o das vari?veis
		var form	 	= getFormByName( aFormName );
		if( !form ) return;
		
		var elements 	= form.elements;
		if( !elements ) return;
		
		var valid		= true;		

		// In?cio do processo de valida??o
		var compElement = null;
		var label 		= null;
		var required 	= null;
		var message		= '';
		var resultComp  = null;

		// Vari?vel que armazena uma referencia para o
		// primeiro componente a apresentar erro e que pode receber foco
		var firstCompErro = null;

		// Itera??o sobre os elementos
		for( var i = 0 ; i < elements.length ; i++ ){
			
			// Obtendo elementos gerais para a valida??o
			compElement 	= elements[i];
			
			// Verifica se o elemento ? do tipo radio ou checkbox, caso seja
			// somente o elemento que tiver o attributo master="true" ser? o detentor
			// das configura??es para todos os demais, caso o elemento n?o tenha 
			// o atributo indicado ser? dado proseguimento com o pr?ximo elemento da
			// lista
			if( compElement.type == 'radio' || compElement.type == 'checkbox' ){
				if( !compElement.getAttribute("master") ){
					continue;
				}
			}
			
			label 			= getComponentLabel( compElement );
			resultComp  	= true;
			
			// Valida??o de obrigat?riedade de preenchimento do valor
			required 	= compElement.getAttribute("required");
			if( required ){
				validateResult = validateRequired( compElement, label );
				if( validateResult && !validateResult.valid ){
					valid	 		= false;
					resultComp		= false;
					message += '\n' + validateResult.message;
				}
			}
			
			// As demais verifica??es somente s?o feitas caso o valor do campo
			// n?o seja obrigat?rio, ou caso seja obrigat?rio e esteja presente
			if( ( required && resultComp ) || !required  ){
			
				// Valida??o com rela??o ao formato para os campos que receber 
				// um valor contendo uma data
				date = compElement.getAttribute("date");
				if( date ){
					validateResult = validateDate( compElement, label, date );
					if( validateResult && !validateResult.valid ){
						valid	   = false;
						resultComp = false;
						message += '\n' + validateResult.message;				
					}
				}


				// Valida??o com rela??o ao formato para os campos que receber 
				// um valor contendo um n?mero
				number = compElement.getAttribute("number");
				if( number ){
					validateResult = validateNumber( compElement, label, number );
					if( validateResult && !validateResult.valid ){
						valid	 = false;
						resultComp = false;						
						message += '\n' + validateResult.message;				
					}
				}


			}// final da verifica??o para a execu??o das demais verifica??es
			
			
			// Configura a apresenta??o do componente caso tenha sido
			// encontrado erro para o mesmo ou n?o
			if( !resultComp ){
				setComponentClassErro( compElement );
				
				// Configura o input que contem o erro a receber o foco 
				if( firstCompErro == null && canReceiveFocus( compElement ) ){
					firstCompErro = compElement;
				}				
			}else{
				resetComponetClassErro( compElement );
			}
			
			
		}// final da itera??o sobre os elementos do formul?rio
		
		// Alert para as mensagens de erro
		if( message != '' ){
			message = 'Ocorreu(ram) o(s) seguinte(s) erro(s) de valida\u00e7\u00e3o:\n' + message;
			alert( message );

			// Configura o erro para o componente caso ele exista
			if( firstCompErro ){
				setFocusOnElement( firstCompErro );
			}
			
		}
		
		return valid;
	}
	
	
	/**
	 * M?todo respons?vel por enviar todos os valores dos input existentes no formul?rio em quest?o 
	 * para a URL especificada no atributo action do formul?rio 
	 *
	 * aFormName - Nome do formul?rio que ter? os seus input enviados
	 * aArrayProperty - Array com o nome das propriedade a serem obtidas quando o elemento ? colocado no request	 
	 */
	function sendForm( aFormName, aArrayProperty ){
		var form   = getFormByName( aFormName );
		var action = form.action;
		sendFormToAction( aFormName, action , aArrayProperty );
		return;
	}
	
	
	/**
	 * M?todo respons?vel pela compara??o entre dois componentes que possuem valores de data
	 * caso a data inicial seja maior do que a data final, uma mensagem ? exibida retornando um valor
	 * false, caso a data inicial seja menor ou igual a data final retorna um valor true
	 *		
	 *		aFormName- Nome do formul?rio
	 *		aComponentNameStart - Nome do componente que contem a data de in?cio
	 *		aComponentNameEnd - Nome do componente que contem a data final
	 */
	function comparDate( aFormName, aComponentNameStart, aComponentNameEnd ){
		var dtCompInicial = getComponent( aFormName, aComponentNameStart );
		var dtCompFinal   = getComponent( aFormName, aComponentNameEnd );

		var dtInicial = getDate( dtCompInicial, true );
		var dtFinal   = getDate( dtCompFinal  , true );

		if( dtInicial && dtFinal ){
			if( dtInicial.getFullYear() > dtFinal.getFullYear() 
				|| ( dtInicial.getFullYear() == dtFinal.getFullYear() 
						&& dtInicial.getMonth() > dtFinal.getMonth() )
				|| ( dtInicial.getFullYear() == dtFinal.getFullYear() 
						&& dtInicial.getMonth() == dtFinal.getMonth()
						&& dtInicial.getDate()  > dtFinal.getDate() )){
				alert( "A data inicial '" + getComponentLabel(dtCompInicial) + "' deve ser menor que a data final '" + getComponentLabel(dtCompFinal) + "'" );
				return false;
			}else{
				return true;
			}
		}else{
			return true;
		}
	}

	/**
	 * M?todo respons?vel por validar e enviar todos os valores dos input existentes no formul?rio em quest?o 
	 * para a URL especificada no atributo action do formul?rio 
	 *
	 * aFormName - Nome do formul?rio que ter? os seus input enviados
	 * aArrayProperty - Array com o nome das propriedade a serem obtidas quando o elemento ? colocado no request	 	 
	 */
	function sendAndValidateForm( aFormName, aArrayProperty ){
		if( validateForm( aFormName ) ){
			sendForm( aFormName, aArrayProperty );
			return true;
		}
		return false;
	}


	/**
	 * M?todo que valida e envia os todos os valores dos input existentes no formul?rio em quest?o para a
	 * URL especificada no par?metro
	 *
	 * aFormName - Nome do formul?rio que ter? os seus input enviados
	 * aAction - URL para a qual ser?o enviados os valores do input do formul?rio	 
	 * aArrayProperty - Array com o nome das propriedade a serem obtidas quando o elemento ? colocado no request
	 */
	function sendAndValidateToAction( aFormName, aAction, aArrayProperty){
		if( validateForm( aFormName ) ){
			var array = sendFormToAction( aFormName, aAction, aArrayProperty );
			return ( array != null )? array : true;
		}
		return false;
	}

	
	/**
	 * M?todo que retorna uma string com a lista formatada de todos os par?metros do formul?rio
	 * cujo nome ? passado como par?metro
	 * Param:
	 *		aFormName - Nome do formul?rio
	 */
	function getParameterToPost( aFormName ){
		var form   	 = getFormByName( aFormName );
		var elements = form.elements;
		
		var parameter = '';
		var separador = '&';
		
		// Itera??o sobre os elementos do formul?rio para obten??o
		// da lista de par?metros
		for( var i = 0 ; i < elements.length ; i++ ){
			compElement = elements[i];
			
			if( compElement.type == 'hidden' || compElement.type == 'textarea' 
					|| compElement.type == 'password' || compElement.type == 'text' ){
					
				compElement.value = trim( compElement.value );
				if( parameter ) parameter += separador;
				parameter += compElement.name + '=' + compElement.value.replace(/%/g, "%25").replace(/&/g, "%26");
				
			}else if( compElement.type == 'select-one' ){
				
				if( compElement.selectedIndex > 0 ){
					value = compElement.options[ compElement.selectedIndex ].value;
					value = trim( value );
					if( parameter ) parameter += separador;
					parameter += compElement.name + '=' + value.replace(/%/g, "%25").replace(/&/g, "%26");
				}
				
			}else if( compElement.type == 'radio' || compElement.type == 'checkbox' ) {
				
				if( compElement.checked ){
					if( parameter ) parameter += separador;
					parameter += compElement.name + '=' + compElement.value.replace(/%/g, "%25").replace(/&/g, "%26");
				}
				
			}else if( compElement.type == 'select-multiple' ){
				
				compOptions = compElement.options;
				for( var iMultiple = 0; iMultiple < compOptions.length ; iMultiple++ ){
					if( compOptions[iMultiple].selected ){
						if( parameter ) parameter += separador;
						parameter += compElement.name + '=' + compOptions[iMultiple].value.replace(/%/g, "%25").replace(/&/g, "%26");
					}
				}
			}
		}
		
		return parameter;
	}

	/**
	 * M?todo que envia os todos os valores dos input existentes no formul?rio em quest?o para a
	 * URL especificada no par?metro
	 *
	 * aFormName - Nome do formul?rio que ter? os seus input enviados
	 * aAction - URL para a qual ser?o enviados os valores do input do formul?rio	 
	 * aArrayProperties - Array com o nome das propriedade a serem obtidas quando o elemento ? colocado no request
	 */
	function sendFormToAction( aFormName, aAction, aArrayProperty){
		var param = getParameterToPost( aFormName );
		if( aArrayProperty != null 
				&& aArrayProperty.length > 0){
			param += (( param == '' )? 'JCPR=' : '&JCPR=' );
			
			for( var i = 0 ; i < aArrayProperty.length ; i++ ){
				if( i > 0 ) param += ',';
				param += aArrayProperty[i];
			}
		}
	
		var array = connectOnServer( aAction, param ) ;
		return ( array != null )? array : true;
	}
	

	/**
	 * M?todo que envia, via GET, os pares nome=valor passados como par?metros via o ArrayProperty
	 * aAction - URL para a qual ser? enviado
	 * aArrayProperty - Array contendo objetos da 
	 */
	function Parameter( aName, aValue ){
		this.name = aName;
		this.value = aValue;
		return this;
	}
	
	function parseArrayParamToString(aArrayParam){
		var param = "";
		for (i = 0; i < aArrayParam.length; i++){
			paramTmp = aArrayParam[i];
			if (param == ""){
				param = paramTmp.name + "=" + paramTmp.value;
			}else{
				param += "&" + paramTmp.name + "=" + paramTmp.value;
			}
		}
		return param;
	}
	
	function sendParamToAction(aAction, aArrayProperty, aArrayParam){
		var param = parseArrayParamToString(aArrayParam);
		
		if( aArrayProperty != null 
				&& aArrayProperty.length > 0){
			param += (( param == '' )? 'JCPR=' : '&JCPR=' );
			
			for( var i = 0 ; i < aArrayProperty.length ; i++ ){
				if( i > 0 ) param += ',';
				param += aArrayProperty[i];
			}
		}
	
		var array = connectOnServer( aAction, param ) ;
		return ( array != null )? array : true;
	}


/**
	 * M?todo respons?vel por abrir um pop-up
	 * Param:
	 *	aUrl - Url da janela a ser aberta
	 *  aName - Nome da nova janela
	 *  aScrollbars - Valor boolean indicando se a janela vai ter scroll ou n?o
	 *  aResizable - Valor indicando se a tela ser? redimencion?vel
	 *	aWidth - Valor q contem a largura da tela
	 *	aHeigth - Valor q contem a altura da tela
	 * 
	 * Return:
	 *	Referencia para a janela criada
	 */
	function openPopUp( aUrl, aName, aScrollbars, aResizable, aWidth, aHeigth ){
		return openPopUp( aUrl, aName, aScrollbars, aResizable, aWidth, aHeigth, 'yes' );
	}
	
	
	/**
	 * M?todo respons?vel por abrir um pop-up
	 * Param:
	 *	aUrl - Url da janela a ser aberta
	 *  aName - Nome da nova janela
	 *  aScrollbars - Valor boolean indicando se a janela vai ter scroll ou n?o
	 *  aResizable - Valor indicando se a tela ser? redimencion?vel
	 *	aWidth - Valor q contem a largura da tela
	 *	aHeigth - Valor q contem a altura da tela
	 *  aStatusBar - Indica se haver? ou n?o barra de status na tela
	 * Return:
	 *	Referencia para a janela criada
	 */
	function openPopUp( aUrl, aName, aScrollbars, aResizable, aWidth, aHeigth, aStatusBar ){
		var x = (screen.width -aWidth)/2;
		var y = (screen.height - aHeigth)/2;	

		var features = 'scrollbars=' + aScrollbars + ',';
		features +='toolbar=no,location=no,directories=no,';
		features +='status=' + aStatusBar + ',menubar=no,';
		features +='resizable=' + aResizable + ',';  
		features +='resize=yes,';
		features +='copyhistory=yes,titlebar=0,';
		features +='left=' + x + ',top=' + y + ',screenX=' + x + ',';
		features +='screenY=' + y + ',width=' + aWidth + ',';
		features +='height=' + aHeigth ;
		
		var win = window.open( aUrl ,aName, features);

		if( win.focus ){
			win.focus();
		}

		return win;
	}

	/**
	 * M?todo que tem como objetivo a conex?o com o servidor atrav?s da URL especificada
	 * enviando os par?metros indicados e configurando uma fun??o de callback a ser chamada
	 * quando o termino da opera??o
	 */
	function connectOnServer( aUrl, aParameter ){
		
		var REQUEST = null;
		var array	= null;
		var xml		= null;

	    if (window.XMLHttpRequest) {
    	    REQUEST = new XMLHttpRequest();
			
	    } else if (window.ActiveXObject) {
    	    REQUEST = new ActiveXObject("Microsoft.XMLHTTP");
	    }
		
		try{
			REQUEST.open("POST", aUrl, false );
		    REQUEST.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded; charset=UTF-8');
		    
		    //aParameter = escape(aParameter);
		    aParameter = replaceAll( aParameter, '+', '%2B' );
		    /*aParameter = aParameter.replace('+', '%2B');
		    aParameter = aParameter.replace('%20', '+');
		    aParameter = aParameter.replace('*', '%2A');
		    aParameter = aParameter.replace('/', '%2F');
		    aParameter = aParameter.replace('@', '%40');*/
		    
			REQUEST.send( aParameter );
			
			var processoOk = false;
			
			if( REQUEST.readyState == 4 ) {
       			if( REQUEST.status == 200 ) {
					processoOk = true;
					xml = REQUEST.responseXML;
					
					if( xml && xml.documentElement ){
						
						if( xml.documentElement.nodeName == TAG_MESSAGE_ERRO ){ 
							alert( xml.documentElement.firstChild.data );
							return false;

						}else if( xml.documentElement.nodeName == TAG_WINDOW_ERRO ){
							openPopUp(URL_ERRO_PAGE, 'erro','no','yes', 750, 450 );
							return false;

						}else if( xml.documentElement.nodeName == TAG_ITEMS ){

							var items = xml.documentElement.childNodes;
							for( i = 0 ; i < items.length ; i++ ){
								if( items[i].nodeName == TAG_ITEM ){
									var item = items[i].childNodes;
									for( y = 0 ; y < item.length; y++ ){
										
										if( item[y].nodeName == TAG_MESSAGE_CONFIRM ){
												array = true;
												alert( item[y].firstChild.data );
										
										}else if( item[y].nodeName == TAG_OBJECT ){
												
												var tagProperty = item[y].childNodes;
												array = new Array();
												
												for( var iProperty = 0 ; iProperty < tagProperty.length ; iProperty++ ){
													if( tagProperty[iProperty].nodeName == TAG_PROPERTY ){
															var name	 = null;
															var value	 = null;

															var tagItens = tagProperty[ iProperty ].childNodes;
	
															for( var iItens = 0 ; iItens < tagItens.length ; iItens++ ){
	
																if( tagItens[iItens].nodeName == TAG_NAME ){
																	name = tagItens[ iItens ].firstChild.data;

																}else if( tagItens[iItens].nodeName == TAG_VALUE ){
																	value = tagItens[ iItens ].firstChild.data;
																}
															}
															
															array[ name ] = value;
													}
												}
												
										}else if( item[y].nodeName == TAG_COLLECTION ){												
														
												var tagItens = item[y].childNodes;
												array = new Array();

												for( var iItens = 0 ; iItens < tagItens.length ; iItens++ ){
													
													if( tagItens[iItens].nodeName == TAG_ITEM && tagItens[iItens].firstChild.nodeName == TAG_OBJECT ){

														var arrayObj = new Array();
														var tagProperty = tagItens[iItens].firstChild.childNodes;
														
														for( var iProperty = 0 ; iProperty < tagProperty.length ; iProperty++ ){
															
															if( tagProperty[iProperty].nodeName == TAG_PROPERTY ){
																
																var name  = null;
																var value = null;
																var tagItensProperty = tagProperty[ iProperty ].childNodes;

																for( var iItensProperty = 0 ; iItensProperty < tagItensProperty.length ; iItensProperty++ ){
																	if( tagItensProperty[iItensProperty].nodeName == TAG_NAME ){
																		name = tagItensProperty[ iItensProperty ].firstChild.data;


																	}else if( tagItensProperty[iItensProperty].nodeName == TAG_VALUE ){
																		value = tagItensProperty[ iItensProperty ].firstChild.data;

	
																	}
																}

																arrayObj[ name ] = value;
															}

														}
									
														array[ array.length ] = arrayObj;

													}
	
												}// Loop: for( var iItens = 0 ; iItens < tagItens.length ; iItens++ ){

										}// Teste: else if( item[y].nodeName == TAG_COLLECTION ){
										
										
										
									}

								}//Teste: if( items[i].nodeName == TAG_ITEM ){

							}

						}// Teste: else if( xml.documentElement.nodeName == TAG_ITEMS ){

					}				

		        }
				
				if( !processoOk ){
    		    	msg = "ERRO:Ocorreu o erro " + REQUEST.status + " durante o \n"
    		    		+ "processamento da requisi??o feita com o protocolo HTTP.\n"
						+ REQUEST.statusText;
					alert( msg );
		        }
   			}

		}catch( e ){
			var msg = "ERRO:Ocorreu uma falhas ao se conectar com o servidor do sistema,\n " 
				+ "favor entrar em contato com o adminstrador para provid?ncias.\n"
				+ "Stacktrace:\n"
				+ e.message;

			alert( msg );
		}

		return array;	
	}
	
	
	/**
	 * Fun??o respons?vel por desabilitar um determinado componente de acordo com as possibilidade
	 * do mesmo
	 */
	function disabledComponent( aComponent, aValue ){
		if( validateRefComponent( aComponent ) ){
			if( aComponent.type != 'hidden' ){
				aComponent.disabled = aValue;
			}
		}
		return;
	}

	/**
	 * Fun??o respons?vel por desabilitar todos os elementos de um determinado formul?rio
	 * 
	 * aFormName - Nome do formul?rio
	 * aValue - Campo que contem um valor boolean que indica se deve ser desabilitado ou n?o
	 */	
	function disabledForm( aFormName , aValue ){
		return disabledFormExcept( aFormName , null,  aValue );
	}

		
	/**
	 * Fun??o respons?vel por desabilitar todos os elementos de um determinado formul?rio, 
	 * a menos os componentes cujos nomes se encontram no array tamb?m passado como par?metro
	 * 
	 * aFormName - Nome do formul?rio
	 * aArrayExcept - Array com o nome dos componentes que n?o devem ser especificados
	 * aValue - Campo que contem um valor boolean que indica se deve ser desabilitado ou n?o
	 */
	function disabledFormExcept( aFormName , aArrayExcept,  aValue ){
		
		// Obtem o formul?rio a ser desabilitado
		var form = getFormByName( aFormName );
		
		if( form ){
			// Obtem os elementos a serem percorrido
			var elements = form.elements;
			if( !elements ) return;
			
			for( var i = 0 ; i < elements.length ; i++ ){
				var disable = aValue;
				var change = true;

				if( aArrayExcept ){
					for( var y = 0 ; y < aArrayExcept.length; y++ ){
						if( aArrayExcept[y] == elements[i].name ){
//							if (disable == false && elements[i].disabled == false) {
//								disable = true;
//							} else if (disable == true && elements[i].disabled == true) {
//								disable = false;						
//							} else {
								change = false;
//							}
						}
					}
				}

				if( change ){
					disabledComponent( elements[i], disable );
				}
			}
		}
		return;
	}

	
	/**
	 *	Fun??o respons?vel por alterar a configura??o de obrigatoriedade de um determinado componente
	 * 
	 *
	 *  aComponent - Componente que ter? a sua obrigatoriedade alterada
	 *  aValue - Propriedade que contem um valor boolean que indica se o componente ser? posto 
	 *			 como obrigat?rio ou n?o
	 */
	function setComponentRequired( aComponent, aValue ){
		if( validateRefComponent( aComponent ) ){
			aComponent.setAttribute('required', aValue );
		}
		return;
	}
	
	/**
	 * M?todo respons?vel por retornar os valores associados a um determinado componente
	 * 
	 */
	function getComponentValue( aComponent ){
		var value = null;


		if( aComponent.length ){
			// elemento checkbox ou radiobox
			
			for( var i = 0 ; i < aComponent.length ; i++ ){

				if( aComponent.type == 'select-multiple' ){

					compOptions = aComponent.options;

					for( var iMultiple = 0; iMultiple < compOptions.length ; iMultiple++ ){
						if( compOptions[iMultiple].selected ){
							if( !value )value = new Array();
							value[ value.length ] = compOptions[iMultiple].value;
						}
					}
					break;

				}else if( aComponent[i].type == 'radio' || aComponent[i].type == 'checkbox' ){

						if( aComponent[i].type == 'radio' 
										&& aComponent[i].checked){

							value = aComponent[i].value;
							break;

						}else if( aComponent[i].type == 'checkbox' 
										&& aComponent[i].checked ){
						
							if( !value ) value = new Array();
							value[ value.length ] = aComponent[i].value;

						}

				}else if( aComponent.type == 'select-one' ){
					if( aComponent.selectedIndex > 0 ){
						value = aComponent.options[ aComponent.selectedIndex ].value;
						value = trim( value );
					}
					break;
				}

			}// final da itera??o dos elementos contidos no componente

		}else{
			if( aComponent.type == 'hidden' || aComponent.type == 'textarea' 
					|| aComponent.type == 'password' || aComponent.type == 'text' ){
					
				value = trim( aComponent.value );
				
			}else if( aComponent.type == 'radio' ){
				aComponent = aComponent.form.elements[ aComponent.name ];
				for( var i = 0 ; i < aComponent.length ; i++ ){
					itemComponent = aComponent[i];
					if( itemComponent.checked ){
						value = itemComponent.value;
						break;
					}
				}

			}else if( aComponent.type == 'checkbox' ){
				
				aComponent = aComponent.form.elements[ aComponent.name ];
				for( var i = 0 ; i < aComponent.length ; i++ ){
					itemComponent = aComponent[i];
					if( itemComponent.checked ){
						if( !value ) value = new Array();
						value[ value.length ] = itemComponent.value;
					}
				}
			}

		}
		return value;
	}



	/**
	 * M?todo que retorna o valor do formato de data atribuido para o componente
	 * Fun??o somente aplicada a componentes que possuem o atributo date especificado
	 */
	function getDateFormat( aComponent ){
		var format = null;
		if( validateRefComponent( aComponent ) ){
			format = aComponent.getAttribute('date');
		}
		return format;
	}
	
	/**
	 * Fun??o que retorna um objeto data, apartir do valor existente no componente que armazena a data.
	 * O par?metro aValidate ir? indicar se deve ser colcado um alert informando se deve ser informado caso haja falha
	 * na valida??o do valor do componente
	 * Fun??o somente aplicada a componentes que possuem o atributo date especificado
	 */
	function getDate( aComponent, aValidate ){
		var date = null;
		if( validateRefComponent( aComponent ) ){
			
			result = validateDate( aComponent, getComponentLabel( aComponent ) , getDateFormat( aComponent ) );
			if( result && result.valid ){
				date			= getComponentValue( aComponent );

				var splitDate	= new RegExp("/");
				itens			= date.split(splitDate);

				itDate			= null;
				itMonth			= null;
				itYear			= null;
				
				if( itens[0] && itens[0].length >= 2 ){
					itDate	= parseInt( ( itens[0].substring(0,1) == 0 ) ? itens[0].substring(1) : itens[0] );
				}

				if( itens[1] && itens[1].length >= 2 ){
					itMonth	= parseInt( ( itens[1].substring(0,1) == 0 ) ? itens[1].substring(1) : itens[1] );
				}

				itYear	= parseInt( itens[2] );

				if( !isNaN(itDate) && !isNaN(itMonth) && !isNaN(itYear) ){
					date = new Date();
					date.setYear	( itYear	  );
					date.setMonth	( itMonth - 1 );
					date.setDate	( itDate	  );
				}else{
					return null;
				}

			}else if( aValidate ){ // Valida??o do valor do componente v?lido
				alert( result.message );
				if( canReceiveFocus( aComponent ) ){
					setFocusOnElement( aComponent );
					return false;
				}
			}

		}// Valor do componente existente
		return date;
	}

	
	/**
	 * Fun??o que configura o valor de um determinado componente que armazena uma data
	 * com a data especificada
	 * aComponent - Referencia para o componente
	 * aDate - Data que ser? configurada
	 */
	function setDateToComponent( aComponent, aDate ){
		if( validateRefComponent( aComponent ) ){
			var dateFormat = getDateFormat( aComponent );
			if( !dateFormat ){
				alert( 'ERRO: O m?todo setDateToComponent( aComponent, aDate ) somente pode ser aplicado \n'
						+ ' para componentes que possuem o attributo date especificado.');

			}else if( aDate ){
				var strDay = trim( aDate.getDate().toString() );
				if( strDay.length == 1 ) strDay = '0' + strDay;
				
				var strMonth = trim( (aDate.getMonth() + 1).toString() );
				if( strMonth.length == 1 ) strMonth = '0' + strMonth

				var str = strDay + '/' +  strMonth + '/' + aDate.getFullYear();
				setComponentValue( aComponent, str );
			}
		}
		return;
	}
	
	
	/**
	 * Adiciona ao valor (positivo ou negativo) obtido do componente, 
	 * o qual cont?m uma data a quantidade de anos especificada
	 */
	function addYear( aDate,  aYear ){

		if( !aDate ) return null;
		if( !(aDate instanceof Date)){
			alert( 'ERRO: O objeto passado como par?metro para o m?todo addMonth( aDate, aMonth )\n'
					+ 'precisa ser um objeto date v?lido.');
			return null;
		}

		var date = null;
		if( aYear != null && aYear != undefined && !isNaN( aYear ) ){
			
			var valYear  = parseInt( aDate.getFullYear()  );
			var valMonth = parseInt( aDate.getMonth() + 1 );
			var valDate  = parseInt( aDate.getDate()	   );

			valYear += aYear;
			
			if( valMonth == 2 && ( valYear % 4 != 0 ) && valDate == 29 ){
				valDate = 28;
			}

			date = new Date( aDate );
			
			date.setDate    ( valDate      );
			date.setMonth   ( valMonth - 1 );
			date.setFullYear( valYear      );
		}

		return date;
	}


	/**
	 * Adiciona ao valor(positivo ou negativo) obtido do componente
	 * o qual cont?m uma data a quantidade de meses especificada
	 */
	function addMonth( aDate, aMonth ){
		
		if( !aDate ) return null;
		if( !(aDate instanceof Date)){
			alert( 'ERRO: O objeto passado como par?metro para o m?todo addMonth( aDate, aMonth )\n'
					+ 'precisa ser um objeto date v?lido.');
			return null;
		}

		var date = null;
		if( aMonth != null && aMonth != undefined && !isNaN( aMonth ) ){

			if( aDate ){
				var valMonth = aDate.getMonth() + 1;
				var valYear  = aDate.getFullYear();
				var valDate	 = aDate.getDate();
				
				valMonth += aMonth;

				if( valMonth > 12 ){
					valYear  += parseInt( valMonth / 12 );
					valMonth  = parseInt( valMonth % 12 );

				}if( valMonth < 0 ){
					valYear  += parseInt( aMonth / 12 );
					valMonth  = ( aDate.getMonth() + 1 ) + parseInt( aMonth % 12 );
				
				}else if( valMonth == 0 ){
					valMonth  = 12;
					valYear--; 
				}

				if( valMonth == 2 && valDate == 29 && ( valYear % 4 != 0 ) ){
					valDate = 28;
				}

				if( ( valMonth == 4 || valMonth == 6 || valMonth == 9 || valMonth == 11 )
						&& valDate == 31 ){
					valDate = 30;
				}
				
				date = aDate;
				date.setDate ( valDate		);
				date.setMonth( valMonth - 1 );
				date.setYear ( valYear		);

			}
		}
		return date;
	}
	

	/**
	 * Adiciona ao valor(positivo ou negativo) obtido do componente
	 * o qual cont?m uma data a quantidade de dias especificado
	 */	
	function addDay( aDate, aDay ){
		if( !aDate ) return null;
		if( !(aDate instanceof Date)){
			alert( 'ERRO: O objeto passado como par?metro para o m?todo addMonth( aDate, aMonth )\n'
					+ 'precisa ser um objeto date v?lido.');
			return null;
		}

		var date = null;
		if( aDay != null && aDay != undefined && !isNaN( aDay ) ){
			date = new Date( aDate.getTime() + ( aDay * 86400000 ) );
		}
		return date;
	}

	
	/**
	 * Fun??o que retorna uma referencia para o elemento de um determinado formul?rio
	 * Param:
	 *		aFormName - Nome do formul?rio do qual se deseja obter o elemento
	 *		aElementName - Nome do elemento do qual se deseja a referencia
	 */
	function getFormElement( aFormName, aElementName ){
		var form	= getFormByName( aFormName );
		var element = null;
		if( form ){
			element = form.elements[ aElementName ];	

			if( !element ){
				alert( 'ERRO: O elemento de nome \'' + aElementName + '\' no formul?rio \'' + aFormName
					+ '\' \n n?o foi encontrado.')
			}
		}
		
		return element;
	}


	/**
	 * Fun??o respons?vel por configurar o valor de um determinado componente
	 * Param:
	 *	aComponent - Referencia para o componente que ser deseja obter a referencia
	 *	aValue - Valor a ser configurado para o componente
	 */ 
	function setComponentValue( aComponent, aValue ){
		if( !aComponent.length ){
			if( aComponent.type == 'hidden' 
				|| aComponent.type == 'text' 
				|| aComponent.type == 'textarea' ){
				aComponent.value = aValue;
			}
		}
		return;
	}

	
	/**
	 * M?todo respons?vel por limpar todos os campos do formul?rio
	 */
	function clearForm( aFormName ){
		return clearFormExcept( aFormName,null );
	}

	
	/**
	 * M?todo respons?vel por limpara todos os campos de um formul?rio 
	 * a menos os campos indicados
	 */
	function clearFormExcept( aFormName, aArrayExcept){
		var element = getFormByName( aFormName ).elements;
		
		var tam = element.length;
		for( i = 0; i < tam ; i++  ){

			var limpar = true;
			if( aArrayExcept != null ){
				for(y = 0; y < aArrayExcept.length; y++){
					if( element[i].name != null && 
						element[i].name != undefined && 
						aArrayExcept[y] == element[i].name ){
						limpar = false;
						break;
					}
				}
			}

			if(limpar){
				if(	element[i].type == 'text' || 
					element[i].type == 'hidden' || 
					element[i].type == 'textarea' ) {
	
					element[i].value = '';

				}else if( element[i].type == 'select-one' ){			
					
					if( element[i].options.length >= 1 ){
						element[i].selectedIndex = 0;
					}

				}else if( element[i].type == 'select-multiple' ){

					compOptions = element[i].options;
					for( var iMultiple = 0; iMultiple < compOptions.length ; iMultiple++ ){
						compOptions[iMultiple].selected = false;
					}

				}else if( element[i].type == 'checkbox' ){

					element[i].checked = false;

				}
				
			}// final do teste if para o verifica??o do limpar

		}// final da itera??o entre os componentes

		return true;
	}


	/**
	 * Fun??o respons?vel por obter os par?metros de configura??o a ser utilizada por um 
	 * determinado elemento
	 */
	function getParamConfiguration( aRef ){
		var arrayParameters = document.getElementsByTagName('param');
		var parameters	  = new Array();
		if( arrayParameters ){
			for( var i = 0 ; i < arrayParameters.length ; i++ ){
				var ref = arrayParameters[i].getAttribute('ref');
				if( ref == aRef ){
					parameters[parameters.length] = arrayParameters[i];
				}
			}
		}
		return parameters;
	}

	
	/**
	 * M?todo que retorna uma string contendo todos os par?metros 
	 */
	function getRefParameterToPost( aFormaName, aRef ){
		var parameter = getParamConfiguration( this.name );
		var strParameter  = '';
		
		if( parameter && parameter.length && parameter.length > 0 ){

			for( var i = 0 ; i < parameter.length ; i++ ){
				name	= parameter[i].getAttribute("name");
				urlName = parameter[i].getAttribute("urlName");
				value	= getComponentValue( getFormByName( aFormaName ).elements[ name ] );
				
				if( value && ( value instanceof Array ) ){
					for( var y = 0 ; y < value.length; y++ ){
						if( strParameter ) strParameter += "&";
						strParameter += ( urlName ? urlName : name );
						strParameter += "=";
						strParameter += value[y];
					}
				}else{
					if( strParameter ) strParameter += "&";
					strParameter += (urlName ? urlName : name);
					strParameter += "=";
					strParameter += value;
				}
			}
		}
		
		return strParameter;
	}
	
	/**
	 * M?todo respons?vel por carrega apartir de um determinada datasource no servidor um array com os valores
	 * das propriedades desejadas
	 * Param:
	 *	aDatasource - DataSource a ser utilizado para se carregar os valores das propriedades
	 *	aArrayProperty - Array contendo o nome das proriedades desejadas
	 *	aFormName - Nome do formul?rio desejado
	 */
	function loadProperties( aDatasource, aArrayProperty , aFormName ){
		var parameter = getParameterToPost( aFormName );
		if( parameter ){
			parameter += '&JCDTS=' + escape( aDatasource );
		}else{
			parameter = 'JCDTS=' + escape( aDatasource );
		}
		return loadObjectFromServer( parameter, aArrayProperty );
	}

	
	/**
	 * M?todo respons?vel por carrega apartir de um determinada datasource no servidor um array com os valores
	 * das propriedades desejadas
	 * Param:
	 *	aDatasource - DataSource a ser utilizado para se carregar os valores das propriedades
	 *	aArrayProperty - Array contendo o nome das proriedades desejadas
	 *	aFormName - Nome do formul?rio desejado
	 *  aRef - Id da referencia das configura??es a serem utilizadas
	 */
	function loadPropertiesWithParam( aDatasource, aArrayProperty , aFormName , aRef ){
		var parameter = getRefParameterToPost( aFormName, aRef );

		if( parameter ){
			parameter += '&JCDTS=' + escape( aDatasource );

		}else{
			parameter  = 'JCDTS=' + escape( aDatasource );

		}
		
		return loadObjectFromServer( parameter, aArrayProperty );
	}

	
	/**
	 * M?todo de uso interno do Script respons?vel por carregar um array cujos indices s?o 
	 * os nomes das propriedades desejadas e o valor, o valor das propriedades
	 * Param:
	 *	aParameter - String no formato para os par?metros desejados
	 *	aArrayProperty - Array contendo o nome das propriedades desejadas
	 */
	function loadObjectFromServer( aParameter, aArrayProperty ){
		if( aArrayProperty && aArrayProperty.length > 0 ){
			aParameter += '&JCPR=';
			for( var i = 0 ; i < aArrayProperty.length ; i++ ){
				if( i > 0 ) aParameter += ',';
				aParameter += aArrayProperty[i];
			}
		}else{
			alert( 'ERRO: As propriedades desejadas deve ser especificado.' );
			return;
		}

		return connectOnServer( URL_LOAD_PROPERTY , aParameter );
	}
	
	function Parameter( aName, aValue ){
		this.name = aName;
		this.value = aValue;
		return this;
	}
	
	function parseArrayParamToString(aArrayParam){
		var param = "";
		if( aArrayParam ){
			for (i = 0; i < aArrayParam.length; i++){
				paramTmp = aArrayParam[i];
				if (param == ""){
					param = paramTmp.name + "=" + paramTmp.value;
				}else{
					param += "&" + paramTmp.name + "=" + paramTmp.value;
				}
			}
		}
		return param;
	}
	
	function loadPropertiesArrayParam( aDatasource, aArrayProperty , aArrayParam){
		var parameter = null;
		if( aArrayParam ){
			parameter = parseArrayParamToString(aArrayParam);
		}
		if( parameter ){
			parameter += '&JCDTS=' + escape( aDatasource );
		}else{
			parameter = 'JCDTS=' + escape( aDatasource );
		}
		return loadObjectFromServer( parameter, aArrayProperty );
	}
	
	/**
	 * Funcao responsavel por validar se o ano passado como parametro
	 * tem um formato valido.
	 */
	function validateYear(aValue, aKeyPress) { 
  
  		var TECLAS_CONTROLE = 0;
		var TECLA_BACKSPACE = 8;
  
   		var tecla  = aKeyPress.keyCode;

	   	if (tecla == TECLAS_CONTROLE || tecla == TECLA_BACKSPACE) {
	     	return true;
	     }
	
	 	if (aValue.value.length == 4) {
	   		alert("O campo ano deve ter no m\u00e1ximo 4 d\u00edgitos.");
	   		return false;
		} else { 
			if (tecla < 48 || tecla > 57){ 
	   			alert("Digite apenas n\u00fameros.");
	   			return false;
			}
		}
	   
	}
	
	/**
	 * Preenche a String ? esquerda com o caractere fornecido,
	 * at? que ela atinja o tamanho especificado.
	 *
	 * valor - String do valor a ser alterado
	 * tamanho - Tamanho maximo que deve possuir o valor mais os caracteres adicionados
	 * caracter - Caracter utilizado para preenher o valor
	 */
	function lpad(valor, tamanho, caracter) {
		var str = valor;
		var dif = tamanho - str.length;
		var ch = String(caracter).charAt(0);
		for (; dif>0; dif--) str = ch + str;
		return str;
	} //lpad

	/**
	 * Calcula os 2 d?gitos verificadores para o n?mero-efetivo pEfetivo de
	 * CNPJ (12 d?gitos) ou CPF (9 d?gitos) fornecido. isCnpj ? booleano e
	 * informa se o n?mero-efetivo fornecido ? CNPJ (default = false).
	 *
	 * pEfetivo - String do n?mero-efetivo (SEM d?gitos verificadores) de CNPJ ou CPF.
	 * isCnpj - Indica se a string fornecida ? de um CNPJ. Caso contr?rio, ? CPF. Default = false (CPF).
	 *
	 * Retorna uma string com os dois d?gitos verificadores.
	 */
	function dvCpfCnpj(pEfetivo, isCnpj) {

		if (isCnpj==null) {
			isCnpj = false;
		}

		var i, j, k, soma, dv;
		var cicloPeso = isCnpj? 8: 11;
		var maxDigitos = isCnpj? 14: 11;
		var calculado = pEfetivo.replace(/\D/g, "").replace(/^0+/, "");
		calculado = lpad(calculado, maxDigitos, '0');
		calculado = calculado.substring(2, maxDigitos);
		var result = "";

		for (j = 1; j <= 2; j++) {

			k = 2;
			soma = 0;

			for (i = calculado.length-1; i >= 0; i--) {
				soma += (calculado.charAt(i) - '0') * k;
				k = (k-1) % cicloPeso + 2;
			}

			dv = 11 - soma % 11;

			if (dv > 9) {
				dv = 0;
			}

			calculado += dv;
			result += dv

		}

		return result;

	} //dvCpfCnpj

	/**
	 * Testa se a String aCpf fornecida ? um CPF v?lido.
	 * Qualquer formata??o que n?o seja algarismos ? desconsiderada.
	 * 
	 * aCpf - String fornecida para ser testada.
	 *
	 * Retorna true se a String fornecida for um CPF v?lido.
	 */
	function isCpf(aCpf) {

		var numero = aCpf.replace(/\D/g, "").replace(/^0+/, "");
	
		numero = lpad(numero, 11, '0');

		var base = numero.substring(0, numero.length - 2);

		var digitos = dvCpfCnpj(base, false);

		var algUnico, i;

		// Valida d?gitos verificadores
		if (numero != base + digitos) {
			return false;
		}

		/* N?o ser?o considerados v?lidos os seguintes CPF:
		 * 000.000.000-00, 111.111.111-11, 222.222.222-22, 333.333.333-33, 444.444.444-44,
		 * 555.555.555-55, 666.666.666-66, 777.777.777-77, 888.888.888-88, 999.999.999-99.
		 */
		algUnico = true;

		for (i=1; i<11; i++) {
			algUnico = algUnico && (numero.charAt(i-1) == numero.charAt(i));
		}

		return (!algUnico);

	} //isCpf

	/**
	 * Testa se a String aCnpj fornecida ? um CNPJ v?lido.
	 * Qualquer formata??o que n?o seja algarismos ? desconsiderada.
	 *
	 * aCnpj - String fornecida para ser testada.
	 * 
	 * Retorna true se a String fornecida for um CNPJ v?lido.
	 */
	function isCnpj(aCnpj) {

		var numero = aCnpj.replace(/\D/g, "").replace(/^0+/, "");
	
		numero = lpad(numero, 14, '0');

		var base = numero.substring(0, 8);
		var ordem = numero.substring(8, 12);
		var digitos = dvCpfCnpj(base + ordem, true);
		
		// Valida d?gitos verificadores
		if (numero != base + ordem + digitos) {
			return false;
		}

		/* N?o ser?o considerados v?lidos os CNPJ com os seguintes n?meros B?SICOS:
		 * 11.111.111, 22.222.222, 33.333.333, 44.444.444, 55.555.555,
		 * 66.666.666, 77.777.777, 88.888.888, 99.999.999.
		 */
		var algUnico = numero.charAt(0) != '0';

		for (i=1; i<8; i++) {
			algUnico = algUnico && (numero.charAt(i-1) == numero.charAt(i));
		}

		if (algUnico) {
			return false;
		}

		/* N?o ser? considerado v?lido CNPJ com n?mero de ORDEM igual a 0000.
		 * N?o ser? considerado v?lido CNPJ com n?mero de ORDEM maior do que 0300
		 * e com as tr?s primeiras posi??es do n?mero B?SICO com 000 (zeros).
		 * Esta cr?tica n?o ser? feita quando o no B?SICO do CNPJ for igual a 00.000.000.
		 */
		if (ordem == "0000") {
			return false;
		}

		return (base == "00000000" || parseInt(ordem, 10) <= 300 || base.substring(0, 3) != "000");

	} //isCnpj

	/**
	 * Formata a string fornecida como CNPJ ou CPF.
	 *
	 * form - Nome do formulario
	 * event - Evento onKeyPress
	 * compName - Nome do componente
	 * isCnpj - Indica se a string fornecida ? um CNPJ. Caso contr?rio, ? CPF. Default = false (CPF).
	 */
	function formatCpfCnpj(form, event, compName, isCnpj) {
		
		var tecla = event.keyCode;

		if ((tecla >= 48 && tecla <= 57) || tecla == 0) {

			var component = getComponent(form, compName);

			var numero = component.value;

			var tamanho = numero.length;

			if (isCnpj) {

				component.setAttribute('maxLength', 18);

				if (tamanho > 1){
					var element = numero.substring(2,3);
					if( element != "." ){
						numero = numero.substring(0,2) + "." + numero.substring(2);  
						component.value = numero;
					}
				} 
				
				if (tamanho > 5){
					var element = numero.substring(6,7);
					if( element != "." ){
						numero = numero.substring(0,6) + "." + numero.substring(6);  
						component.value = numero;
					}
				} 
				
				if (tamanho > 9){
					var element = numero.substring(10,11);
					if( element != "/" ){
						numero = numero.substring(0,10) + "/" + numero.substring(10);  
						component.value = numero;
					}
				} 
				
				if (tamanho > 14){
					var element = numero.substring(15,16);
					if( element != "-" ){
						numero = numero.substring(0,15) + "-" + numero.substring(15); 
						component.value = numero;
					}
				}

			} else {

				component.setAttribute('maxLength', 14);

				if(tamanho > 2){
					var element = numero.substring(3,4);
					if( element != "." ){
						numero = numero.substring(0,3) + "." + numero.substring(3);  
						component.value = numero;
					}
				}

				if(tamanho > 6){
					var element = numero.substring(7,8);
					if( element != "." ){
						numero = numero.substring(0,7) + "." + numero.substring(7);  
						component.value = numero;
					}
				}

				if(tamanho > 10){
					var element = numero.substring(11,12);
					if( element != "-" ){
						numero = numero.substring(0,11) + "-" + numero.substring(11);  
						component.value = numero;
					}
				}

			}

			return true;
		
		} else {

			return false;

		}

	}
	
	/**
	 * Formata a string fornecida como Cep.
	 *
	 * aEvent - Evento onKeyPress
	 * aComponent - Componenteo que originou o evento.
	 */
	function formatCep(aEvent, aComponent) {
		
		var tecla = aEvent.keyCode;

		if ((tecla >= 48 && tecla <= 57) || tecla == 0) {

			var numero = aComponent.value;

			var tamanho = numero.length;

			if (tamanho > 4){
				var element = numero.substring(5,6);
				if( element != "-" ){
					numero = numero.substring(0,5) + "-" + numero.substring(5);  
					aComponent.value = numero;
				}
			} 
			return true;
		} else {
			return false;
		}
		
	}
	
	/**
	 * Formata a string fornecida como telefone.
	 *
	 * form - Nome do formulario
	 * event - Evento onKeyPress
	 * compName - Nome do componente
	 */
	function formatTelefone(form, event, compName) {
		
		var tecla = event.keyCode;

		if ((tecla >= 48 && tecla <= 57) || tecla == 0) {

			var component = getComponent(form, compName);

			var numero = component.value;

			var tamanho = numero.length;

			if (tamanho >= 0){
				var element = numero.substring(0,1);
				if( element != "(" ){
					numero = numero.substring(0,1) + "(" + numero.substring(1);  
					component.value = numero;
				}
			} 
			
			if (tamanho > 2){
				var element = numero.substring(3,4);
				if( element != ")" ){
					numero = numero.substring(0,4) + ")" + numero.substring(4);  
					component.value = numero;
				}
			} 

			if (tamanho > 7){
				var element = numero.substring(8,9);
				if( element != "-" ){
					numero = numero.substring(0,8) + "-" + numero.substring(8);  
					component.value = numero;
				}
			}
			
			return true;
		
		} else {

			return false;

		}

	}
	
	/**
	 * Realiza a validacao de um determinado endereco de e-mail.
	 *
	 * email - Valor a ser avaliado
	 */
	function validateEmail(email){

		var reEmail = /^[\w-]+(\.[\w-]+)*@(([A-Za-z\d][A-Za-z\d-]{0,61}[A-Za-z\d]\.)+[A-Za-z]{2,6}|\[\d{1,3}(\.\d{1,3}){3}\])$/;

		if (reEmail.test(email)) {
			return true;
		} else if (email != null && email != "") {
			return false;
		}
	}
	
	
	
	/**
	 * FUNCAO RESPONSAVEL POR SUBSTITUIR TODOS OS ELEMENTOS ENCONTRADOS EM UMA DETERMINADA 
	 * STRING POR OUTRO ELEMENTO
	 */
	function replaceAll( str, from, to ){
    	var idx = str.indexOf( from );
        while ( idx > -1 ) {str = str.replace( from, to ); idx = str.indexOf( from );}
        return str;
    } 
	
	/**
	 * METODOS RESPONS?VEIS PELO PROCESSAMOS DE SE COLOCAR UM AUTO-COMPLETE NO INPUT TEXT
	 * Attributos a serem inseridos no input para ativas a busca:

		style="width:150px;height:20px;"
		action="<c:url value="/GS/Usuario/PesquisaSelecao"/>"
		property-key="codigo"
		property-label="nome"
		property-table="codigo;nome"
		input-key="codigo"
		onKeyDown="JavaScript:agendarPesquisa(this)"	 
	 */

	var MENU_AUTO_POP_UP 		= "menu-popup";
	var NOME_ULTIMA_PESQUISA 	= null;
	var MIN_NUM_CARACTERES 		= 1;
	var COUNT 					= 0;
	var MAX_DIV_POP_UP_HEIGHT	= 120;
	var NUM_MAX_ELEMENTO		= 200;
	var STYLE_DESTAQUE			= 'grid_style_item_destaque';
	var STYLE_NORMAL			= 'grid_style_item1';

	function setMinNumCaracteresInAgendarPesquisa( numMin ){
		MIN_NUM_CARACTERES = numMin;
	}
	
	function agendarPesquisa( aComponent, aEvent ){
		var menu = document.getElementById(MENU_AUTO_POP_UP);

		if( aEvent.keyCode == 17 || aEvent.keyCode == 18){		
			return;

		}else if( aEvent.keyCode == 27 ){ // click no ESC
			hiddenAutoPopUp();
			return;
		
		}else if( aEvent.keyCode == 38 ){ // UP
			if( menu.style.visibility == 'visible' ){
				var marcarAnterior = false;
				var numRowAnterior = null;
				for( y = 0 ; y < NUM_MAX_ELEMENTO; y++){
					var row = document.getElementById('LINHA_POP_UP_' + y );
					if( row ){
						if( row.className == STYLE_DESTAQUE ){
							setTimeout(row.getAttribute('onMouseOut'),0);
							marcarAnterior  = true;
							numRowAnterior  = (y - 1);
							break;
						}
					}else{
						break;
					}
				}
				
				if( marcarAnterior ){
					var row = document.getElementById('LINHA_POP_UP_' + (numRowAnterior));
					if( row ){
						setTimeout(row.getAttribute('onMouseOver'),0);
					}
				}else{
					var row = document.getElementById('LINHA_POP_UP_' + (y - 1));
					if( row ){
						setTimeout(row.getAttribute('onMouseOver'),0);
					}
				}
			}
			return;
		
		}else if( aEvent.keyCode == 40 ){ // DOWN
			if( menu.style.visibility == 'visible' ){
				var marcarProxima = false;
				for( y = 0 ; y < NUM_MAX_ELEMENTO; y++){
					var row = document.getElementById('LINHA_POP_UP_' + y );
					if( row ){
						if( marcarProxima ){
							setTimeout(row.getAttribute('onMouseOver'),0);
							break;
						}
						if( row.className == STYLE_DESTAQUE ){
							setTimeout(row.getAttribute('onMouseOut'),0);
							marcarProxima  = true;
						}
					}else{
						break;
					}
				}
				if( !marcarProxima ){
					var row = document.getElementById('LINHA_POP_UP_0');
					if( row ){
						setTimeout(row.getAttribute('onMouseOver'),0);
					}
				}
			}
			return;
		
		}else if( aEvent.keyCode == 9 || aEvent.keyCode == 13){ // TAB
			if( menu.style.visibility == 'visible' ){
				for( y = 0 ; y < NUM_MAX_ELEMENTO; y++){
					var row = document.getElementById('LINHA_POP_UP_' + y );
					if( row ){
						if( row.className == STYLE_DESTAQUE ){
							setTimeout(row.getAttribute('onClick'),0);
							break;
						}
					}else{
						break;
					}
				}				
			}
			return;
		}
		
		menu  = showAutoPopUp(aComponent.id);
		var value = aComponent.value;
		if( value.length > MIN_NUM_CARACTERES ) {
			if( NOME_ULTIMA_PESQUISA == value ){
				return;
			}else{
				clearTimeout(COUNT);
				menu.innerHTML = "Carregando...";
				var method = 'pesquisarPopUp(\'' + aComponent.id + '\');';
				COUNT = setTimeout(method,500);																			
			}
		}else{
			clearTimeout(COUNT);
			hiddenAutoPopUp();
			NOME_ULTIMA_PESQUISA = null;
		}
		
		menu.style.marginTop = "8px";
		
		return;
	}		

	function pesquisarPopUp(aComponentId) {

		var field		 	  = document.getElementById(aComponentId);	
		var menu			  = showAutoPopUp(aComponentId);

		var action		  	  = field.getAttribute("action");
		var property_key	  = field.getAttribute("property-key");
		var property_label	  = field.getAttribute("property-label");
		var property_table	  = field.getAttribute("property-table");
		var input_key	  	  = field.getAttribute("input-key");
		
		var inputKey 		  = null;
		if( input_key  ){
			inputKey = document.getElementById(input_key);
		}
		
		var arrayProperties   = new Array();
		arrayProperties[arrayProperties.length] = property_key;
		arrayProperties[arrayProperties.length] = property_label;		

		if( property_table ){
			var arrayPropertyTable = property_table.split(';');
			for( i = 0 ; i < arrayPropertyTable.length ; i++ ){
				arrayProperties[arrayProperties.length] = arrayPropertyTable[i];
			}
		}		

		if( trim(field.value).length == 0 ){
			if( inputKey ){
				inputKey.value = '';	
			}
			hiddenAutoPopUp();
			return;
		}

		var array = sendFormToAction( field.form.name, action, arrayProperties);

		if( array ){
			
			if( array.length > NUM_MAX_ELEMENTO ){
				var msg  = "<font size='2'><div align='center'>Foram obtidas mais de 200 op&ccedil;&otilde;es para ";
					msg += "os crit&eacute;rios de sele&ccedil;&atilde;o especificados.";
					msg += "Favor selecionar um crit&eacute;rio de sele&ccedil;&atilde;o mais restritivo.</div><font>"
				menu.innerHTML = msg;
				if( inputKey ){
					inputKey.value = '';	
				}
				agendarHiddenAutoPopUp();
				return;
			}
			
			if( array.length == 0 ){
				menu.style.height  = "60px";
				menu.innerHTML = "<font size='2' color='red'><div align='center'>Nenhum registro <br>foi encontrado!</div><font>";
				if( inputKey ){
					inputKey.value = '';	
				}
				agendarHiddenAutoPopUp();
				return;
				
			}else if( ( ( array.length + 1 ) * 20 ) < MAX_DIV_POP_UP_HEIGHT ){
				menu.style.height  = ( ( array.length + 1 ) * 20) + "px";
			}
			
			var arrayTable = property_table.split(';');
			var url = "<table width='100%' border='0' cellpadding='0' cellspacing='2' bgcolor='#CCCCCC'>";
			for( y = 0 ; y < array.length ; y++ ){
				url += "<tr id='LINHA_POP_UP_";
				url += y;
				url += "' class='grid_style_item1' style='cursor:pointer;padding-left:3px;padding-right:10px;height:19px;' ";
				url += " onMouseOut=\"JavaScript:destacar('LINHA_POP_UP_";
				url += y;
				url += "',false)\"";
				url += " onMouseOver=\"JavaScript:destacar('LINHA_POP_UP_";
				url += y;
				url += "',true)\"";
				url += " onClick='JavaScript:selecionarAutoPopUp(\"";

				url += array[y][property_key];
				url += "\",\"";
				url += array[y][property_label];
				url += "\",\"";
				url += aComponentId;
				url += "\")'>";
				
				for( w = 0; w < arrayTable.length; w++){
					var valueColumn = array[y][arrayTable[w]];
					url += "<td nowrap>";
					if( valueColumn != 'null' ){
						url += valueColumn;
					}
					url += "</td>";
				}
		      	url += "</tr>"
			}
			url += "</table>"
			menu.innerHTML = url;
		}
		return;
	}


	function destacar( aIdLinha, aDestaque ){
		document.getElementById(aIdLinha).className = (aDestaque ? STYLE_DESTAQUE : STYLE_NORMAL);
		return;
	}

	function selecionarAutoPopUp(aKey,aLabel,aComponentLabel){
		hiddenAutoPopUp();

		var component = document.getElementById(aComponentLabel);
		component.value = aLabel;
		
		var inputKey = component.getAttribute('input-key')
		if( inputKey ){
			var compKey = document.getElementById(inputKey);
			if( compKey ){
				compKey.value = aKey;
			}
		}

		var functionSelect = component.getAttribute('onSelectedPoUp');
		if( functionSelect ){
			setTimeout(functionSelect,0);
		}
		
		try{
			component.focus();
		}catch(e){}		

		return;
	}

	function showAutoPopUp(aComponentId){
		var menu			  = document.getElementById(MENU_AUTO_POP_UP);
		var field		 	  = document.getElementById(aComponentId);	
		menu.style.top		  = (getElementY(field) + parseInt(field.style.height)) + "px";
		menu.style.left		  = (getElementX(field) ) + "px";
		menu.style.width	  = parseInt(field.style.width) + "px";
		menu.style.height	  = MAX_DIV_POP_UP_HEIGHT + "px";
		menu.style.visibility = "visible";
		return menu;
	}

	function hiddenAutoPopUp(){
		var menu = document.getElementById(MENU_AUTO_POP_UP);
		menu.style.width  = '0px';
		menu.style.height = '0px';
		menu.style.visibility = 'hidden';
		return;	
	}
	
	function agendarHiddenAutoPopUp(){
		var methodCall = 'document.getElementById(\'' + MENU_AUTO_POP_UP + '\').style.visibility = \'hidden\'';
		setTimeout(methodCall,4000);
		return;	
	}	

	function getElementY(element){
		var targetTop = 0;
		if (element.offsetParent) {
			while (element.offsetParent) {
				targetTop += element.offsetTop;
				element = element.offsetParent;
			}
		} else if (element.y) {
			targetTop += element.y;
		}
		return targetTop;
	}


	function getElementX(element){
		var targetLeft = 0;
		if (element.offsetParent) {
			while (element.offsetParent) {
				targetLeft += element.offsetLeft;
				element = element.offsetParent;
			}
		} else if (element.x) {
			targetLeft += element.x;
		}
		return targetLeft;
	}
	
	 document.write("<div style='position:absolute;top:170px;left:140px;background-color:#CCCCCC;visibility:hidden;overflow:scroll;z-index:999;' id='menu-popup'></div>");


	///////////////////////////////////////////////////////////////////////////////////////////////////
	//  M?TODOS QUE S?O CHAMADOS NO FINAL DO SCRIPT PARA A EXECU??O DE CONFIGURA??ES
	//  PADR?ES
	///////////////////////////////////////////////////////////////////////////////////////////////////
	configInputForm();
	///////////////////////////////////////////////////////////////////////////////////////////////////