//########### objetos com expressao regular para validação de campos e tipos ####

var valida = new Object();

valida = { 
	
	regEmail : [],
	EmailErro : "O e-mail em formato invalido",
	
	regTime : [ ],
	TimeErro : "Este não é um formato de Tempo válido",
	
	regData : [ ],
	DataErro : "Este não é um formato de Data válido",
	
	regMoeda : [ ],
	MoedaErro : "Formato de Moeda Invalido",
	
	regDigito : [ ],
	DigitoErro : "Este não é um formato de Digito Valido",
	
	regDecimal : [ ],
	DecimalErro : "É necessario um formado decimal, EX: 0.00 "	,
	
	regNumero : [ ],
	NumeroErro : "Apenas é aceito numeros!",
	
	CpfErro : "CPF Invalido",
	CnpjErro : "CNPJ invalido",
	CepErro : "Formato CEP Errado"
}



/** Expressoes regulares tiradas , http://www.mhavila.com.br/topicos/web/valform.html **/

/* 1. Livre — ReEmail1 aceita nome-local com todos os caracteres permitidos na RFC 2822: [\w!#$%&'*+/=?^`{|}~-]; e o domínio tem definição bem livre, por nome basicamente fixando apenas que o TLD deve ter entre 2 e 6 caracteres: [A-Za-z]{2,6}; ou por número IP entre colchetes: \[\d{1,3}(\.\d{1,3}){3}\].
   2. Compacto — ReEmail2 limita os caracteres permitidos no nome-local de forma mais compacta e restritiva, porém cobre os casos mais comuns. Aceita como nome-local uma ou mais palavras separadas por ponto ([\w-]+(\.[\w-]+)*), onde cada palavra é definida por [\w-]+ permitindo assim letra, dígito, sublinhado e hífen. Também limita o tamanho de nomes de domínio entre 2 e 63 caracteres apenas com letras, dígitos, sublinhado e hífen: [\w-]{2,63}.
   3. Restrito — ReEmail3 é uma variação da ReEmail2, mas força nomes de domínio entre 2 e 63 caracteres, deixa de usar a seqüência \w para não permitir o sublinhado e garante que não há hífen nem na primeira nem na última posição, conforme RFC 1034/1035. O resultado é o seguinte para representar um nome de domínio: [A-Za-z\d][A-Za-z\d-]{0,61}[A-Za-z\d].
*/

valida.regEmail[1] = /^[\w!#$%&'*+\/=?^`{|}~-]+(\.[\w!#$%&'*+\/=?^`{|}~-]+)*@(([\w-]+\.)+[A-Za-z]{2,6}|\[\d{1,3}(\.\d{1,3}){3}\])$/;
valida.regEmail[2] = /^[\w-]+(\.[\w-]+)*@(([\w-]{2,63}\.)+[A-Za-z]{2,6}|\[\d{1,3}(\.\d{1,3}){3}\])$/;
valida.regEmail[3] = /^[\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}\])$/;

/*
   1. Horário HH:MM simples — aceita dois pares de dois dígitos separados por dois-pontos (:); pode ser usado para hora:minutos ou ainda para minutos:segundos, porém não valida as faixas de valor válidos para os dígitos, aceitando assim qualquer valor entre 00 e 99.
   2. Horário HH:MM 24h — aceita horas na faixa 00-23 e minutos 00-59, separados por dois-pontos.
   3. Horário HH:MM 12h — aceita horas na faixa 01-12 e minutos 00-59, separados por dois-pontos.
   4. Tempo horas:MM:SS — aceita qualquer quantidade de horas (0 ou mais, um ou mais dígitos), minutos 00-59 e segundos 00-59, todos separados por dois-pontos.
   5. Tempo horas:MM:SS.mili — similar ao anterior, porém inclui 3 dígitos finais para milisegundos 000-999, separados dos anteriores por ponto (.).
*/

valida.regTime[1] = /^\d{2}:\d{2}$/;
valida.regTime[2] = /^([0-1]\d|2[0-3]):[0-5]\d$/;
valida.regTime[3] = /^(0[1-9]|1[0-2]):[0-5]\d$/;
valida.regTime[4] = /^\d+:[0-5]\d:[0-5]\d$/;
valida.regTime[5] = /^\d+:[0-5]\d:[0-5]\.\d{3}\d$/;


