var reLetra 		=/^[^\d*?]+$/;
var caracters 	    = "!@#$%¨&*()=+_[]{}\/|<>?";
var reDigitos 	    =/^\d+$/;
var reDigitosMoeda 	=/\d{0,3}\.?\d{1,3}\,\d{2}/;
var reDDMMAAAA	    = /^(([0][1-9])|([1,2]\d)|([3][0,1]))\W?(([0][1-9])|([1][0-2]))\W?([1-9][0-9]{3})$/
var fsDDMMAAAA	    = "$1/$5/$8"
var reDDMMAA		    = /^(([0][1-9])|([1,2]\d)|([3][0,1]))\W?(([0][1-9])|([1][0-2]))\W?([0-9][0-9]{1})$/
var fsDDMMAA		    = "$1/$5/$8"
var reMMAAAA		    = /^(([0][1-9])|([1][0-2]))\W?([1-9][0-9]{3})$/
var fsMMAAAA		    = "$1/$4"

var reCPF				    = /^(\d{3})\W?(\d{3})\W?(\d{3})\W?(\d{2})$/
var fsCPF				    = "$1.$2.$3-$4"
var feCPF				    = "$1$2$3$4"
var reCGCMF				  =   /^(\d{2})\W?(\d{3})\W?(\d{3})\W?(\d{4})\W?(\d{2})$/;
var fsCGCMF				  = "$1.$2.$3/$4-$5"
var feCGCMF				  = "$1$2$3$4$5"
var reCaractersEsp  = "!@#$%&*()_+=]}[{/?;:.>,<\|^~"
var reArquivo		    = "!@%*()+=]}[{?;>,<|^"

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}\])$/;
var reEmail = reEmail3;

function Validar(naoTrocaAba){

	iRetorno = this.ValidaCampos()

	if(iRetorno != -1){
		if (jsReplace(this.campos[iRetorno].sDisplayMsg, " ", "") != "" ) {

			alert(this.campos[iRetorno].sDisplayMsg); //não retirar esse alert, faz parte da regra de negócio do componente

		} else {
			alert('O campo ' + this.campos[iRetorno].sNome + ' é inválido.');
		}

		if (naoTrocaAba != true) {
			try	{
				top.frameSetTransacao.Acoes.oAbas.selTab(top.frameSetTransacao.Acoes.oAbas.Elem[0].id);
				this.campos[iRetorno].oCampo.focus();
			} catch (e) {
				//alert("Exception: " + e);
			}
		}

		if (this.campos[iRetorno].sTipo != 'check') {

			if (!this.campos[iRetorno].oCampo.disabled){//verifica se o campo nao estah desabilitado. Ocorre quando é um campo que a entrada é através de uma janela de seleção, onde que o usuário não informa via digitação e sim, via seleção.
				if (this.campos[iRetorno].oCampo.type.toLowerCase() != 'hidden') {
					this.campos[iRetorno].oCampo.focus();
				}
			}

			if (this.campos[iRetorno].sTipo != 'combo'){
				this.campos[iRetorno].oCampo.select();
			}
		}

		return false;
	}
	else{
		return true;
	}
}


/**************************************************************************************************/
function Validacao(){
	this.adicionaCampo = adicionaCampo;
	this.ValidaCampos = ValidaCampos;
	this.ativaMascaras = ativaMascaras;

	this.ativaSaltaProxCampo = ativaSaltaProxCampo;
	this.saltaProxCampo = saltaProxCampo; //rotina privada
	this.bSaltaProxCampo = false;
	this.limpa = valLimpa;

	this.ativaZeraTamCampo = ativaZeraTamCampo;
	this.sizeCaractDig = 0;


	this.Validar = Validar;
	this.campos = new Array();
	this.iLast = 0;
}
/**************************************************************************************************/
function Campo(oCampo,sNome,sMsg,bNotNull,sTipo,sRegra){
	this.oCampo = oCampo;
	this.sNome = sNome;
	this.sMsg = sMsg;
	this.sDisplayMsg = this.sMsg;
	this.bNotNull = bNotNull;
	this.sTipo = sTipo;
	this.sRegra = sRegra;
	return this;
}
/**************************************************************************************************/
function adicionaCampo(oCampo,sNome,sMsg,bNotNull,sTipo,sRegra){
	this.campos[this.iLast] = new Campo(oCampo,sNome,sMsg,bNotNull,sTipo,sRegra);
	this.iLast++;
}


