/*
function verificaNum(campo, event)
function mascaraVlr(campo, qtdDecimal) 
function trataKeyPressVlr(campo, event, qtdDecimal) 
function trataBackSpaceVlr(campo, event, qtdDecimal)
function retornaVlrObj(campo, qtdDecimal) 
function retornaVlr(valor)
function iniciaVlr(qtdDecimal)
function trataLostFocusObj(campo, qtdDecimal) 
function trataLostFocusVlr(valor, qtdDecimal) 

function trim (str)

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)
*/



/* EXPRESSÕES REGULARES 
   
ex.>  http://www.mhavila.com.br/topicos/web/valform.html
Valida o texto do email: reEmail1.test(document.formrh.ema.value) retorna true ou false



validação de entrada de um número inteiro não-negativo sem sinal, ou seja, apenas dígitos
reDigits = /^\d+$/;

validação de números reais em ponto flutuante (decimal). As expressões definidas permitem, como opcionais: sinal, separadores de milhar e casas decimais. Não é tratada neste exemplo a notação científica (com expoente).
reDecimalPt = /^[+-]?((\d+|\d{1,3}(\.\d{3})+)(\,\d*)?|\,\d+)$/;
reDecimalEn = /^[+-]?((\d+|\d{1,3}(\,\d{3})+)(\.\d*)?|\.\d+)$/;

validação de números decimais: valores financeiros
reMoeda = /^\d{1,3}(\.\d{3})*\,\d{2}$/;

validar uma data
reDate1 = /^\d{1,2}\/\d{1,2}\/\d{1,4}$/;
reDate2 = /^[0-3]?\d\/[01]?\d\/(\d{2}|\d{4})$/;
reDate3 = /^(0?[1-9]|[12]\d|3[01])\/(0?[1-9]|1[0-2])\/(19|20)?\d{2}$/;
reDate4 = /^((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}$/;
reDate5 = /^((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}$/;

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. 
A única coisa que a expressão mais completa (e complexa) não é capaz de testar é a validade do dia 29/fev apenas para anos bissextos.


validar um horário ou tempo
reTime1 = /^\d{2}:\d{2}$/;
reTime2 = /^([0-1]\d|2[0-3]):[0-5]\d$/;
reTime3 = /^(0[1-9]|1[0-2]):[0-5]\d$/;
reTime4 = /^\d+:[0-5]\d:[0-5]\d$/;
reTime5 = /^\d+:[0-5]\d:[0-5]\.\d{3}\d$/;

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 (.). 

validar um endereço de e-mail (correio eletrônico).
reEmail1 = /^[\w!#$%&'*+\/=?^`{|}~-]+(\.[\w!#$%&'*+\/=?^`{|}~-]+)*@(([\w-]+\.)+[A-Za-z]{2,6}|\[\d{1,3}(\.\d{1,3}){3}\])$/;
reEmail2 = /^[\w-]+(\.[\w-]+)*@(([\w-]{2,63}\.)+[A-Za-z]{2,6}|\[\d{1,3}(\.\d{1,3}){3}\])$/;
reEmail3 = /^[\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 - 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]. 

*/