/* 1. Simples — valida apenas o uso de dígitos, nas posições e quantidade certas: 1 a 2 dígitos para dia e para mês, 1 a 4 dígitos para ano.
   2. Média — testa os dígitos possíveis em cada posição: o primeiro dígito do dia, se houver, deve ser de 0 a 3 ([0-3]?\d); o primeiro dígito do mês, se houver, deve ser 0 ou 1 ([01]?\d); passamos a aceitar apenas 2 ou 4 dígitos para o ano.
   3. Avançada — garante as faixas de valores corretas para dias 1 a 31 ((0?[1-9]|[12]\d|3[01])) e meses 1 a 12 ((0?[1-9]|1[0-2])). E aqui optamos por forçar os 2 primeiros dígitos do ano (correspondentes ao século), quando fornecidos, a serem 19 ou 20 ((19|20)?\d{2}).
   4. Completa — valida os dias permitidos de acordo com o mês. Para este último, foram criados três grupos alternativos de pares dia/mês:
          * Os dias 1 a 29 ((0?[1-9]|[12]\d)) são aceitos em todos os meses (1 a 12): (0?[1-9]|1[0-2])
          * Dia 30 é válido em todos os meses, exceto fevereiro (02): (0?[13-9]|1[0-2])
          * Dia 31 é permitido em janeiro (01), março (03), maio (05), julho (07), agosto (08), outubro (10) e dezembro (12): (0?[13578]|1[02]).
   5. Tradicional — data no formato DD/MM/AAAA, basicamente é a data Completa, porém sem a opcionalidade do zero à esquerda no dia ou mês menor que 10 e sem a opcionalidade e verificação de século no ano, aceitando qualquer seqüência de 4 dígitos (\d{4}) como ano.
*/

valida.regData[1] = /^\d{1,2}\/\d{1,2}\/\d{1,4}$/;
valida.regData[2] = /^[0-3]?\d\/[01]?\d\/(\d{2}|\d{4})$/;
valida.regData[3] = /^(0?[1-9]|[12]\d|3[01])\/(0?[1-9]|1[0-2])\/(19|20)?\d{2}$/;
valida.regData[4] = /^((0?[1-9]|[12]\d)\/(0?[1-9]|1[0-2])|30\/(0?[13-9]|1[0-2])|31\/(0?[13578]|1[02]))\/(19|20)?\d{2}$/;
valida.regData[5] = /^((0[1-9]|[12]\d)\/(0[1-9]|1[0-2])|30\/(0[13-9]|1[0-2])|31\/(0[13578]|1[02]))\/\d{4}$/;


valida.regMoeda = /^\d{1,3}(\.\d{3})*\,\d{2}$/;
//valida.regMoeda = /^\d+\,\d{2}$/;

valida.regDigito = /^\d+$/;

valida.regDecimal['Pt'] = /^[+-]?((\d+|\d{1,3}(\.\d{3})+)(\,\d*)?|\,\d+)$/;
valida.regDecimal['En'] = /^[+-]?((\d+|\d{1,3}(\,\d{3})+)(\.\d*)?|\.\d+)$/;

valida.regNumero = /[~a-zA-Z_]/;

valida.regCep = /^[0-9]{5}-[0-9]{3}$/;

valida.Email = function( EmailString , Nivel ){
	return EmailString.trim().match( this.regEmail[Nivel] );	
}

valida.Time = function( TimeString , Nivel ){
	return TimeString.trim().match( this.regTime[Nivel] );	
}

valida.Data = function( DataString , Nivel ){
	return DataString.trim().match( this.regData[Nivel] );	
}

valida.Decimal = function( DecimalString , Lingua ){
	return DecimalString.trim().match( this.regDecimal[Lingua] );	
}

valida.Digito = function( DigitoString ){
	return DigitoString.trim().match( this.regDigito );	
}

valida.Moeda = function( MoedaString ){
	return MoedaString.trim().match( this.regMoeda );	
}

valida.Numero = function( NumeroString )
{	
	
	if(NumeroString == ""){
		return false;	
	}
	
	return !NumeroString.trim().match( this.regNumero );
}