function valLimpa() {
	var size = this.campos.length;
	var i = 0;
	for (i = size-1; i>=0 ; i--) {
		p = this.campos.pop();
		p = null;
	}
}

/**************************************************************************************************
-->Funcao que valida todos os campos de um formulario

Para cada campo a ser validado, tem que passar:
- o objeto do campo
- nome do campo que é exibido ao usuario. Isto é usado para montar a mensagem caso o campo seja nulo
- mensagem para devolver caso houver erro
- true ou false para indicar se eh notNull
- tipo do campo (data,fone,nome,cep)
Exemplo: validaCampos(txtNome,'Nome do Usuario','Campo Nome só pode ter letras',true,
											txtEnde,'Endereco do Usuario','Campo Endereço só pode ter letras',false)

	Caso a funcao retornar 'null', é porque esta tudo válido. Senão vai retornar um objeto do tipo
	'Campo', que tem o objeto e a mensagem.
***************************************************************************************************/
function ValidaCampos(){
	var bOk = true;
	var iCampoErro = -1;
	var iCombo, campoAux;

	for(i = 0; i < this.campos.length; i++){

		this.campos[i].sDisplayMsg = this.campos[i].sMsg;

		//verifica se o campo tem que ser preenchido
		if(this.campos[i].bNotNull){
			if(this.campos[i].sTipo == "combo"){
				iCombo = this.campos[i].oCampo.selectedIndex;
				if(this.campos[i].oCampo.options[iCombo].value == 0){
					this.campos[i].sDisplayMsg = "O campo " + this.campos[i].sNome + " deve ser informado."
					bOk = false;
					iCampoErro = i;
					break;//stop o for
				}//end if
			} else if (this.campos[i].sTipo == "check") {
				var checks = this.campos[i].oCampo;
				var found = false;
				for (ci = 0; ci < checks.length; ci++) {
					if (checks[ci].checked)	{
						found = true;
					}
				}
				if (!found) {
					this.campos[i].sDisplayMsg = "O campo " + this.campos[i].sNome + " deve ser informado."
					bOk = false;
					iCampoErro = i;
				}
			} else {
				campoAux = jsReplace(this.campos[i].oCampo.value," ","");
				if(campoAux == ""){
					bOk = false;
					this.campos[i].sDisplayMsg = "O campo " + this.campos[i].sNome + " deve ser informado."
					iCampoErro = i;
					break;//stop o for
				}//end if
			}//end else
		}//end if

		switch(this.campos[i].sTipo){
			case "data":
				bOk = validaData(this.campos[i].oCampo,false,2);
				break;
				case "mes_ano":
				bOk = validaData(this.campos[i].oCampo,false,3);
				break;
			case "hora":
				bOk = validaHora(this.campos[i].oCampo);
				break
			case "data_hora":
				bOk = validaDataHora(this.campos[i].oCampo);
				break
			case "fone":
				bOk = validaTelefone(this.campos[i].oCampo);
				break;
			case "nome":
				bOk = validaNome(this.campos[i].oCampo);
				break;
			case "numero":
				bOk = validaNumero(this.campos[i].oCampo, this.campos[i].sRegra);
				break
			case "nome_numero":
				bOk = validaAlfaNumerico(this.campos[i].oCampo);
				break;
				case "numero_moeda":
				bOk = validaNumeroMoeda(this.campos[i].oCampo);
				break;
			case "cep":
				bOk = validaCep(this.campos[i].oCampo);
				break;
			case "cpf":
				bOk = validaCpfCgc(this.campos[i].oCampo,1);
				break;
			case "cgc":
				bOk = validaCpfCgc(this.campos[i].oCampo,2);
				break;
			case "cpf_cgc":
				bOk = validaCpfCgc(this.campos[i].oCampo,1) || validaCpfCgc(this.campos[i].oCampo,2);
				break;
			case "endereco":
				bOk = validaEndereco(this.campos[i].oCampo);
				break;
			case "arq":
				bOk = validaArquivo(this.campos[i].oCampo);
				break;
			case "email":
				bOk = validaEmail(this.campos[i].oCampo,2);
				break;

		}//end switch

		if(!bOk){
			iCampoErro = i;
			break;//stop o for
		}//end if
	}//end for

	return iCampoErro;
}//end function

