//verifica se o browser é netscape/mozilla
var isNS4 = (navigator.appName=="Netscape")?1:0;
function pegaTecla(tecla){
if (isNS4) 
	digito = tecla.which;
else
 digito = tecla.keyCode;
return digito;
}

function caracterControle(digito){
if (digito == 0 || digito == 8 || digito == 13 || digito == 9 || digito == 37 || digito == 38 || digito == 39 || digito == 40 || digito == 16 || digito == 17 || digito == 18)
  return true;
else
  return false;
}

/*============================================================================================
   Funções para validação dos valores dos campos presentes em uma página HTML:
	- ValorNulo: Verifica se o valor do campo presente em uma página HTML está vazio.
		         Exibe uma mensagem de erro caso o valor do campo esteja vazio
	- Trim: Retira os espaços em branco à direita e à esquerda de um texto
	- LTrim: Retira os espaços em branco à esquerda de um texto
	- RTrim: Retira os espaços em branco à direita de um texto
	- SetFocus: Seta o foco de um campo
	- ValorNumerico: Verifica se o valor de um campo de uma página HTML é um valor numérico.
		             Exibe uma mensagem de erro caso o valor do campo não seja um número.
	- VerificaNumero: Verifica se um valor passado como parâmetro é um valor numérico.
		              Exibe uma mensagem de erro caso o valor não seja um número.
	- ENumero: Verifica se um caracter passado como parâmetro é um número de zero a nove
	
	============================================================================================*/
	
	/*==============================================================================================
Verifica se o valor do campo presente em uma página HTML está vazio.
Exibe uma mensagem de erro caso o valor do campo esteja vazio.
Entradas:
   objCampo: campo presente em uma página HTML cujo valor deve ser verificado.
             Se o valor do campo estiver vazio, o campo permanecerá com o foco.
   sMensagem: mensagem a ser exibida se o valor do campo estiver vazio.
              Parâmetro Opcional.
Retorna True se o valor do campo presente na página HTML estiver vazio e false
caso contrário
*/
function ValorNulo(objCampo, sMensagem,bExibirMensagem)
{
   if (typeof(objCampo) != "object")
   {
      alert("Erro na chamada da funçao ValorNulo." +
            " O tipo do valor passado para o parâmetro objCampo não é o esperado." +
            " Deve ser um campo de uma página HTML, ou seja, um objeto");
      return true;
   }
   if (Trim(objCampo.value) == "")
   {
      if (Trim(sMensagem) == "" || typeof(sMensagem) == "undefined")
      {
         sMensagem = "Informe um valor para o campo " + objCampo.dataFld + ".";
      }

      if (typeof(bExibirMensagem) == "undefined")
         bExibirMensagem = true;      

      if (typeof(bExibirMensagem) != "boolean")
      {
         alert("Erro na chamada da funçao ValorNulo." +
            " O tipo do valor passado para o parâmetro bExibirMensagem não é o esperado." +
            " Deve ser true ou false.");
         return false;
      }      
      if (bExibirMensagem)
      	alert(sMensagem);
      SetFocus(objCampo);
      return true;
   }
   return false;
}

/*==============================================================================================
Retira os espaços em branco à direita e à esquerda de um texto
Entradas:
   sTexto: texto a cujos espaços em branco à esquerda e à direita devem ser eliminados
Retorna o texto sem espaços em branco à esquerda e à direita
*/
function Trim(sTexto)
{
   //Texto sem espaços em branco à esquerda e à direita
   var sTextoSemEspacos
   sTextoSemEspacos = LTrim(sTexto);
   sTextoSemEspacos = RTrim(sTextoSemEspacos);
   return sTextoSemEspacos;
}