valida.CnpjCpf = function( Campo , tipo )
{
	var val = Campo.value;
	var base = val.substring(0, val.length-2);
	
	if ( tipo == "CNPJ" ){
		return isCnpj(val);
	}else{
		return isCpf(val);
	
	}
	return false;
}

valida.formatCpfCnpj = function( Campo , tipo )
{	
	if(tipo=="CPF"){
		Campo.value = formatCpfCnpj(Campo.value, true);
	}else{
		Campo.value = formatCpfCnpj(Campo.value, true, true);	
	}
}

valida.CEP = function( CepString ){
	return CepString.match( valida.regCep );
}


valida.DataNascimento = function( DataNascimento ){
	reNasci  = /(\d{2})(\d{2})(\d{4})$/;	
	Data = unformatNumber(DataNascimento.value);	
	DataNascimento.value = Data.lpad(8,'0').replace(reNasci, "$1/$2/$3");
}

valida.formatCEP = function( Campo ){
	Campo.value = Campo.value.replace( /(\d{5})$/ , "$1-" );
}

//############## FUNCOES DE CPF E CNPJ ##############################
/**
 * @author Márcio d'Ávila
 * @version 1.02, 2004-2007
 *
 * Este script foi retirado de:
 * http://www.mhavila.com.br/topicos/web/cpf_cnpj.html
 *
 * Licenciado sob os termos da licença Creative Commons,
 * Atribuição - Compartilhamento pela mesma licença 2.5:
 * http://creativecommons.org/licenses/by-sa/2.5/br/
 * Qualquer outra forma de uso requer autorização expressa do autor.
 *
 * PROTÓTIPOS:
 * método String.lpad(int pSize, char pCharPad)
 * método String.trim()
 *
 * String unformatNumber(String pNum)
 * String formatCpfCnpj(String pCpfCnpj, boolean pUseSepar, boolean pIsCnpj)
 * String dvCpfCnpj(String pEfetivo, boolean pIsCnpj)
 * boolean isCpf(String pCpf)
 * boolean isCnpj(String pCnpj)
 * boolean isCpfCnpj(String pCpfCnpj)
 */


NUM_DIGITOS_CPF  = 11;
NUM_DIGITOS_CNPJ = 14;
NUM_DGT_CNPJ_BASE = 8;


/**

 * Adiciona método lpad() à classe String.
 * Preenche a String à esquerda com o caractere fornecido,
 * até que ela atinja o tamanho especificado.
 */
String.prototype.lpad = function(pSize, pCharPad)
{
	var str = this;
	var dif = pSize - str.length;
	var ch = String(pCharPad).charAt(0);
	for (; dif>0; dif--) str = ch + str;
	return (str);
} //String.lpad



/**
 * Adiciona método trim() à classe String.
 * Elimina brancos no início e fim da String.
 */
String.prototype.trim = function()
{
	return this.replace(/^\s*/, "").replace(/\s*$/, "");
} //String.trim


/**
 * Elimina caracteres de formatação e zeros à esquerda da string
 * de número fornecida.
 * @param String pNum
 * 	String de número fornecida para ser desformatada.
 * @return String de número desformatada.
 */
function unformatNumber(pNum)
{
	return String(pNum).replace(/\D/g, "").replace(/^0+/, "");
} //unformatNumber


/**
 * Formata a string fornecida como CNPJ ou CPF, adicionando zeros
 * à esquerda se necessário e caracteres separadores, conforme solicitado.
 * @param String pCpfCnpj
 * 	String fornecida para ser formatada.
 * @param boolean pUseSepar
 * 	Indica se devem ser usados caracteres separadores (. - /).
 * @param boolean pIsCnpj
 * 	Indica se a string fornecida é um CNPJ.
 * 	Caso contrário, é CPF. Default = false (CPF).
 * @return String de CPF ou CNPJ devidamente formatada.
 */
function formatCpfCnpj(pCpfCnpj, pUseSepar, pIsCnpj)
{
	if (pIsCnpj==null) pIsCnpj = false;
	if (pUseSepar==null) pUseSepar = true;
	var maxDigitos = pIsCnpj? NUM_DIGITOS_CNPJ: NUM_DIGITOS_CPF;
	var numero = unformatNumber(pCpfCnpj);

	numero = numero.lpad(maxDigitos, '0');
	if (!pUseSepar) return numero;

	if (pIsCnpj)
	{
		reCnpj = /(\d{2})(\d{3})(\d{3})(\d{4})(\d{2})$/;
		numero = numero.replace(reCnpj, "$1.$2.$3/$4-$5");
	}
	else
	{
		reCpf  = /(\d{3})(\d{3})(\d{3})(\d{2})$/;
		
		numero = numero.replace(reCpf, "$1.$2.$3-$4");	
		
	}
	return numero;
} //formatCpfCnpj