/**************************************************************************************************/
// REPLACE ALL INSTANCES OF find WITH replace
// inString: the string you want to convert
// find:     the value to search for
// replace:  the value to substitute
//
// usage:    jsReplace(inString, find, replace);
// example:  jsReplace("To be or not to be", "be", "ski");
//           result: "To ski or not to ski"
//
function jsReplace(inString, find, replace) {
    if (!inString) {
        return "";
    }
    // REPLACE ALL INSTANCES OF find WITH replace
    if (inString.indexOf(find) != -1) {
        // SEPARATE THE STRING INTO AN ARRAY OF STRINGS USING THE VALUE IN find
        t = inString.split(find);

        // JOIN ALL ELEMENTS OF THE ARRAY, SEPARATED BY THE VALUE IN replace
        return (t.join(replace));
    }
    else {
        return inString;
    }
}

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

function IsTeclaEspecial(tecla){
	var bValido = false;

	if(		(tecla == 8)  ||		//backspace
			(tecla == 39) ||	//right
			(tecla == 37) ||	//left
			(tecla == 36) ||	//home
			(tecla == 46) ||	//delete
			(tecla == 9)  ||	//tab
			(tecla == 35)){ 	//end
			bValido = true;
		}

	return bValido;
}

/**************************************************************************************************/
function IsNumber(tecla, event){
	var bValido = false;

	if(!event.shiftKey){//verifica se a tecla shift não está pressionada
		if((tecla >= 47 && tecla <= 58) || //numeros de 0 a 9 no teclado acima das letras
			(tecla >= 96 && tecla <= 105)){  //numeros de 0 a 9 no teclado numerico
			bValido = true
		}
	}
	return bValido;
}

/**************************************************************************************************/
function IsLetter(tecla){
	var bValido = false;
	var c;
	if((tecla >= 65 && tecla <= 90) || tecla == 32){  //letras de 'a' a 'z'	e espaço em branco
		bValido = true
	}

	return bValido;
}

/**************************************************************************************************/
function valDigitos(campo) {
	if (!reDigitos.test(campo)) {
		return false;
	}
	return true;
}

function validaNome(oCampo){
	var i;
	var bNomeValido = true;
	var texto = oCampo.value;

	if(!texto){//se não estiver preenchido, retorna true. Não testa obrigatoriedade
		return true;
	}
	if(!reLetra.test(texto)){
		bNomeValido = false;
	} else {
		for(i=0; i < texto.length; i++){
			if (caracters.indexOf(texto.charAt(i)) >= 0) {
				bNomeValido = false;
				break;
			}
		}
	}

	return bNomeValido;
}

/**************************************************************************************************************************
-- Valida se o email é válido

PARÂMETROS
----------
oCampo: endereço de email que será validado.

pFmt: formato do endereço de email que pode ser 1,2 0u 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].

***************************************************************************************************************************/
function validaEmail(oCampo, pFmt) {

	var bValido = true;

	eval("reEmail = reEmail" + pFmt);

	if (reEmail.test(oCampo.value)) {
		bValido = true;
	} else if (oCampo.value != null && oCampo.value != "") {
		bValido = false;
	}

	return bValido;
}

/**************************************************************************************************
-- Valida se tem apenas numeros, letras, ífens, apóstrofes e espaços em branco
***************************************************************************************************/
function validaEndereco(oCampo){
	var i;
	var bValido = true;
	var texto = oCampo.value;

	if(!texto){//se não estiver preenchido, retorna true. Não testa obrigatoriedade
		return true;
	}

	for(i=0; i < texto.length; i++){
		if(reCaractersEsp.indexOf(texto.charAt(i)) >= 0){
			bValido = false;
			break;
		}
	}

	return bValido;
}

/**************************************************************************************************
-- Valida nome de arquivo
***************************************************************************************************/
function validaArquivo(oCampo){
	var i;
	var bValido = true;
	var texto = oCampo.value;

	if(!texto){//se não estiver preenchido, retorna true. Não testa obrigatoriedade
		return true;
	}

	for(i=0; i < texto.length; i++){
		if(reArquivo.indexOf(texto.charAt(i)) >= 0){
			bValido = false;
			break;
		}
	}

	return bValido;
}

/**************************************************************************************************
-- Valida se tem apenas numeros e letras
***************************************************************************************************/
function validaAlfaNumerico(oCampo){
	var i;
	var bValido = true;
	var texto = oCampo.value;

	if(!texto){//se não estiver preenchido, retorna true. Não testa obrigatoriedade
		return true;
	}
	for(i=0; i < texto.length; i++){
		if(caracters.indexOf(texto.charAt(i)) >= 0){
			bValido = false;
			break;
		}
	}

	return bValido;
}