/*==============================================================================================
Retira os espacos em branco à esquerda de um texto
Entradas:
   sTexto: texto cujos espaços em branco devem ser removidos
Retorna o texto sem espaços em branco à esquerda
*/
function LTrim(sTexto)
{
   //Objeto do tipo String para receber o texto a ser verificado
   var objString
   //Contador
   var iCont
   //Texto sem espaços em branco à esquerda e à direita
   var sTextoSemEspacos
   sTextoSemEspacos = ""
   objString = new String(sTexto);
   for (iCont=0; iCont < objString.length; iCont++) 
   {
      if (objString.charAt(iCont) != " ")
      {
     	 sTextoSemEspacos = objString.substring(iCont,objString.length)
         return sTextoSemEspacos;
      }
   }  
   return sTextoSemEspacos;
}

/*==============================================================================================
Retira os espacos em branco à direita de um texto
Entradas:
   sTexto: texto cujos espaços em branco devem ser removidos
Retorna o texto sem espaços em branco à direita
*/
function RTrim(sTexto)
{
   //Objeto do tipo String para receber o texto a ser verificado
   var objString
   //Contador
   var iCont
   //Texto sem espaços em branco à esquerda e à direita
   var sTextoSemEspacos

   sTextoSemEspacos = ""
   objString = new String(sTexto);
   for (iCont=objString.length -1; iCont >= 0; iCont--) 
   {
      if (objString.charAt(iCont) != " ")
      {
	 sTextoSemEspacos = objString.substring(0, iCont +1);
         return sTextoSemEspacos;
      }
   }  
   return sTextoSemEspacos;
}

/*==============================================================================================
Faz com que um campo presente em uma página HTMl fique com o foco
Entradas:
   objCampo: campo presente em uma página HTML que deve ter o foco.
*/
function SetFocus(objCampo)
{
   var objString
   //Verifica se os valores passados para os parâmetros da função são válidos
   if (typeof(objCampo) != "object")
   {
      alert("Erro na chamada da funçao SetFocus." +
            " O tipo do valor passado para o parâmetro objCampo não é o esperado." +
            " Deve ser um campo de uma página HTML, ou seja, um objeto");
      return false;
   }
   objString = new String(objCampo.tagName);
   objString = objString.toUpperCase();
   if (objString == "INPUT")
   {
      objString = new String(objCampo.type);
      objString = objString.toUpperCase();
      if ((objString != "HIDDEN") && (!objCampo.disabled))
         objCampo.focus();
   }
   return true;
}

/*==============================================================================================
Verifica se o valor de um campo de uma página HTML é um valor numérico
Exibe uma mensagem de erro caso o valor do campo não seja um número
Entradas:
   objCampo: campo presente em uma página HTML cujo valor deve ser verificado. 
             Se o valor do campo não for um número, o campo permanecerá com o foco.
   bPodeConterVirgula: indica se o valor a ser verificado pode conter o caracter vírgula
                       Parâmetro Opcional.
   bPodeConterPonto: indica se o valor a ser verificado pode conter o caracter ponto
                     Parâmetro Opcional.
   sMensagem: mensagem a ser exibida se o valor do campo não for um número.
              Parâmetro Opcional.
Retorna True se o valor do campo presente na página HTML for um número e false
caso contrário
*/
function ValorNumerico(objCampo, bPodeConterVirgula, bPodeConterPonto, sMensagem, bPodeNumeroNegativo)
{
   //Verifica se os valores passados para os parâmetros da função são válidos
   if (typeof(objCampo) != "object")
   {
      alert("Erro na chamada da funçao ValorNumerico." +
            " O tipo do valor passado para o parâmetro objCampo não é o esperado." +
            " Deve ser um campo de uma página HTML, ou seja, um objeto")
      return false;
   }
   if (typeof(bPodeConterVirgula) == "undefined")
      bPodeConterVirgula = true;
   if (typeof(bPodeConterPonto) == "undefined")
      bPodeConterPonto = true;
   if (typeof(bPodeNumeroNegativo) == "undefined")
	   bPodeNumeroNegativo = true;
   
   if (typeof(bPodeConterVirgula) != "boolean")
   {
      alert("Erro na chamada da funçao ValorNumerico." +
            " O tipo do valor passado para o parâmetro bPodeConterVirgula não é o esperado." +
            " Deve ser true ou false.");
      return false;
   }      
   if (typeof(bPodeConterPonto) != "boolean")
   {
      alert("Erro na chamada da funçao ValorNumerico." +
            " O tipo do valor passado para o parâmetro bPodeConterPonto não é o esperado." +
            " Deve ser true ou false.")
      return false;
   }      
   if (typeof(bPodeNumeroNegativo) != "boolean")
   {
      alert("Erro na chamada da funçao ValorNumerico." +
            " O tipo do valor passado para o parâmetro bPodeNumeroNegativo não é o esperado." +
            " Deve ser true ou false.")
      return false;
   }      
   
   if (!VerificaNumero(objCampo.value,bPodeConterVirgula,bPodeConterPonto,bPodeNumeroNegativo))   
   {
      if (Trim(sMensagem) == "" || typeof(sMensagem) == "undefined")
      {
         sMensagem = "O valor informado para o campo " + objCampo.dataFld + 
                     " não é um valor numérico.";
      }
      alert(sMensagem);
      objCampo.focus();
      return false;
   }
   return true;
}