/**
 * Calcula os 2 dígitos verificadores para o número-efetivo pEfetivo de
 * CNPJ (12 dígitos) ou CPF (9 dígitos) fornecido. pIsCnpj é booleano e
 * informa se o número-efetivo fornecido é CNPJ (default = false).
 * @param String pEfetivo
 * 	String do número-efetivo (SEM dígitos verificadores) de CNPJ ou CPF.
 * @param boolean pIsCnpj
 * 	Indica se a string fornecida é de um CNPJ.
 * 	Caso contrário, é CPF. Default = false (CPF).
 * @return String com os dois dígitos verificadores.
 */
function dvCpfCnpj(pEfetivo, pIsCnpj)
{
	if (pIsCnpj==null) pIsCnpj = false;
	var i, j, k, soma, dv;
	var cicloPeso = pIsCnpj? NUM_DGT_CNPJ_BASE: NUM_DIGITOS_CPF;
	var maxDigitos = pIsCnpj? NUM_DIGITOS_CNPJ: NUM_DIGITOS_CPF;
	var calculado = formatCpfCnpj(pEfetivo, false, pIsCnpj);
	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 pCpf fornecida é um CPF válido.
 * Qualquer formatação que não seja algarismos é desconsiderada.
 * @param String pCpf
 * 	String fornecida para ser testada.
 * @return <code>true</code> se a String fornecida for um CPF válido.
 */
function isCpf(pCpf)
{
	var numero = formatCpfCnpj(pCpf, false, false);
	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; algUnico && i<NUM_DIGITOS_CPF; i++)
	{
		algUnico = (numero.charAt(i-1) == numero.charAt(i));
	}
	return (!algUnico);
} //isCpf


/**
 * Testa se a String pCnpj fornecida é um CNPJ válido.
 * Qualquer formatação que não seja algarismos é desconsiderada.
 * @param String pCnpj
 * 	String fornecida para ser testada.
 * @return <code>true</code> se a String fornecida for um CNPJ válido.
 */