/**************************************************************************************************/
function validaNumero(oCampo, regras){
	var bNumeroValido = true;
	var regraOk = true;

	if(!oCampo.value){//se não estiver preenchido, retorna true. Não testa obrigatoriedade
		return true;
	}
	if (!reDigitos.test(oCampo.value)) {
		bNumeroValido = false;
	}

	// Se é um número e possui regra de validação, executa a regra.
	if (bNumeroValido && regras) {
		eval('regraOk = ('+ regras.replace(/\$/g, oCampo.value) +');');
	}

	return (bNumeroValido && regraOk);
}

/**************************************************************************************************/
function validaNumeroMoeda(oCampo, regras){
	var bNumeroValido = true;
	var regraOk = true;

	if(!oCampo.value){//se não estiver preenchido, retorna true. Não testa obrigatoriedade
		return true;
	}
	if (!reDigitosMoeda.test(oCampo.value)) {
		bNumeroValido = false;
	}

	// Se é um número e possui regra de validação, executa a regra.
	if (bNumeroValido && regras) {
		eval('regraOk = ('+ regras.replace(/\$/g, oCampo.value) +');');
	}

	return (bNumeroValido && regraOk);
}

/**************************************************************************************************/
function validaCep(oCampo) {
	var bCepValido,cep;

	if(!oCampo.value){//se não estiver preenchido, retorna true. Não testa obrigatoriedade
		return true;
	}
	bCepValido = true;
	cep = jsReplace(oCampo.value,"-","");
	if (cep.length != 8){
		bCepValido = false;
	} else {
		if(!reDigitos.test(cep)){ //verifica se eh so numero
			bCepValido = false;
		}
	}

	//Formata o campo
	if(bCepValido){
		oCampo.value = cep.substring(0,5) + "-" + cep.substring(5);
	}

	return bCepValido;
}


/**************************************************************************************************/
// Substitui todas as ocorrencias de uma string expressão regular por outra
// Eh usado pelo validaData
function impFormat(instr, reBusca, sTroca,umavez,ignorecase) {
	var x= String(typeof reBusca); // Se vier string - converte em espressão regular para aplicar 'g'=global
    if (x.toUpperCase().indexOf('STRING')>=0){
	  	reBusca = new RegExp(reBusca,((ignorecase)?"i":"")+((umavez)?"":"g"))
	}
    return instr.replace(reBusca,sTroca);
}

/**************************************************************************************************
Parametros
field = o campo para ser validado
bmsg = passar true se quiser que a funcao retorne um 'alert'
itipo= 	passar 1 se o formato da data for DDMMAA
				passar 2 se o formato da data for DDMMAAAA
***************************************************************************************************/
function validaData(field,bmsg,itipo) {
	var atipo=["data","dd/mm/aa","dd/mm/aaaa","mm/aaaa"];
	var bDDMMAA		= false;
	var bDDMMAAAA	= false;
  var bMMAAAA   = false;
 	var dia0,mes0,ano0;
 	var auxData;
 	var dData="";

	if (field.value==""){
		return true;
	}
  itipo = (itipo) ? itipo : 0 //0=qualquer, 1=dmaa,2=dmaaaa
	if (itipo == 0 || itipo == 1){
		bDDMMAA = reDDMMAA.test(field.value);
	}
	if (itipo == 0 || itipo == 2){
		bDDMMAAAA = reDDMMAAAA.test(field.value);
	}
  if (itipo == 0 || itipo == 3){
		bMMAAAA = reMMAAAA.test(field.value);
	}
	if ((!bDDMMAA) && (!bDDMMAAAA) && (!bMMAAAA)){// formato não reconhecido
		if(bmsg) alert ("Conteúdo informado não reconhecido como sendo " + atipo[itipo] + "\nVerifique sua digitação");
		return false;
	}
	if (bDDMMAAAA) {
		dData = impFormat(field.value,reDDMMAAAA,fsDDMMAAAA);
 	} else if(bMMAAAA){
    dData = impFormat(field.value,reMMAAAA,fsMMAAAA);
 	} else {
		dData = impFormat(field.value,reDDMMAA,fsDDMMAA);
	}

	dma=dData.split("/");

	if (bDDMMAA) {
		dma[2] = (dma[2]<20) ? parseInt(dma[2])+2000 : parseInt(dma[2])+1900
	} // janelamento de data

	dData=dma.join("/");
  if(!bMMAAAA) {
	  var obj = new Date(dma[2], dma[1]-1, dma[0]);//cria data no browser
  	  dia0 = "00" + obj.getDate();
  	  mes0 = "00" + (obj.getMonth()+1);
  	  ano0 = "0000" + obj.getFullYear();
  	  dia0 = dia0.substring(dia0.length-2);
  	  mes0 = mes0.substring(mes0.length-2);
  	  ano0 = ano0.substring(ano0.length-4);
  	  auxData = dia0 + "/"+  mes0 + "/"+ ano0;

  	  if (auxData != dData) {
		    if (bmsg) alert("Data incorreta\nVerifique sua Digitação");
		    return false
	    } else {
		    field.value = dia0 + "/" + mes0 + "/" + ((itipo==1)?ano0.substring(ano0,2):ano0);
		    return true
  	  }
    } else {
      return true;
    }
  }