/*==============================================================================================
Verifica valor Numérico
*/
function VerificaNumero(sNumero, bPodeConterVirgula, bPodeConterPonto, bPodeNumeroNegativo)
{
   //Contém o caracter vírgula
   var Virgula
   //Contém o caracter ponto
   var Ponto
   //Contém o sina de negativo
	var SinalNegativo
   //Contador
   var iCont
   //Objeto do tipo String para receber o valor a ser verificado
   var objString
   //Caracter contido no valor a ser verificado
   var sCaracter
   
   Virgula = ",";
   Ponto = ".";
   SinalNegativo = "-";
   //Percorre todos os caracteres do valor do campo para verificar se o caracter pode
   //fazer parte de um número
   objString = new String(sNumero)
   for (iCont=0; iCont < objString.length; iCont++)
   {
      sCaracter = objString.charAt(iCont);
      if ( new String(parseInt(sCaracter)) == "NaN" )
      {
         if ((sCaracter == Virgula && !bPodeConterVirgula)  ||
             (sCaracter == Ponto && !bPodeConterPonto) || 
			 (sCaracter == SinalNegativo && !bPodeNumeroNegativo) ||
			 (sCaracter == SinalNegativo && iCont != 0 ) ||
             (sCaracter != Virgula && sCaracter != Ponto && sCaracter != SinalNegativo))
         {
            return false;
         }
      }
   }
   return true;
}
/*==============================================================================================
Verifica se um caracter passado como parâmetro é um número de zero a nove
Entradas:
   sDigito: caracter a ser verificado
Retorna true se o caracter for um número de zero a nove e false caso contrário
*/
function ENumero(tecla)
{
  var digito = pegaTecla(tecla);
  if (((digito) > 47) && ((digito) < 58))
      return true ;
   else 
      return caracterControle(digito); 
}


	/*
	Verifica se um caracter passado como parâmetro é um número de zero a nove ou '>' ou '<'
	Entradas:
	   sDigito: caracter a ser verificado
	Retorna true se o caracter for um número de zero a nove e false caso contrário
	*/
	function ENumeroDependente(campo,tecla)
	{
  var digito = pegaTecla(tecla);
	  if ((((digito) > 47) && ((digito) < 58)))
	      return true ;
	   else {
	   		if (((digito == 60) || (digito == 62)) && campo.value.length == 0){
	   			return true;
	   		}
	   		else {
	      	return caracterControle(digito); 
	      }
	   }
	}

/*==============================================================================================
Verifica o tamanho do campo
Entradas:
   campo: caracter a ser verificado
Retorna true se o caracter for um número de zero a nove e false caso contrário

Utilização:
	Para input, apenas usar a propriedade MAXLENGTH. Para textarea, utilize a função:
 onkeypress="return tamanho(this,####);" onchange="ajustaTamanho(this,####);"
*/