function isCnpj(pCnpj)
{
	var numero = formatCpfCnpj(pCnpj, false, true);
	var base = numero.substring(0, NUM_DGT_CNPJ_BASE);
	var ordem = numero.substring(NUM_DGT_CNPJ_BASE, 12);
	var digitos = dvCpfCnpj(base + ordem, true);
	var algUnico;

	// 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.
	 */
	algUnico = numero.charAt(0) != '0';
	for (i=1; algUnico && i<NUM_DGT_CNPJ_BASE; i++)
	{
		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


/**
 * Testa se a String pCpfCnpj fornecida é um CPF ou CNPJ válido.
 * Se a String tiver uma quantidade de dígitos igual ou inferior
 * a 11, valida como CPF. Se for maior que 11, valida como CNPJ.
 * Qualquer formatação que não seja algarismos é desconsiderada.
 * @param String pCpfCnpj
 * 	String fornecida para ser testada.
 * @return <code>true</code> se a String fornecida for um CPF ou CNPJ válido.
 */
function isCpfCnpj(pCpfCnpj)
{
	var numero = pCpfCnpj.replace(/\D/g, "");
	if (numero.length > NUM_DIGITOS_CPF)
		return isCnpj(pCpfCnpj)
	else
		return isCpf(pCpfCnpj);
} //isCpfCnpj


function apenas_numero(evento)
{
	var keypress = evento.keyCode ? evento.keyCode : evento.which ? evento.which : evento.charCode;
	
	if(keypress == 8 || keypress == 37 || keypress == 39 || keypress == 46)
	{
		return true;	
	}
	
	if((keypress > 47 && keypress < 58))
	{
		return true;
	}
	
	return false;
}


oCep = new Object();
oCep = {	
	get : function(ID){
		return document.getElementById(ID);
	},	
	//Funcao que retorna o cep em ajax
	//realizaTrocaHTMLEndereco tem que ser implementada na pagina
	getEndereco : function ( Cep )
	{	
		Cep = Cep.replace("-","");
	
		var status = AjaxRequest.get(
		{
			'onLoading'  : function(req1) { "" },
			'url'        : 'ajax.php',
			'parameters' : { 'getCep' : 'true' , 'cep' : Cep},
			'onSuccess'  : function(req) { 
				oCep.TrocaEndereco(unescape(req.responseText));
			}}
		);		
	},
	TrocaEndereco : function(){}
}



//########### FUNCOES DE VALIDACAO DO FORMULARIO, ESTA FUNCAO PROCURA NO FORMULARIO OS CAMPOS ########


 var erro = 0;
 var inputFocus = null;
 var atributo = "valida";
 var x=0;
 var naoMsg = 0;
 var rm;
 rm = [];
 
 
function ErroCampo(Campo , Erro){
	erro = 1;
	Campo.setAttribute('class', 'formulario_erro');
	Campo.setAttribute('className', 'formulario_erro');
	if($x2 == 0){
	   inputFocus =  Campo;
	   $x2++;
    }	
	
	if(Erro!="" ){
		
		d=document.createElement('div');
		d.setAttribute('class', 'msg_erro_flutuante');
		d.setAttribute('className', 'msg_erro_flutuante');
		d.appendChild(document.createTextNode(Erro));
		Campo.parentNode.appendChild( d );
		
		//document.body.style = "background-color: #0000";		
		/*document.
		getElementsByTagName("table").
		item(0).style = "background-color: #000000";*/
		
		rm.push( [Campo , d ] );
		setTimeout(function(){			
			for( x in rm ){
				if(rm[x]){
					rm[x][0].parentNode.removeChild(rm[x][1]);
					rm[x] = false;
				}
			}					
			//Campo.parentNode.removeChild(d);
		},8000);
	}
	
	return true;
}


function checkForm( Formulario ){	

	var inputs = Formulario;	
	
	$x=0;
	$x2=0;		
	
    while( $x < inputs.length )
	{		
       if( inputs[$x].getAttribute( atributo ) != null && inputs[$x].getAttribute( atributo ) != "" )
	   {	
		   
       	   Campo = inputs[$x];
		   sCampo = inputs[$x].getAttribute( atributo );		
		   sCampo = sCampo.split(",");
		   Nivel = sCampo[1];
		   sCampo = sCampo[0];
			
		   switch( sCampo ){
			   
				case "moeda":
				
					if(!valida.Moeda( Campo.value )){
					   ErroCampo( Campo , valida.MoedaErro );					   
					}
				
				break;
				case "tempo":
					if(!valida.Time( Campo.value , Nivel )){
					   
					   ErroCampo( Campo , valida.TimeErro );
					   	
					}
				break;
				case "data":
					if(!valida.Data( Campo.value , Nivel )){
					   
					   ErroCampo( Campo , valida.DataErro );
					   	
					}
				break;
				case "email":
					
					if( !valida.Email( Campo.value , Nivel ) ){
					   ErroCampo( Campo , valida.EmailErro );					   
					}					
				break;
				case "digito":
					if(!valida.Digito( Campo.value )){
						ErroCampo( Campo , valida.DigitoErro );					   	
					}
				break;
				case "numero":
				
					if(!valida.Numero( Campo.value )){
					   ErroCampo( Campo , valida.NumeroErro );
					}
				break;
				case "texto":
					
					if(Campo.value == "" ){
					  ErroCampo( Campo , 'Campo(s) obrigatorio(s)!' );					 
					}
					
				break;
				case "cpf":
										
					if( !valida.CnpjCpf( Campo , "CPF") ){						
					   ErroCampo( Campo , valida.CpfErro );
					}
					
				break;
				case "cnpj":										
					if( !valida.CnpjCpf( Campo , "CNPJ") ){
						ErroCampo( Campo , valida.CnpjErro );							
					}					
				break;
				case "cep":										
					if( !valida.CEP( Campo.value ) ){
						ErroCampo( Campo , valida.CepErro );	
					}					
				break;
			}
       }
        $x++;
    }
	return;	
}



function validaFormulario( Formulario )
{
	checkForm( Formulario );
	
	if(erro == 1  ){
    	inputFocus.focus();
		erro=0;
		return false;
	}	
    return true;    
}



//############# funcao que carrega no onload ##########


function IniciaValidacao( Formulario ){

	var InputsForm = Formulario;
	
	$x=0;
	$x2=0;		

    while( $x < InputsForm.length )
	{
			
       if( InputsForm[$x].getAttribute( atributo ) != null && InputsForm[$x].getAttribute( atributo ) != "" )
	   {		   
       	   Campo = InputsForm[$x];
		   sCampo = InputsForm[$x].getAttribute( atributo );		
		   sCampo = sCampo.split(",");
		   Nivel = sCampo[1];
		   sCampo = sCampo[0];
		   
		   switch( sCampo ){
			   case 'cpf':			   	
				Campo.onkeyup = function(){		
					valida.formatCpfCnpj( this , "CPF" );
				}
				
			   break;
			   case 'cnpj':
			   	Campo.onkeyup = function(){
					valida.CnpjCpf(this , "CNPJ")
				}
			   break;
			   case 'data':
			   	Campo.onkeyup = function(){
						valida.DataNascimento(this)
				}			   	
			   break;
			   case 'cep':
			   	Campo.onkeyup = function(){
					valida.formatCEP(this)
				}
			   break;
			   case 'numero':
				   Campo.onkeyup = function(){
						apenas_numero(this)
					}			   	
			   break;
			   case 'moeda':
			   	
				Campo.onkeydown = function(){
					
						//Formata número tipo moeda usando o evento onKeyDown
	
						campo = this;
						tammax = 20;
						teclapres = event;
						decimal = 2;
						
						var tecla = teclapres.keyCode;
						vr = Limpar(campo.value,"0123456789");
						tam = vr.length;
						dec=decimal
						
						if (tam < tammax && tecla != 8){ tam = vr.length + 1 ; }
						
						if (tecla == 8 )
						{ tam = tam - 1 ; }
						
						if ( tecla == 8 || tecla >= 48 && tecla <= 57 || tecla >= 96 && tecla <= 105 )
						{
							if ( tam <= dec )
							{ campo.value = vr ; }
							
							if ( (tam > dec) && (tam <= 5) ){
								campo.value = vr.substr( 0, tam - 2 ) + "," + vr.substr( tam - dec, tam ) ; }
							if ( (tam >= 6) && (tam <= 8) )
							{
								campo.value = vr.substr( 0, tam - 5 ) + "." + vr.substr( tam - 5, 3 ) + "," + vr.substr( tam - dec, tam ) ; 
							}
							
							if ( (tam >= 9) && (tam <= 11) )
							{
								campo.value = vr.substr( 0, tam - 8 ) + "." + vr.substr( tam - 8, 3 ) + "." + vr.substr( tam - 5, 3 ) + "," + vr.substr( tam - dec, tam ) ; 
							}
							
							if ( (tam >= 12) && (tam <= 14) )
							{
								campo.value = vr.substr( 0, tam - 11 ) + "." + vr.substr( tam - 11, 3 ) + "." + vr.substr( tam - 8, 3 ) + "." + vr.substr( tam - 5, 3 ) + "," + vr.substr( tam - dec, tam ) ; 
							}
							
							if ( (tam >= 15) && (tam <= 17) ){
								campo.value = vr.substr( 0, tam - 14 ) + "." + vr.substr( tam - 14, 3 ) + "." + vr.substr( tam - 11, 3 ) + "." + vr.substr( tam - 8, 3 ) + "." + vr.substr( tam - 5, 3 ) + "," + vr.substr( tam - 2, tam ) ;
							}							
						}
				}
				
			   break;
		   }
	   }	   
	   
	   $x++;
	   
	}
}




////////////////////////////////////////////////////////////
	function Limpar(valor, validos) {
		// retira caracteres invalidos da string
		var result = "";
		var aux;
		for (var i=0; i < valor.length; i++) {
			aux = validos.indexOf(valor.substring(i, i+1));
			if (aux>=0) {
				result += aux;
			}
		}
		return result;
	}
	



var Onload = new Object();

Onload = {
	f : [],
	add : function(f){
		this.f.push(f)
	}
}