//********************************************************************************************
// Valida horas
// true = ok
// false = com erro
// 0 = vazio
//********************************************************************************************
function validaHora(oCampo) {
	var bHoraValida = true
	var vHora;
	var vMinuto;

	if(!oCampo.value){//se não estiver preenchido, retorna true. Não testa obrigatoriedade
		return true;
	}

	horario = oCampo.value
	horario = jsReplace(horario,":","");

	if(horario.length != 4) {
		bHoraValida = false;
	} else {
		vHora = horario.substring(0,2);
		vMinuto = horario.substring(2);
		if (vHora > 23 || vMinuto > 59){
			bHoraValida = false;
		} else {
			oCampo.value = vHora + ":" + vMinuto;
		}
	}

	return bHoraValida
}

/**************************************************************************************************/
function validaDataHora(oCampo){
	var bDataHoraValida = true;
	var data, hora, pos, auxCampo;

	if(!oCampo.value){//se não estiver preenchido, retorna true. Não testa obrigatoriedade
		return true;
	}
	//separa a hora
	auxCampo = oCampo.value;
	oCampo.value = jsReplace(oCampo.value,"/","");
	oCampo.value = jsReplace(oCampo.value,":","");
	oCampo.value = jsReplace(oCampo.value,"-","");

	hora = oCampo.value.substring(oCampo.value.length - 4);
	data = oCampo.value.substring(0,8);//deixa no campo apenas a data

	oCampo.value = data;
	if(!validaData(oCampo,false,2)){
		bDataHoraValida = false;
		oCampo.value = auxCampo;
	} else {
		oCampo.value = hora;
		if(!validaHora(oCampo)){
			bDataHoraValida = false;
		}
	}
	oCampo.value = auxCampo;

	return bDataHoraValida;
}

/**************************************************************************************************/
function validaTelefone(oCampo){
	var bFoneValido = true;
	if (oCampo.value) {
		bFoneValido = oCampo.value.match(/^\(\d{2}\) *\d{3,4}[\-\.]\d{3,4}$/);
	}
	return (bFoneValido != null);
}


/**************************************************************************************************/
function valFormat(instr, reBusca, sTroca, umavez, ignorecase) {
	var x = String(typeof reBusca);
	if (x.toUpperCase().indexOf('STRING')>=0)
		reBusca = new RegExp(reBusca,((ignorecase)?"i":"")+((umavez)?"":"g"))
	return instr.replace(reBusca,sTroca);
}

/**************************************************************************************************/
function impCalcDig11(numero) {
	var pesos=[2,3,4,5,6,7,8,9,2,3,4,5,6,7,8,9]
	var calc= 0 , x=''
	var numero=String(numero).split("")
	var limite=numero.length -1
	var result = 0
	var pso=0
	for (var i=limite; i>=0; i--) {
		x+="\npso:"+pesos[pso]+" * "+ numero[i] + " = " + (pesos[pso] * parseInt(numero[i]))
		calc += (pesos[pso++] * parseInt(numero[i]))
	}
	result = 11 - ((calc)%11)
	if (result == 11) {result = 0}
	return result
}