function tamanho(campo, tecla, tamanho)
{
  if (campo.value.length >= tamanho && !caracterControle(pegaTecla(tecla)))
      return false;
  else 
      return true; 
}

function ajustaTamanho(campo, tamanho)
{
  var pos, quebraLinha = 0;
  pos = campo.value.indexOf('\n');
  while (pos > -1){
  	quebraLinha = quebraLinha + 1;
	  pos = campo.value.indexOf('\n',pos+1);  
  }
  if (campo.value.length > (tamanho-quebraLinha))
      campo.value = campo.value.substr(0,tamanho-quebraLinha);
}

	function Len(str)
	  {  return String(str).length;  }
	  
	function Mid(str, start, len)  
	{         
	        if (start < 0 || len < 0) return "";

	        var iEnd, iLen = String(str).length;
	        if (start + len > iLen)
	                iEnd = iLen;
	        else
	                iEnd = start + len;

	        return String(str).substring(start,iEnd);
	}

/*==============================================================================================*/
function formataDouble(campo, tecla)
{
	//Chamado no evento ONKEYUP
  var digito = pegaTecla(tecla);

   if ((digito == 194) || (digito == 190) ||
       (digito == 188) || (digito == 110)){
     campo.value = campo.value.substr(0,campo.value.length-1) + ".";
   }
   else if (!((((digito) > 47) && ((digito) < 58)) || 
       (((digito) > 95) && ((digito) < 106)))){
     campo.value = campo.value.substr(0,campo.value.length-1);
   }    
}