var reDigits = /^\d+$/;
var reDecimalPt = /^[+-]?((\d+|\d{1,3}(\.\d{3})+)(\,\d*)?|\,\d+)$/;
var reDecimalEn = /^[+-]?((\d+|\d{1,3}(\,\d{3})+)(\.\d*)?|\.\d+)$/;
var reMoeda = /^\d{1,3}(\.\d{3})*\,\d{2}$/;
var reCEP = /^\d{1,5}\-\d{1,3}$/;
var reRg1 = /^\d{1,2}\.\d{1,3}\.\d{1,3}$/;  //sem digito verificador
var reRg2 = /^\d{1,2}\.\d{1,3}\.\d{1,3}\-\d$/;  //com digito verificador
var reDate1 = /^\d{1,2}\/\d{1,2}\/\d{1,4}$/;
var reDate2 = /^[0-3]?\d\/[01]?\d\/(\d{2}|\d{4})$/;
var reDate3 = /^(0?[1-9]|[12]\d|3[01])\/(0?[1-9]|1[0-2])\/(19|20)?\d{2}$/;
var reDate4 = /^((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}$/;
var reDate5 = /^((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}$/;
var reTime1 = /^\d{2}:\d{2}$/;
var reTime2 = /^([0-1]\d|2[0-3]):[0-5]\d$/;
var reTime3 = /^(0[1-9]|1[0-2]):[0-5]\d$/;
var reTime4 = /^\d+:[0-5]\d:[0-5]\d$/;
var reTime5 = /^\d+:[0-5]\d:[0-5]\.\d{3}\d$/;
var reEmail1 = /^[\w!#$%&'*+\/=?^`{|}~-]+(\.[\w!#$%&'*+\/=?^`{|}~-]+)*@(([\w-]+\.)+[A-Za-z]{2,6}|\[\d{1,3}(\.\d{1,3}){3}\])$/;
var reEmail2 = /^[\w-]+(\.[\w-]+)*@(([\w-]{2,63}\.)+[A-Za-z]{2,6}|\[\d{1,3}(\.\d{1,3}){3}\])$/;
var reEmail3 = /^[\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}\])$/;


 
/*
   File: funcoes.js

   Funções de validação de campos durante a digitação.
*/
ns4 = (document.layers)?true:false;
ie4 = (document.all)?true:false;

var TAB = 9;
var ENTER = 13;
var BS =  8;
var DEL = 46;

var milSep = ' ';
var decSep = '.';

var strNumber = '0123456789';
 
/*    
   Function: verificaNum

   Verifica se a tecla pressionada é numérica ou Backspace.
   Utilizar diretamente no campo do formulário no evento "onkeypressed".

   Parâmetros:

      campo - compo do formulário.
      event - tipo de evento.

   Retorno:

      *true* a tecla seja numérica.
*/
function verificaNum(campo, event)
{
    var key;
    var tecla;  
	
  if (navigator.appName.indexOf("Netscape") != -1){
        tecla = event.which;
  } else {
        tecla = event.keyCode;
  }

    key = String.fromCharCode( tecla);

	if ( tecla == ENTER){
        return false;
  }
    if ( tecla == BS ){
        return true;
  }
    var Digits = "0123456789";
    if ( Digits.indexOf(key) == -1 )
        return false;
    return true;
}

/*
   Function: mascaraVlr

   Aplica a máscara de valor em tempo real.
   Utilizar diretamente no campo do formulário no evento "onkeypressed".

   Parâmetros:

      campo - compo do formulário.
      e - evento.
	  qtdDecimal - Quantidade de casas decimais
	  
   Retorno:

      *true* a tecla seja numérica.

function mascaraVlr(campo, qtdDecimal) {
    var sep = 0;
    var key = '';
    var indStart = indMil = indInteiro = ind = j = 0;
    var len = len2 = 0;
    var aux = aux2 = '';
	var tamDecimal = 0; //len da parte decimal mais separador
	var compDecimal = 0; //len para completar a parte decimal
	var auxLen = 0;
	var auxValor = 0;
	var auxdec = 0;
	
	if(decSep!="" && qtdDecimal > 0)
	{	
		tamDecimal = qtdDecimal + decSep.length;
	}
	else
	{
		tamDecimal = qtdDecimal;
	}
	
    len = campo.value.length;

	for(indStart = 0; indStart < len; indStart++)
	{
        if ((campo.value.charAt(indStart) != '0') && (campo.value.charAt(indStart) != decSep)  && (campo.value.charAt(indStart) != milSep)) break;
    }
	
	aux = '';
    for(; indStart < len; indStart++)
	    if (strNumber.indexOf(campo.value.charAt(indStart))!=-1) aux += campo.value.charAt(indStart);
		
    aux += key;
    len = aux.length;
	
	if ((len == tamDecimal) && qtdDecimal>0 )  
	{
		campo.value = '0'+ decSep + aux;
	}
	
	if ( (len < tamDecimal) && (qtdDecimal>0) )
	{	compDecimal=qtdDecimal-len
		auxValor = iniciaVlr(compDecimal);
		/*auxValor = '0' + decSep ;
		for (qtd=0; qtd < compDecimal; qtd++)
			auxValor = auxValor + '0' ;		*/	
/*			
		auxValor = auxValor + aux;	
		campo.value = auxValor;
	}	else if ( (len == 0) && (qtdDecimal==0) )
	{
		campo.value = '0';
	}	
	
    if (len > qtdDecimal)
	{
        aux2 = '';
		if (qtdDecimal == 0) auxdec = 1; else auxdec =tamDecimal ;
        for (j = 0, indMil = len - auxdec; indMil >= 0; indMil--) {
            if (j == 3) {
				aux2 += milSep;
                j = 0;
            }
            aux2 += aux.charAt(indMil);
            j++;
        }
        campo.value = '';
        len2 = aux2.length;
        for (indInteiro = len2 - 1; indInteiro >= 0; indInteiro--)    campo.value += aux2.charAt(indInteiro);
		
		
		if (qtdDecimal>0){  campo.value += decSep + aux.substr(len - qtdDecimal, len);}
		
    }
	
    return campo.value;
}
*/

function trataKeyPressVlr(campo, event, qtdDecimal) {
    var sep = 0;
    var key = '';
    var indStart = indMil = indInteiro = ind = j = 0;
    var len = len2 = 0;
    var aux = aux2 = '';
    var whichCode = (window.Event) ? event.which : event.keyCode;
	var tamDecimal = 0; //len da parte decimal mais separador
	var compDecimal = 0; //len para completar a parte decimal
	var auxLen = 0;
	var auxValor = 0;
	var auxdec = 0;
	
	if(decSep!="" && qtdDecimal > 0)
	{	
		tamDecimal = qtdDecimal + decSep.length;
	}
	else
	{
		tamDecimal = qtdDecimal;
	}
	
	trataBackSpaceVlr(campo, event, qtdDecimal);
	if (whichCode == ENTER) return true;  // Enter
    key = String.fromCharCode(whichCode);  // Get key value from key code
    if (strNumber.indexOf(key) == -1 && (event.keyCode != 46)) return false;  // Not a valid key or delete
	
    len = campo.value.length;

	for(indStart = 0; indStart < len; indStart++)
	{
        if ((campo.value.charAt(indStart) != '0') && (campo.value.charAt(indStart) != decSep)  && (campo.value.charAt(indStart) != milSep)) break;
    }
	
	aux = '';
    for(; indStart < len; indStart++)
	    if (strNumber.indexOf(campo.value.charAt(indStart))!=-1) aux += campo.value.charAt(indStart);

    aux += key;
    len = aux.length;
	
	if ((len == qtdDecimal) && qtdDecimal>0 )  
	{	campo.value = '0' + decSep + aux;	}
	else if ( (len < tamDecimal) && (qtdDecimal>0) )
	{	compDecimal=qtdDecimal-len;
		auxValor = iniciaVlr(compDecimal);
		/*auxValor = '0' + decSep ;
		for (qtd=0; qtd < compDecimal; qtd++)
			auxValor = auxValor + '0' ;
		*/	
		auxValor = auxValor + aux;	
		campo.value = auxValor;
	}	
	else if ( (len == 0) && (qtdDecimal==0) )
	{
		campo.value = '0';
	}	

    if (len > qtdDecimal)
	{
        aux2 = '';
		if (qtdDecimal == 0) auxdec = 1; else auxdec =tamDecimal ;
        for (j = 0, indMil = len - auxdec; indMil >= 0; indMil--) {
            if (j == 3) {
				aux2 += milSep;
                j = 0;
            }
            aux2 += aux.charAt(indMil);
            j++;
        }
        campo.value = '';
        len2 = aux2.length;
        for (indInteiro = len2 - 1; indInteiro >= 0; indInteiro--)    campo.value += aux2.charAt(indInteiro);
		
		
		if (qtdDecimal>0){  campo.value += decSep + aux.substr(len - qtdDecimal, len);}
		
    }
	
    return false;
}

/*
   Function: trataBackSpaceVlr

   Trata adequadamente o backspace em campo de valor.
   Utilizar diretamente no campo do formulário no evento "onkeydown".

   Parâmetros:

      campo - compo do formulário.
      event - evento.

   Retorno:

      nada.
*/


function trataBackSpaceVlr(campo, event, qtdDecimal)
{
   var key = '';
   var whichCode = (window.Event) ? event.which : event.keyCode;
   var contDec = 0;
   var contMil = 0;
   var numer = 0;
   var aux, auxValor,len;
   NumDig = campo.value;
   TamDig = NumDig.length;
   TamDig--;
   Contador = 0;
   
	if(decSep!="" && qtdDecimal>0)
	{	
		tamDecimal = qtdDecimal + decSep.length;
	}
	else
	{
		tamDecimal = qtdDecimal;
	}

	campo.value = campo.value.replace(' ','');

	aux = '';

    key = String.fromCharCode(whichCode);  // Get key value from key code
//    if ( (strNumber.indexOf(key) == -1) && (event.keyCode != BS) ) 
//	{alert("Retornou"); return false;}  // Not a valid key or delete
    
	len = campo.value.length ;
	
	for(indStart = 0; indStart < len; indStart++)
	{
        if ((campo.value.charAt(indStart) != '0') && (campo.value.charAt(indStart) != decSep)  && (campo.value.charAt(indStart) != milSep)) break;
    }

    for(; indStart < len; indStart++)
	    if (strNumber.indexOf(campo.value.charAt(indStart))!=-1) aux += campo.value.charAt(indStart);
		
    len = aux.length;

	if ((len >= 0) && ((event.keyCode == BS)) )
	{   numer = "";
		contDec = 0;
	    contMil = 0;

		if ((len == tamDecimal) && qtdDecimal>0 )  
		{ numer = '0' + decSep + aux;	}
		else if ( (len < tamDecimal) && (qtdDecimal>0) )
		{ 	
			compDecimal=tamDecimal-len;
			auxValor = iniciaVlr(compDecimal);
			/*auxValor = '0' + decSep ;
			for (qtd=0; qtd < compDecimal; qtd++)
				auxValor = auxValor + '0' ;
			*/	
			auxValor = auxValor + aux;	
			numer = auxValor;
		}	
			
		if (len > tamDecimal)
		{	if (qtdDecimal==0) contMil= -1;
			for (i = len-1; (i >= 0); i--)
			{ 	if ( (contDec == tamDecimal) && (qtdDecimal>0) )
				{	numer = decSep + numer;
					contDec = -1;
					contMil = 0;
				}
				else if (qtdDecimal==0)
				{ 	contDec = -1;}
				
				if ((contMil == 3) && (contDec == -1)  )  
				{	numer = milSep+numer;
					contMil = 0;
				}
				
				if (contDec == -1) contMil ++;
				
				if (contDec > -1) contDec ++;
				
				numer = aux.substr(i, 1)+numer;
			}
		}		
//		if (numer == "001" || numer == "000" || numer == "002" || numer == "003" || numer == "004" || numer == "005" || numer == "006" || numer == "007" || numer == "008" || numer == "009") 
//			numer="";       
		
//		if ((numer.length) == qtdDecimal && qtdDecimal > 0)
//			numer= "0" + decSep + numer;
			
		campo.value = numer;
	}
	return false;
}



function retornaVlrObj(campo, qtdDecimal) {
//Recebe e retona o objeto
	campo.value = retornaVlr(campo.value, qtdDecimal) 
	
    return campo;
}


//retorna float de valor formatado usando decSep e milSep
function retornaVlr(valor)
{
	var auxCampo = new Object();
	var aux = "";

	auxCampo.value = valor;
	
	auxCampo.value = "0" + auxCampo.value;
	if (isNaN(auxCampo.value) == true) //se ja nao estiver com formataçao oracle 
	{	
		len = auxCampo.value.length;
		
		aux = '';
		for(ind =0; ind < len; ind++)
		{
			if (strNumber.indexOf(auxCampo.value.charAt(ind))!=-1 || auxCampo.value.charAt(ind) == decSep) 
			{		aux += auxCampo.value.charAt(ind); 		}
		}
		if (ind == 0 ) aux +="0";
		 
		aux = aux.replace(decSep,'.');
		if (isNaN(aux) == true) aux="0";

		return parseFloat(aux);	
	}	
	else
	{
		return parseFloat(auxCampo.value);	
	}
	
}   

 

function iniciaVlr(qtdDecimal)
{	var auxValor = 0;

	auxValor = '0';
	if (qtdDecimal > 0 )
	{	auxValor+= decSep ;
		for (qtd=0; qtd < qtdDecimal; qtd++)
			auxValor = auxValor + '0' ;
	}	
	return auxValor;		
}

/*****************************************************************/
function trataLostFocus(campo, qtdDecimal) {
    var sep = 0;
    var key = '';
    var indStart = indMil = indInteiro = ind = j = 0;
    var len = len2 = 0;
    var auxCampo = aux = aux2 = '';
	var tamDecimal = 0; //len da parte decimal mais separador
	var compDecimal = 0; //len para completar a parte decimal
	var auxLen = 0;
	var auxValor = 0;
	var auxdec = 0;
	var auxMil = '';
	var partInt = '';
	var partDec = '';
	var ini = 0;

		
	auxCampo = campo.value;
	
	auxCampo = auxCampo.replace(' ','');
	
	if (isNaN(campo.value) == false) auxCampo = campo.value.replace('.', decSep);
	
	len = auxCampo.length;
		
	if(decSep!="" && qtdDecimal > 0)
	{	
		tamDecimal = qtdDecimal + decSep.length;

		if (auxCampo.indexOf(decSep) == -1 ) 
		{	partDec = auxCampo.substr(len, len);
			partInt = auxCampo.substr(0, len);			
		}
		else
		{	partDec = auxCampo.substr(auxCampo.indexOf(decSep)+1, len);
			partInt = auxCampo.substr(0, auxCampo.indexOf(decSep));			
		}

		if (partDec.length > qtdDecimal)
		{
			aux = '';
//			alert ("partDec = " + partDec + " partInt = " + partInt);
//			alert("auxCampo " + auxCampo + "   " +auxCampo.length) 
			for(i=0; i  < auxCampo.length; i++)
				if (strNumber.indexOf(auxCampo.charAt(i))!=-1) aux += auxCampo.charAt(i);		
				
//			partDec = aux.substr(i-tamDecimal, i);
//			partInt = aux.substr(0, i-qtdDecimal);							
			
			partInt = aux;
//			alert("partInt = " + partInt);
			partDec = '';
		}
		
		aux = '';
		for(i=0; i  < partInt.length; i++)
			if (strNumber.indexOf(partInt.charAt(i))!=-1) aux += partInt.charAt(i);
			
//		alert("partInt.length = " + partInt.length + " auxCampo = " + auxCampo);
//		alert ("aux = " + aux)	;
	}
	else
	{
		tamDecimal = qtdDecimal;
		
		aux = '';
		for(i=0; i  < auxCampo.length; i++)
			if (strNumber.indexOf(auxCampo.charAt(i))!=-1) aux +=auxCampo.charAt(i);
			
		partDec = '';			
	}

	for(indStart = 0; indStart < aux.length; indStart++)
	{
        if (aux.charAt(indStart) != '0' ) break;
    }

	partInt = aux.substr(indStart, aux.length);			

//	alert ("S - partInt = " + indStart + " - " +  partInt)
	
//	partInt = aux;		
	if (qtdDecimal > 0	)
	{
		for(cont1 = partDec.length; cont1 < qtdDecimal ; cont1++)
		{
			partDec = partDec + '0';
		}		
	}

	auxMil=''; 
	if (partInt.length == 0)
	{
		auxMil = auxMil + '0';
	}
	else
	{  
		for (j = 0, indMil = partInt.length-1; indMil >= 0; indMil--) {
			if (j == 3) {
				auxMil = milSep + auxMil;
				j = 0;
			}
			auxMil = partInt.charAt(indMil) + auxMil;
			j++;
		}
	}
	
	if (qtdDecimal > 0)	
	{	campo.value = auxMil +  decSep + partDec;}
	else
	{	campo.value = auxMil;}
	
    return campo.value;
}
 
function trataLostFocusObj(campo, qtdDecimal) {
//Recebe e retona o objeto
	campo.value = trataLostFocusVlr(campo.value, qtdDecimal) 
    return campo;
}
 
 function trataLostFocusVlr(valor, qtdDecimal) {
 //recebe e retorna o valor
    var sep = 0;
    var key = '';
    var indStart = indMil = indInteiro = ind = j = 0;
    var len = len2 = 0;
    var auxCampo = new Object();
	var aux = aux2 = '';
	var tamDecimal = 0; //len da parte decimal mais separador
	var compDecimal = 0; //len para completar a parte decimal
	var auxLen = 0;
	var auxValor = 0;
	var auxdec = 0;
	var auxMil = '';
	var partInt = '';
	var partDec = '';
	var ini = 0;
	var campo = 0;
		
		
	auxCampo.value = valor;
	
	auxCampo.value = auxCampo.value.replace(' ','');
	
	if (isNaN(auxCampo.value) == false) auxCampo.value = auxCampo.value.replace('.', decSep);
	
	len = auxCampo.value.length;
	if(decSep!="" && qtdDecimal > 0)
	{	
		tamDecimal = qtdDecimal + decSep.length;

		if (auxCampo.value.indexOf(decSep) == -1 ) 
		{	partDec = auxCampo.value.substr(len, len);
			partInt = auxCampo.value.substr(0, len);			
		}
		else
		{	partDec = auxCampo.value.substr(auxCampo.value.indexOf(decSep) + 1, len);
			partInt = auxCampo.value.substr(0, auxCampo.value.indexOf(decSep));			
		}

		if (partDec.length > qtdDecimal)
		{
			aux = '';
			for(i=0; i  < auxCampo.value.length; i++)
				if (strNumber.indexOf(auxCampo.value.charAt(i))!=-1) aux += auxCampo.value.charAt(i);		
				
			partInt = aux;
			partDec = '';
		}
		
		aux = '';
		for(i=0; i  < partInt.length; i++)
			if (strNumber.indexOf(partInt.charAt(i))!=-1) aux += partInt.charAt(i);
	}
	else
	{
		tamDecimal = qtdDecimal;
		
		aux = '';
		for(i=0; i  < auxCampo.value.length; i++)
			if (strNumber.indexOf(auxCampo.value.charAt(i))!=-1) aux +=auxCampo.value.charAt(i);
			
		partDec = '';			
	}
	for(indStart = 0; indStart < aux.length; indStart++)
	{
        if (aux.charAt(indStart) != '0' ) break;
    }

	partInt = aux.substr(indStart, aux.length);			
	if (qtdDecimal > 0	)
	{
		for(cont1 = partDec.length; cont1 < qtdDecimal ; cont1++)
		{
			partDec = partDec + '0';
		}		
	}

	auxMil=''; 
	if (partInt.length == 0)
	{
		auxMil = auxMil + '0';
	}
	else
	{  
		for (j = 0, indMil = partInt.length-1; indMil >= 0; indMil--) {
			if (j == 3) {
				auxMil = milSep + auxMil;
				j = 0;
			}
			auxMil = partInt.charAt(indMil) + auxMil;
			j++;
		}
	}
	
	if (qtdDecimal > 0)	
	{	valor = auxMil +  decSep + partDec;}
	else
	{	valor = auxMil;}
	
    return valor;
}





function trim (str){
	while('' + str.value.charAt(0)==' ')	
		str.value = str.value.substring(1,str.value.length);
	return str.value;		
}




/**
 * @author Márcio d'Ávila
 * @version 1.01, 2004
 *
 * 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)
 */


var NUM_DIGITOS_CPF  = 11;
var NUM_DIGITOS_CNPJ = 14;
var 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; i<NUM_DIGITOS_CPF; i++)
	{
		algUnico = 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; i<NUM_DGT_CNPJ_BASE; 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


/**
 * 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