/**************************************************************************************************/
function validaCpfCgc(oCampo,itipo){
	var atipo=["CPF/CNPJ","CPF","CNPJ"]
	var cpf='', cgc='', digito='',dg='', dgc='', digitoc='', k=0, i=0, j=0, soma=0, mt=0;
	var cpfcgc = oCampo.value;
	var bcpf=false;
	var bcgc=false;

	if (oCampo.value==""){
		return true;
	}

	itipo=(itipo)?itipo:0 // 0=qualquer, 1=cpf,2=cgc
	if (itipo==0||itipo==1) bcpf= reCPF.test(cpfcgc);	// valida tamanho e formato do CPF
	if (itipo==0||itipo==2) bcgc= reCGCMF.test(cpfcgc);	// valida tamanho e formato do CCG
	if ((!bcpf)&&(!bcgc)) {// formato não reconhecido
		return false ;
	}
	// tirar separadores
	if (bcpf)
		cpfcgc=cpfcgc.replace(reCPF,feCPF);
	else
		cpfcgc=cpfcgc.replace(reCGCMF,feCGCMF) ;
	// valida entradas fáceis
	var cpferr = 	"0000000000011111111111222222222223333333333344444444444"+
					 			"5555555555566666666666777777777778888888888899999999999"
	if (cpferr.indexOf(cpfcgc) >= 0) { // informado campo de facil entrada
		return false;
	}
	// tabela de pesos para colunas
	mult = [2,3,4,5,6,7,8,9,2,3,4,5,6,7,8,9];
	if (bcgc){
		cgc = cpfcgc.substring(0,12);
		digito = cpfcgc.substring(12,14);
		for (j = 1; j <= 2; j++) {
			digitoc = impCalcDig11(cgc)
			if (digitoc == 10) digitoc = 0
			dgc +=digitoc;
			cgc+=digitoc;
		}
	}
	else{
		cpf = cpfcgc.substring(0,9);
		digito = cpfcgc.substring(9,11);
		for (j = 1; j <= 2; j++) {
			soma = 0;
			mt = 2;
			for (i = 8 + j; i >= 1; i--) {
				soma += parseInt(cpf.charAt(i-1),10) * mt;
				mt++;
			}
			dg = 11 - (soma % 11);
			if (dg > 9) {dg = 0};
			cpf += dg;
			dgc+=dg
		}
	}
	// digito inválido
	if (dgc != digito) {
		return false;
	}
	else {
		oCampo.value = valFormat(oCampo.value,((bcgc)?reCGCMF:reCPF),((bcgc)?fsCGCMF:fsCPF));
		return true;
	}
}

/**************************************************************************************************/
//ativa para cada campo um tratador de eventos que irá capturar as teclas digitadas
function ativaMascaras(){

	if (!top.frameSetTransacao.Dados.trataEvento){
		alert("Erro. Não será possível utilizar máscaras na entrada desse formulário.\n\nVerifique se existe o include na página para a biblioteca PRTrataEvento.js");
		return;
	}

	for (i=0; i<this.campos.length; i++) {
		if (this.campos[i].oCampo!=null) {//verifica se o campo foi adicionado a coleção de campos
			this.campos[i].oCampo.onkeyup = top.frameSetTransacao.Dados.trataEvento;
		}
	}
}

/**************************************************************************************************/
//ativa para cada campo uma chamada de rotina que zera a quantidade de caracteres pra um campo em específico.
function ativaZeraTamCampo(){
	for (i=0; i<this.campos.length; i++) {
		if (this.campos[i].oCampo!=null) {//verifica se o campo foi adicionado a coleção de campos
			this.campos[i].oCampo.onfocus = top.frameSetTransacao.Dados.trataEvento;
		}
	}
}

/**************************************************************************************************/
//ativa para cada campo um saltador automático
function ativaSaltaProxCampo(valor){
	if (valor==null) valor = true;
	this.bSaltaProxCampo = valor;
//	this.ativaZeraTamCampo(); //soh ativa quando a opção de saltar pra prox estiver ativada
}

/**************************************************************************************************/
function saltaProxCampo(oCampo){
	var oForm = oCampo.form;
	var proxCampo = null;

	// Procura nos elementos do form o campo passado como parametro e retorna o proximo campo
	for (i=0; i<oForm.elements.length; i++) {
		if (oForm.elements[i] == oCampo) {
			for (j=i+1; j<oForm.elements.length; j++) {
				if ((oForm.elements[j] != null) && (oForm.elements[j].type != 'hidden') && (oForm.elements[j].disabled == false)){
					proxCampo =  oForm.elements[j];
					proxCampo.focus();
					return;
				}
			}
		}
	}
}