function FormataCGCeCPF(Campo, tecla)
{	
  var digito = pegaTecla(tecla);
   if (((digito) > 47) && ((digito) < 58)) {
		//Chamado no evento ONKEYUP
		var vr;	
			
		vr = Campo.value;		
				
		vr = vr.replace( /\./, "" );
		vr = vr.replace( /\./, "" );
		vr = vr.replace( "-", "" );
		vr = vr.replace(/\//,"");
		
		tam = vr.length + 1;	
		if (tam == 11)
		{
			Campo.value = vr.substr( 0, 3 ) + '.' + vr.substr( 3, 3 ) + '.' + vr.substr( 6, 3 ) + '-' + vr.substr( 9, 2 ); 
		}
		if (tam == 14)
		{
			Campo.value = vr.substr( 0, 2 ) + '.' + vr.substr( 2, 3 ) + '.' + vr.substr( 5, 3 ) + '/' + vr.substr( 8, 4 ) + '-' + vr.substr( 12, 2 );  
		}
		return true;
	} else {
		return caracterControle(digito);
	}
}

function FormataCPF(Campo, tecla)
{	
  var digito = pegaTecla(tecla);
  if (((digito) > 47) && ((digito) < 58)) {
		//Chamado no evento ONKEYUP
		var vr;	
			
		vr = Campo.value;		
				
		vr = vr.replace( /\./, "" );
		vr = vr.replace( /\./, "" );
		vr = vr.replace( "-", "" );
		vr = vr.replace(/\//,"");
		
		tam = vr.length + 1;	
		Campo.value = vr.substr( 0, 3 ) + '.' + vr.substr( 3, 3 ) + '.' + vr.substr( 6, 3 ) + '-' + vr.substr( 9, 2 ); 
		return true;
	} else {
		return caracterControle(digito);
	}
}

function FormataCGC(Campo,tecla)
{	
  var digito = pegaTecla(tecla);
   if (((digito) > 47) && ((digito) < 58)) {
		//Chamado no evento ONKEYUP
		var vr;	
			
		vr = Campo.value;		
				
		vr = vr.replace( /\./, "" );
		vr = vr.replace( /\./, "" );
		vr = vr.replace( "-", "" );
		vr = vr.replace(/\//,"");
		
		tam = vr.length + 1;	
		Campo.value = vr.substr( 0, 2 ) + '.' + vr.substr( 2, 3 ) + '.' + vr.substr( 5, 3 ) + '/' + vr.substr( 8, 4 ) + '-' + vr.substr( 12, 2 );  
		return true;
	} else {
		return caracterControle(digito);
	}
}


/*==============================================================================================*/

//Função para validação de CPF
        
	function ValidaCPF(CPF)
	{
		//Valida argumento
		if (Len(CPF) != 11)
			return false;
		
		Repetido=true;
		for (i=1;i<=10;i++)
		{
			if (Mid(CPF,i,1)!=Mid(CPF,0,1))
				{Repetido=false;
				 break;
				}
		}
		
		if (Repetido)
			return false;
								 
		soma = 0
		for (i = 1;i<=9;i++)
			soma = soma + parseInt(Mid(CPF, i-1, 1)) * (11 - i);

		Resto = 11 - (soma - (parseInt(soma / 11) * 11));

		if (Resto == 10 || Resto == 11) 
			 Resto = 0;
			 		
		if (Resto != parseInt(Mid(CPF, 9, 1)))
			return false;
							 	
		soma = 0
		for (i = 1;i<=10;i++)
			soma = soma + parseInt(Mid(CPF, i-1, 1)) * (12 - i);
		
		Resto = 11 - (soma - (parseInt(soma / 11) * 11));

		if (Resto == 10 || Resto == 11) 
			Resto = 0;
															
		if (Resto != parseInt(Mid(CPF, 10, 1)))
			return false;
			
		return true;
	}
	
/*==============================================================================================*/
//Função para Validação de CGC

	function ValidaCGC(cgc) 
	{ 
		if (Len(cgc)== 8 && parseInt(cgc) > 0)
		  {  a = 0;
			 J = 0;
			 d1 = 0;
			
			for (i = 0;i<7;i++)
			{	a = parseInt(Mid(cgc, i, 1));
								
				if (((i+1) % 2) != 0)
					a = a * 2;					 									
				 												
				if (a > 9)
					J = J + parseInt(a / 10) + (a % 10);
				else
					J = J + a;								
			}
			
			d1 = ((J % 10) != 0) ? (10 - (J % 10)) : 0 ;			
			
			if (d1 == parseInt(Mid(cgc, 7, 1)))
				 return true;
			else
				return false;
			}			
		else
		  { //if (Len(cgc) == 14 && parseInt(cgc) > 0)
		    if (Len(cgc) == 14)
			{	a = 0;
				i = 0;
				d1 = 0;
				d2 = 0;
				J = 5;
				
				for (i = 0;i<12;i++)
				 {	 a = a + (parseInt(Mid(cgc, i, 1)) * J);			 
					 J = (J > 2) ? (J - 1) : 9 ; 					 
				  }
								
				a = a % 11;
				d1 = (a > 1) ? (11 - a) : 0 ;
				a = 0;
				i = 0;
				J = 6;
				
				for (i = 0;i<13;i++)
					{a = a + (parseInt(Mid(cgc, i, 1)) * J);
					 J = (J > 2) ? (J - 1) : 9;
					}				
				
				a = a % 11;
				d2 = (a > 1) ? (11 - a): 0;
				
				if (d1 == parseInt(Mid(cgc, 12, 1)) && d2 == parseInt(Mid(cgc, 13, 1)))
					return true;
				else
					return false;
			}	
		    else
				return false;		
		}
}

/*==============================================================================================*/
//Função para formatação de CEP

function FormataCEP_VerificarEssaFuncao(Campo)
{	
	//Chamado no evento ONKEYUP
	
	var tecla = event.keyCode;
	var vr;	
		
	vr = Campo.value;		
			
	vr = vr.replace( /\./, "" );
	vr = vr.replace( "-", "" );
	vr = vr.replace(/\D/,"");
	
	tam = vr.length + 1;

	if ( tecla != 9 && tecla != 8 )
	{
		if ( tam > 2 && tam < 7 )
			Campo.value = vr.substr( 0, tam - 2  ) + '.' + vr.substr( tam - 2, tam );
		if ( tam >= 5 && tam <= 10 )
			Campo.value = vr.substr( 0, 2 ) + '.' + vr.substr( 2, 3 ) + '-' + vr.substr( 5, 3 ); 
	}

}

function FormataCEP(ConteudoCampo,tecla)
{
var digito = pegaTecla(tecla);
if (((digito) > 47) && ((digito) < 58))
  {
   NumDig = ConteudoCampo.value;
   TamDig = NumDig.length;
   if (TamDig == 2)
    ConteudoCampo.value = NumDig.substr(0,2)+".";
    else if (TamDig == 6)
		ConteudoCampo.value = NumDig.substr(0,6)+"-";
   return(true);
   } else {
   		return caracterControle(digito);
   }
}

function FormataTelefone(ConteudoCampo,tecla)
{
var digito = pegaTecla(tecla);
if (((digito) > 47) && ((digito) < 58))
  {
   NumDig = ConteudoCampo.value;
   TamDig = NumDig.length;
   if (TamDig == 2)
    ConteudoCampo.value = "("+NumDig.substr(0,2)+")";
    else if (TamDig == 8)
		ConteudoCampo.value = NumDig.substr(0,8)+"-";
   return(true);}
else return caracterControle(digito);
}

function validaEmail(valor) {
  prim = valor.indexOf('@')
  if(prim < 1) return false;
  if(valor.substring(valor.length-1, valor.length) == '.') return false;
  if(valor.indexOf('@',prim + 1) != -1) return false
  if(valor.indexOf('.') < 1) return false;
  if(valor.indexOf(' ') != -1)return false;
  if(valor.indexOf('.@') > 0) return false;
  if(valor.indexOf('@.') > 0) return false;
  if(valor.indexOf('.com.br.') > 0) return false;
  if(valor.indexOf('/') > 0) return false;
  if(valor.indexOf('[') > 0) return false;
  if(valor.indexOf(']') > 0) return false;
  if(valor.indexOf('(') > 0) return false;
  if(valor.indexOf(')') > 0) return false;
  if(valor.indexOf('..') > 0) return false;
  return true;
}

function FormataClasse(ConteudoCampo,tecla)
{
//Tamanho máximo 6 posições. Máscara do campo: X.X.XX.XX
var digito = pegaTecla(tecla);
if (((digito) > 47) && ((digito) < 58))
  {
   NumDig = ConteudoCampo.value;
   TamDig = NumDig.length;
   if (TamDig == 1)
     ConteudoCampo.value = NumDig.substr(0,1)+".";
   else if (TamDig == 3)
   		ConteudoCampo.value = NumDig.substr(0,3)+".";
   else if (TamDig == 6)
   		ConteudoCampo.value = NumDig.substr(0,6)+".";
   return(true);
   } else {
   		return caracterControle(digito);
   }
}

function ELetra(tecla){
  var digito = pegaTecla(tecla);
  if ((digito > 44 && digito < 58))
      return caracterControle(digito); 
  else
  	  return true;
}

function setFocusOnTab(campo,tecla){
   var digito = pegaTecla(tecla);
   if (digito == 0){
   		document.forms[0].elements[campo].focus();
        return false; 
   }
}

function pulaProximoCampo (campo,proximoCampo, tecla){
	var digito = pegaTecla(tecla);

 var tamanho;
 if (isNS4) {
		tamanho =	campo.maxLength-1;
 } else {
		tamanho =	campo.maxLength;
 }
 	if (!caracterControle(digito) && campo.value.length == tamanho ) {
    	document.forms[0].elements[proximoCampo].focus();
      document.forms[0].elements[proximoCampo].select();
  }
}