/*
* Secretaria de Estado de Fazenda de Mato Grosso – Sefaz-MT
* Arquivo : funcoesGenericas.js
* Criação : Abril de 2005
* Revisão : Wanderlúcio Alves de Oliveira - Revisão
* Log : 
* 
* ESTE ARQUIVO SÓ PODERÁ SOFRER MANUTENÇÃO EXCLUSIVAMENTE PELA ÁBACO TECNOLOGIA DE INFORMAÇÃO
*/

/*******************************************************
Função para verificar se um determinado objeto é array ou não.
   Ex. se existe um radio button ou um conjunto

Parâmetros:
	campo - objeto do campo a ser verificado

Válido para: 
	IE, Opera, Netscape, Mozilla, Firefox

Exemplo:
	return isArray(p_form.txtNome)
*******************************************************/

function isArray(obj){
	return(typeof(obj.length)=="undefined") ? false : true;
}


/*******************************************************
Função para verificar se os campos obrigatórios foram preenchidos

Parâmetros:
	campo - objeto do campo a ser validado
	mensagem - mensagem a ser mostrada para o usuário

Válido para: 
	IE, Opera, Netscape, Mozilla, Firefox

Exemplo:
	return verificaCampos(p_form.txtNome,'Mensagem')
*******************************************************/

function verificaCamposW3c(campo,mensagem) {
   return verificaCamposW3cByValor(campo, '', mensagem);
}

/*******************************************************
Função para verificar se os campos obrigatórios foram preenchidos

Parâmetros:
	campo - objeto do campo a ser validado
   valor - valor a ser comparado(valor inicial ex: -1 para campos numéricos, '' para campos texto)
	mensagem - mensagem a ser mostrada para o usuário

Válido para: 
	IE, Opera, Netscape, Mozilla, Firefox

Exemplo:
	return verificaCampos(p_form.txtNome,'Mensagem')
*******************************************************/
function verificaCamposW3cByValor(campo, valor, mensagem)
{
	if (trimW3c(campo.value)==valor)
	{
		alert(mensagem);
		campo.focus();
		return false;
	}
	return true;		
}

/*******************************************************
Função para permitir apenas números e ponto(.)

Parâmetros:
	campo - objeto do campo a ser formatado
	evt - evento utilizado

Válido para: 
	IE, Opera, Netscape, Mozilla, Firefox

Exemplo: 
	onkeypress="return formataNumeroW3c(form.data,event)"
*******************************************************/

function formataNumeroW3c(campo, evt){
	
	tecla = !isNaN(evt.keyCode)? evt.keyCode: evt.which;
	if ( tecla == 0)
		tecla = evt.which;

	if ((tecla != 0) &&  (tecla != 16) && (tecla != 17) && (tecla != 48) && (tecla != 49) && (tecla != 50) && (tecla != 51) && (tecla != 52) && (tecla != 53) && (tecla != 54) && (tecla != 55) && (tecla != 56) && (tecla != 57) && (tecla != 9) && (tecla != 13) && (tecla != 8) && (tecla != 46))
	{
		return false;	
	}
}

/*******************************************************
Função para permitir apenas números e virgula (,) no campo

Parâmetros:
	campo - objeto do campo a ser formatado
	evt - evento utilizado

Válido para: 
	IE, Opera, Netscape, Mozilla, Firefox

Exemplo: 
	onkeypress="return formataNumeroDecW3c(form.data,event)"
*******************************************************/

function formataNumeroDecW3c(campo, evt){
	tecla = !isNaN(evt.keyCode)? evt.keyCode: evt.which;
	if ( tecla == 0)
		tecla = evt.which;
//alert(tecla);
	if ((tecla != 0) &&  (tecla != 16) && (tecla != 17) && (tecla != 44) && (tecla != 48) && (tecla != 49) && (tecla != 50) && (tecla != 51) && (tecla != 52) && (tecla != 53) && (tecla != 54) && (tecla != 55) && (tecla != 56) && (tecla != 57) && (tecla != 9) && (tecla != 13))
	{
		return false;	
	}
}


/*******************************************************
Função para validar CPF

Parâmetros:
	campo - objeto do campo a ser validado

Formato: 
	999.999.999-99

Válido para: 
	IE, Opera, Netscape, Mozilla, Firefox

Exemplo:
	v_retorno = validaCpfW3c(p_form.txtCpf);

	if (!v_retorno)
		return v_retorno;
	
	(Deve ser chamado no evento onSubmit)
*******************************************************/
function validaCpfW3c(campo) {

	if(campo.value.length == 0)
		return;
	formataNumeroCpfW3c(campo);
	vr = campo.value;
	for(i = 0; i < vr.length; i++)
		if ((vr.charAt(i) == ".") || (vr.charAt(i) == "-"))
			vr = vr.substr(0, i) + vr.substr(i+1);
			
	alerta = "Limpo";

	if ((vr.length != 0) && (vr != '00000000000') && (vr != '11111111111') && (vr != '22222222222') && (vr != '33333333333') && (vr != '44444444444') && (vr != '55555555555') && (vr != '66666666666') && (vr != '77777777777') && (vr != '88888888888') && (vr != '99999999999')) {
	
	  // verifica o tamanho
	  if (vr.length != 11)  {
	  	alerta = 'CPF Inválido.';
		sim = false;
	  } else 
		sim = true;
	
	  if (sim) {  // valida o primeiro digito
		for (i=0;((i<=(vr.length-1))&& sim); i++) {
		  val = vr.charAt(i)
		  if ((val!="9")&&(val!="0")&&(val!="1")&&(val!="2")&&(val!="3")&&
			  (val!="4")&&(val!="5")&&(val!="6")&&(val!="7")&&(val!="8")) {
			sim = false;
		  }
		}
	
		if (sim) {
		  soma = 0;
		  for (i=0;i<=8;i++) {
			val = eval(vr.charAt(i));
			soma = soma + (val*(i+1));
		  }
	
		  resto = soma % 11;
	
		  if (resto>9)
			dig = resto -10;
		  else
			dig = resto;
	
		  if (dig != eval(vr.charAt(9))) {
			sim = false;
		  } else {  // valida o segundo digito
			soma = 0;
			for (i=0;i<=7;i++) {
			  val = eval(vr.charAt(i+1));
			  soma = soma + (val*(i+1));
			}
	
			soma = soma + (dig * 9);
			resto = soma % 11;
	
			if (resto>9)
			  dig = resto -10;
			else
			  dig = resto;
	
			if (dig != eval(vr.charAt(10)))
			  sim = false;
			else
			  sim = true;
		  }
		}
	  }
	  if (sim == false)
		alerta = 'CPF Inválido.';

	} else 
		alerta = 'CPF Inválido.';
			
	if (alerta != "Limpo"){
		  alert(alerta);
		  campo.focus();
		  return false;
	}
}

/*************************************************************************
Função para checar se a o formato do CPF digitado é válida

Parâmetros:
	campo - objeto do campo a ser formatado

Formato: 
	999.999.999-99

Válido para: 
	IE, Opera, Netscape, Mozilla, Firefox

Exemplo: 
	 formataNumeroCpfW3c(this);
*************************************************************************/

function formataNumeroCpfW3c(campo)
{
	for(i = 0; i < campo.value.length; i++)
		if ((campo.value.charAt(i) == ".") || (campo.value.charAt(i) == "-"))
			campo.value = campo.value.substr(0, i) + campo.value.substr(i+1);
	
	for(i = campo.value.length; i < 11; i++)
		campo.value = "0" + campo.value;
	
	campo.value = campo.value.substring(0,3)+"."+campo.value.substring(3,6)+"."+campo.value.substring(6,9)+"-"+campo.value.substring(9,11);

}

/*************************************************************************
Função para formatar o CPF enquanto está digitando

Parâmetros:
	campo - objeto do campo a ser formatado
	evt - evento utilizado

Formato: 
	999.999.999-99

Válido para: 
	IE, Opera, Netscape, Mozilla, Firefox

Exemplo: 
	 onKeyPress="return formataNumeroCpfDigitaW3c(this, event)"
*************************************************************************/

function formataNumeroCpfDigitaW3c(campo, evt){

	tecla = !isNaN(evt.keyCode)? evt.keyCode: evt.which;
	if (tecla == 0)
		tecla = evt.which;

	if (((tecla < 48) || (tecla > 57)) && ((tecla != 8) && (tecla != 9) && (tecla != 13) && (tecla != 46)))
		return false;	
		
	else {
		
		if ((navigator.userAgent).indexOf("Opera") == -1) {
			if ((tecla != 8) && (tecla != 9) && (tecla != 13) && (tecla != 46)) {

				separacao1 = '.';
				separacao2 = '.';
				separacao3 = '-';
				conjunto1 = 3;
				conjunto2 = 7;
				conjunto3 = 11;
							
				if (campo.value.length == conjunto1)
					campo.value = campo.value + separacao1;
		
				if (campo.value.length == conjunto2)
					campo.value = campo.value + separacao2;
				
				if (campo.value.length == conjunto3)
					campo.value = campo.value + separacao3;
					
			} 
			
		} else {
			
			if ((tecla == 9) || (tecla == 13)) 
				if(campo.value.length > 0)
					formataNumeroCpfW3c(campo);
					
		}
	}
		
}

/*************************************************************************
Função para validar e formatar data

Parâmetros:
	field - objeto do campo a ser formatado e validado

Formato: 
	dd/mm/aaaa

Válido para: 
	IE, Opera, Netscape, Mozilla, Firefox

Exemplo: 
	onBlur="formataDataW3c(this)"
*************************************************************************/

function formataDataW3c(field,p_submit) {

	var checkstr = "0123456789";
	var DateField = field;
	var Datevalue = "";
	var DateTemp = "";
	var seperator = "/";
	var day;
	var month;
	var year;
	var leap = 0;
	var err = 0;
	var i;

   err = 0;
   DateValue = DateField.value;
   /* Deleta todos os caracteres exceto de 0 a 9. */
   for (i = 0; i < DateValue.length; i++) {
	  if (checkstr.indexOf(DateValue.substr(i,1)) >= 0) {
	     DateTemp = DateTemp + DateValue.substr(i,1);
	  }
   }
   DateValue = DateTemp;
   
   if (DateValue.length == 6) {
      DateValue = DateValue.substr(0,4) + '20' + DateValue.substr(4,2); }
   if (DateValue.length != 8) {
      err = 19;}
   
   year = DateValue.substr(4,4);
   if (year == 0) {
      err = 20;
   }
   
   month = DateValue.substr(2,2);
   if ((month < 1) || (month > 12)) {
      err = 21;
   }
   
   day = DateValue.substr(0,2);
   if (day < 1) {
     err = 22;
   }
  
   if ((year % 4 == 0) || (year % 100 == 0) || (year % 400 == 0)) {
      leap = 1;
   }
   if ((month == 2) && (leap == 1) && (day > 29)) {
      err = 23;
   }
   if ((month == 2) && (leap != 1) && (day > 28)) {
      err = 24;
   }
   
   if ((day > 31) && ((month == "01") || (month == "03") || (month == "05") || (month == "07") || (month == "08") || (month == "10") || (month == "12"))) {
      err = 25;
   }
   if ((day > 30) && ((month == "04") || (month == "06") || (month == "09") || (month == "11"))) {
      err = 26;
   }
   
   if ((day == 0) && (month == 0) && (year == 00)) {
      err = 0; day = ""; month = ""; year = ""; seperator = "";
   }

   if (err == 0) {
      DateField.value = day + seperator + month + seperator + year;
   }
   else {
	   if (p_submit)
	   {
		   	return false;
	   }
	   else
		  alert("Data inválida");
		  DateField.value = "";
		  DateField.focus();
		  return false;
   }
}
 
/*************************************************************************
Função para comparar se a data inicial é menor que a data final

Parâmetros:
	dtInicial - string da data inicial
	dtFinal - string da data final

Formato: 
	dd/mm/aaaa

Válido para: 
	IE, Opera, Netscape, Mozilla, Firefox

Exemplo: 
	v_retorno = comparaDatasW3c(p_form.dtInicial.value, p_form.dtFinal.value);
    if (!v_retorno)
          return v_retorno;

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

function comparaDatasW3c(dtInicial, dtFinal) {
 // Seta as variáveis com dia, mês e ano separados
   v_diainicio = dtInicial.substr(0,2);
   v_mesinicio = dtInicial.substr(3,2);
   v_anoinicio = dtInicial.substr(6,4);
   v_diafim = dtFinal.substr(0,2);
   v_mesfim = dtFinal.substr(3,2);
   v_anofim = dtFinal.substr(6,4);

   // Se o dia ou o mês for menos que 10, adiciona o número 0 (zero) para ficar com duas casas - para data de inicio
  /* if (v_diainicio < 10)
      v_diainicio = "0" + v_diainicio;
   if (v_mesinicio < 10)
      v_mesinicio = "0" + v_mesinicio;
   if (v_diafim < 10)
      v_diafim = "0" + v_diafim;
   if (v_mesfim < 10)
      v_mesfim = "0" + v_mesfim;*/

   // Depois concatena no formato YYYYMMDD para depois comparar
   v_dtinicio = v_anoinicio + v_mesinicio + v_diainicio;
   v_dtfim = v_anofim + v_mesfim + v_diafim;

//alert(v_dtinicio);
//alert(v_dtfim);
   // Compara as datas no formato YYYYMMDD, se a inicio for maior que a fim, dá mensagem de erro ao usuário
   if (v_dtinicio > v_dtfim) 
   {
      alert("A data de início deve ser anterior à data final.");
      return false;
	 
   }
		return true;
}  


/*************************************************************************
Função para checar se a o formato da data digitada é válida

Parâmetros:
	campo - objeto do campo a ser formatado
	evt - evento utilizado

Formato: 
	dd/mm/aaaa

Válido para: 
	IE, Opera, Netscape, Mozilla, Firefox

Exemplo: 
	onKeyPress="return checaDataW3c(this, event)"
*************************************************************************/


function checaDataW3c(campo, evt){
	
	tecla = !isNaN(evt.keyCode)? evt.keyCode: evt.which;
	if ( tecla == 0)
		tecla = evt.which;

	if ((tecla != 0) && (tecla != 16) &&  (tecla != 17) && ((tecla < 47) || (tecla > 57)) && ((tecla != 8) && (tecla != 9) && (tecla != 13) && (tecla != 46)))
	{
		return false;	
	}

		
}

/*************************************************************************
Função para validar o tamanho do textarea

Parâmetros:
	p_objCampo - objeto do campo a ser formatado
	p_permitido - quantidade de caracteres permitidos

Formato: 
	dd/mm/aaaa

Válido para: 
	IE, Opera, Netscape, Mozilla, Firefox

Exemplo: 
	onKeyUp="cortaPalavras(this, 100)"
*************************************************************************/

function cortaPalavrasW3c( p_objCampo, p_permitido ) { 

   if (  p_objCampo.value.length > p_permitido ) {
      alert(  "A quantidade de caracteres digitados ultrapassou "+p_permitido+". Os caracteres excedidos serão retirados.");
      p_objCampo.value =  p_objCampo.value.substr( 0, p_permitido )

	  if ( p_objCampo.value.length > p_permitido )  
         p_objCampo.value =  p_objCampo.value.substr( 0, p_permitido-1 )
   }
   
}


/*************************************************************************
Função que verifica se algum Radio button está selecionado

Parâmetros:
	form - objeto do formulário
	mensagem - mensagem a ser mostrada para o usuário

Formato: 
	-

Válido para: 
	IE, Opera, Netscape, Mozilla, Firefox

Exemplo: 
	retorno = validaRadios(p_form,"Mensagem")
*************************************************************************/

function validaRadiosW3c(form, mensagem) { 
	
	retorno = false;

	for(i= 0; i < form.length; i++ )
	{
		if (form.elements[i].type == "radio" && form.elements[i].checked == true)
		{
 			retorno = true;
			break;
		}
	}
	
	if(retorno == false)
		alert(mensagem);

	return retorno;
}
/*************************************************************************
Função que acrescenta a quantidade de meses desejada em uma data

Parâmetros:
	campoData - objeto do campo da data na qual será acrescentada a qtde de meses desejada
	idDataResult - id do local onde a data gerada será colocada
  qtdeMeses - qtde de meses adicionados no campoData para gerar no idDataResult

Formato: 
	mm

Válido para: 
	IE, Opera, Netscape, Mozilla, Firefox

Exemplo: 
	onBlur="acrescentaMes(this, 'idCampo', '24');"
*************************************************************************/

function acrescentaMes(campoData, idDataResult, qtdeMeses){
  
  // Separar os componentes da data e acrescentar o número de meses
  var dataArray = campoData.value.split("/");
  var mesAtual = parseInt(dataArray[1]);
  
  if(dataArray[1]=="08") {
			dataArray[1] = 8;
  }
  if(dataArray[1]=="09") {
			dataArray[1] = 9;
  }

  var dia = parseInt(dataArray[0]), mes = parseInt(dataArray[1]) + parseInt(qtdeMeses), ano = parseInt(dataArray[2]); 
  
  // Definir o valor do ano e do mês
  if (mes > 12) {
    ano += Math.floor(mes/12);
    mes %= 12;
      if (mes == 0) {
        mes = mesAtual;
        ano -= 1;
  }
  }
  
  if (dia > 28) {
    if ((mes == 2)) {
      if(ano%4 == 0) 
        dia = 29;
      else
        dia = 28;
    } else {
      if (((mes==4) || (mes==6) || (mes==9) || (mes==11)) && (dia == 31)) 
        dia = 30;
    }
  }
  if (dia < 10) 
    dia = '0' + dia;
    
  if (mes < 10) 
    mes = '0' + mes;
  
  if (campoData.value != "")
    document.getElementById(idDataResult).innerHTML = "&nbsp;&nbsp;"+dia+"/"+mes+"/"+ano;
	 return dia+"/"+mes+"/"+ano;
}

/*************************************************************************
Função que valida CNPJ

Parâmetros:
	campo - objeto do campo do CNPJ que será validado

Válido para: 
	IE, Opera, Netscape, Mozilla, Firefox

Exemplo: 
	onChange="return validaCnpfW3c(this);"
	
		OU
	
	v_retorno=validaCnpjW3c(form.txt_cnpj);		
	if(!v_retorno)
		return v_retorno;
	
	return v_retorno;
	
*************************************************************************/

function validaCnpjW3c(campo)
{
	if(campo.value!="")
	{
		var invalid;
		invalid = /^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,4})+$/;
		
		//****limpar a string deixando só números****\\
		
		var Digitos = "0123456789";
		var temp = "";
		var digito = "";
		var S=campo.value;
		for (var i=0; i<S.length; i++)	
		{
			digito = S.charAt(i);
			if (Digitos.indexOf(digito)>=0)	
			{
				temp=temp+digito;	
			}
		} 
		var s=temp;
		//**** #### ****\\
	
		if ((s.length != 14))
		{
			alert("CNPJ Inválido.");
			campo.focus();
			return false;
		}
			//**** Validar ****\\
					
			var i;
		
			var c = s.substr(0,12);
			var dv = s.substr(12,2);
			var d1 = 0;
			for (i = 0; i < 12; i++)
			{
				d1 += c.charAt(11-i)*(2+(i % 8));
			}
				if (d1 == 0) {
					alert("CNPJ Inválido.");
					campo.focus();
					return false;
				}
				d1 = 11 - (d1 % 11);
			if (d1 > 9) d1 = 0;
			if (dv.charAt(0) != d1)
			{
				alert("CNPJ Inválido.");
				campo.focus();
				return false;
			}
		
			d1 *= 2;
			for (i = 0; i < 12; i++)
			{
				d1 += c.charAt(11-i)*(2+((i+1) % 8));
			}
			d1 = 11 - (d1 % 11);
			if (d1 > 9) d1 = 0;
			if ((dv.charAt(1) != d1) || (campo.value.indexOf("..")>-1) )
			{
					alert("CNPJ Inválido.");
					campo.focus();
					return false;
			}
			else 
				return true;
	}
			//**** #### ****\\
}
/*************************************************************************
Função que formata CNPJ

Parâmetros:
	campo - objeto do campo do CNPJ que será validado
	evt - evento que invoca a função

Válido para: 
	IE, Opera, Netscape, Mozilla, Firefox

Exemplo: 
	onKeyPress="formataNumeroCnpjW3c(this, event)"
	
*************************************************************************/


function formataNumeroCnpjW3c(campo, evt){

	tecla = !isNaN(evt.keyCode)? evt.keyCode: evt.which;
	if (tecla == 0)
		tecla = evt.which;

	if (((tecla < 48) || (tecla > 57)) && ((tecla != 8) && (tecla != 9) && (tecla != 13) && (tecla != 46)))
		return false;	
		
	else {
		
		if ((navigator.userAgent).indexOf("Opera") == -1) {
			if ((tecla != 8) && (tecla != 9) && (tecla != 13) && (tecla != 46)) {

				separacao1 = '.';
				separacao2 = '.';
				separacao3 = '/';
				separacao4 = '-';
				conjunto1 = 2;
				conjunto2 = 6;
				conjunto3 = 10;
				conjunto4 = 15;
							
				if (campo.value.length == conjunto1)
					campo.value = campo.value + separacao1;
		
				if (campo.value.length == conjunto2)
					campo.value = campo.value + separacao2;
				
				if (campo.value.length == conjunto3)
					campo.value = campo.value + separacao3;
					
				if (campo.value.length == conjunto4)
					campo.value = campo.value + separacao4;
					
					
			} 
			
		} else {
			
			if ((tecla == 9) || (tecla == 13)) {
			
				campo.value = campo.value.replace(".", "");
				campo.value = campo.value.replace(".", "");
				campo.value = campo.value.replace("/", "");
				campo.value = campo.value.replace("-", "");				
				
				for(i = campo.value.length; i < 14; i++)
					campo.value = "0" + campo.value;

			campo.value = campo.value.substring(0,2)+"."+campo.value.substring(2,5)+"."+campo.value.substring(5,8)+"/"+campo.value.substring(8,12)+"-"+campo.value.substring(12,14);				
				
			}
			
		}
	}
		
}

/*************************************************************************
Função que formata CNPJ

Parâmetros:
	campo - objeto do campo do CNPJ que será validado
	evt - evento que invoca a função

Válido para: 
	IE, Opera, Netscape, Mozilla, Firefox

Exemplo: 
	onKeyPress="formataNumeroCnpjW3c(this, event)"
	
*************************************************************************/


function formataCampoCnpjW3c(campo)
{
	campo.value = campo.value.substring(0,2)+"."+campo.value.substring(2,5)+"."+campo.value.substring(5,8)+"/"+campo.value.substring(8,12)+"-"+campo.value.substring(12,14);						
}

/*************************************************************************
Função que verifica se o número do procedimento foi digitado no formato correto "XXXXX/YYYY/ZZZZZZ"
Onde:
	XXXXX-> Nro da Portaria (até 5 dígitos). ex. 12345
	YYYY-> Ano da portaria em 4 dígitos. ex. 2005
	ZZZZZZ-> Máscara. ex. SEFAZ/GS
	

Parâmetros:
	campo - objeto do campo que contém o nro do procedimento


Válido para: 
	IE, Opera, Netscape, Mozilla, Firefox

Exemplo: 
	onBlur="validarNumeroProcedimentoW3c(this)"


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

function validarNumeroProcedimentoW3c(campo)
{
	mensagem="";
	permitido="0123456789";
	barra1=campo.value.indexOf("/")
	if(barra1>-1)
	{
		num=campo.value.substr(0,barra1);
		resto=campo.value.substr(barra1+1);
		barra2=resto.indexOf("/");
		ano=resto.substr(0,barra2);
		resto=resto.substr(barra2+1);

			for(i=0, j=0;i<=num.length, j<=ano.length;i++,j++)
			{
				if((permitido.indexOf(num.charAt(i))<0)||(permitido.indexOf(ano.charAt(j))<0)|| (ano.length!=4)|| (num.length>5) || (num==""))
				{
					
					alert("Número do Procedimento Inválido");
					return false;
				}
			}

	}
	else
	{
		alert("Digite o N.º do procedimento no formato: \"N.º Portaria/Ano/Sigla Referência\"");
		return false;
	}
	if(resto!="")
		return true;
	else
	{
		alert("Informe a sigla de referência");
		return false;
	}
}

/*************************************************************************
Função que verifica se o número da portaria foi fiditada corretamente ou seja NUMERO/ANO
Onde:
	XXXXX-> Nro da Portaria (até 5 dígitos). ex. 12345
	YYYY-> Ano da portaria em 4 dígitos. ex. 2005

Parâmetros:
	campo - objeto do campo que contém o nro do procedimento

Válido para: 
	IE, Opera, Netscape, Mozilla, Firefox

Exemplo: 
	onBlur="validarNumeroPortariaW3c(this)"


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

function validarNumeroPortariaW3c(campo)
{

	permitido="0123456789";
	barra1=campo.value.indexOf("/");
	if(barra1 > (-1))
	{
		num=campo.value.substr(0,barra1);
		resto=campo.value.substr(barra1+1);
		ano=resto.substr(0,barra1);

			for(i=0, j=0;i<=num.length, j<=ano.length;i++,j++)
			{
				if((permitido.indexOf(num.charAt(i))<0)||(permitido.indexOf(ano.charAt(j))<0)|| (ano.length!=4)|| (num.length>5) || (num==""))
				{
					alert("Número da portaria Inválido");
					return false;
				}
			}
	}
	else
	{
		alert("Digite o N.º da portaria no formato: \" N.º Portaria/Ano\"");
		return false;
	}	
}

/*************************************************************************
Função que move o foco do campo ao ser pressionada a tecla <Enter>

Parâmetros:
	campo - objeto do campo que receberá o foco
	evt - evento utilizado


Válido para: 
	IE, Opera, Netscape, Mozilla, Firefox

Exemplo: 
	onKeyPress="return moverFocoW3c(document.getElementById('idCampo'), event)"

	
*************************************************************************/
function moverFocoW3c(campo, evt){

	tecla = !isNaN(evt.keyCode)? evt.keyCode: evt.which;

	if ((tecla == 13))
	{
		campo.focus();
		return false;	
	}

		
}
/*************************************************************************
Função que bloqueia espaços e move o foco ao ser pressionada a tecla <enter> caso o textarea estiver vazio

Parâmetros:
	objeto - objeto que vai receber o foco
	evt - evento utilizado
	txtArea - objeto textarea


Válido para: 
	IE, Opera, Netscape, Mozilla, Firefox

Exemplo: 
	onKeyDow="return bloqueiaEspacoW3c(txt_nome, event, this)"

	
*************************************************************************/
function bloqueiaEspacoW3c(objeto, evt,txtArea){
	
	tecla = !isNaN(evt.keyCode)? evt.keyCode: evt.which;

	if(txtArea.value=='')
	{
		if (tecla == 13) // enter
			 return setaFocoEnterW3c(objeto,evt)
		else if(tecla == 32) // espaço
				return false;	
	}
		
}
/*************************************************************************
Função que move o foco ao ser pressionada a tecla <enter>

Parâmetros:
	objeto - objeto que vai receber o foco
	evt - evento utilizado


Válido para: 
	IE, Opera, Netscape, Mozilla, Firefox

Exemplo: 
	onKeyDow="return setaFocoEnterW3c(this, event)"

	
*************************************************************************/
function setaFocoEnterW3c(objeto,evt)
{
	tecla = !isNaN(evt.keyCode)? evt.keyCode: evt.which;
	if (tecla == 13)
	{

		objeto.focus();
		return false;
	}
}
/*************************************************************************
Função que acrescenta a quantidade de dias desejada em uma data

Parâmetros:
	p_data - string da data inicial
	p_dias - qtde de dias adicionados no p_data

Formato: 
	dd/mm/aaaa

Válido para: 
	IE, Opera, Netscape, Mozilla, Firefox

Exemplo: 
	onBlur="acrescentaDiasW3c('31/07/2005','1')"
*************************************************************************/

function acrescentaDiasW3c(p_data, p_dias) {
	p_data = p_data.split('/');

	if(p_data[0]=="09")
	{
		var dia = 9;
	}
	else
	{
		if(p_data[0]=="08")
		{
			var dia = 8;
		}
		else
		{
			var dia = parseInt(p_data[0]);
		}
	}
	
	var acrecescentarDia = p_dias;
	
	var diafuturo = eval(dia+acrecescentarDia);
	
	/** Foi comentado esta linha de comando, devido a um erro encontrado na conversão da string
	 *  "09" e "08" utilizando o parseInt(), que fazia uma conversão erronea para 0 e não 9 e 8,
	 *  respectivamente, como era de se esperar.
	 */ //diafuturo = parseInt(p_data[0])+eval(p_dias);
    mes = p_data[1]; 
    ano = parseInt(p_data[2]);
    while (diafuturo > checaDiasW3c(mes,ano)) {
        diafuturo -= checaDiasW3c(mes,ano);
        mes++;
        if(mes > 12) {
            mes = 1;
            ano++;
        }
    }

    if (diafuturo < 10)
        diafuturo = '0'+diafuturo;
    //if (mes < 10) 
       // mes = '0'+mes;

	return diafuturo+"/"+mes+"/"+ano;
}

function checaDiasW3c(mes,ano) {
   if ((mes < 8 && mes % 2 == 1) || (mes > 7 && mes % 2 == 0)) 
      return 31;
   if (mes != 2) 
      return 30;
   if (ano % 4 == 0) 
      return 29;
   return 28;
}

/*************************************************************************
Função que formata o número do processo 

Parâmetros:
	campo - objeto que contém o número a ser formatado


Formato: 
	000000-000/0000

Válido para: 
	IE, Opera, Netscape, Mozilla, Firefox

Exemplo: 
	onBlur="return formataNumeroProcessoW3c(this)"
*************************************************************************/
function formataNumeroProcessoW3c(campo)
{//000000-000/0000 
//alert(campo.value.substr(0,campo.value.indexOf("-")));
	if (campo.value){
		nrProc=campo.value.replace("-","");
		nrProc=nrProc.replace("/","");
		if((nrProc.indexOf("-")<0)&&(nrProc.indexOf("/")<0))
		{//alert(nrProc);
			campo.value=nrProc;
			var tamanho=campo.value.length;
			if((tamanho<=13)&&(tamanho>7))
			{
				ano=campo.value.substr(tamanho-4);
				meio=campo.value.substr(tamanho-7,ano.length-1);
				resto=campo.value.substr(0,tamanho-7);
				while(resto.length<6)
				{
					resto="0"+resto;
				}
				campo.value="";
				campo.value=resto + "-" + meio + "/" + ano;	
				return true;
			}
			else if((tamanho!=15)||(campo.value.charAt(6)!="-")||(campo.value.charAt(10)!="/") || (verficaCaracteresW3c(campo)==false) )
			{
				//return verficaCaracteresW3c(campo);
				alert("Número do Processo Inválido");
				campo.value="";
				campo.focus();
				return false;
			}
		}
		else
		{
			alert("Número do Processo Inválido");
			campo.value="";
			campo.focus();
			return false;	
		}
	}
}
function verficaCaracteresW3c(campo)
{
	nrProcesso = campo.value.replace("-","");
	nrProcesso = nrProcesso.replace("/","");
	if((nrProcesso.indexOf("-")<0)&&(nrProcesso.indexOf("/")<0))
		return true;
	else
		return false;
}

function somaDatasW3c(data, data1)
  {
	// Formatar as datas de entrada
	dt = new String(data);
	dt = dt.replace( "/", "" );
	dt = dt.replace( "/", "" );
	var Data = new Date(dt.substr( 4, 4 ), dt.substr( 2, 2 ) - 1, dt.substr( 0, 2 ));
	
	venc = new String(data1);
	venc = venc.replace( "/", "" );
	venc = venc.replace( "/", "" );
	var Vencimento = new Date(venc.substr( 4, 4 ), venc.substr( 2, 2 ) - 1, venc.substr( 0, 2 ));
	
	//Mês funciona assim: 0-11 em JavaScript 
	// Configurando 1 dia em milisegundos 
	var dia = 1000*60*60*24;
	
	return Math.ceil((Data.getTime()-Vencimento.getTime())/(dia) + 1);
}

/*************************************************************************
* Função que calcula a quantidade de dias entre uma data inicial e uma data final.

Parâmetros:
	dataInicio - Data Inicial no seguinte formato "10/10/2008"
	dataFim    - Data Final no seguinte formato "11/10/2008"

Válido para: 
	IE, Opera, Netscape, Mozilla, Firefox
	
Exemplo: 
	dias= calculaQuantidadeDiasW3c('10/10/2008', '11/10/2008');
*************************************************************************/
function calculaQuantidadeDiasW3c(dataInicio, dataFim)
{
	// Formatar as datas de entrada
	dataInicial = new String(dataInicio);
	dataInicial = dataInicial.replace( "/", "" );
	dataInicial = dataInicial.replace( "/", "" );
	var dateInicio = new Date(dataInicial.substr( 4, 4 ), dataInicial.substr( 2, 2 ) - 1, dataInicial.substr( 0, 2 ));
	
	dataFinal = new String(dataFim);
	dataFinal = dataFinal.replace( "/", "" );
	dataFinal = dataFinal.replace( "/", "" );
	var dateFim = new Date(dataFinal.substr( 4, 4 ), dataFinal.substr( 2, 2 ) - 1, dataFinal.substr( 0, 2 ));
	
	//Mês funciona assim: 0-11 em JavaScript 
	// Configurando 1 dia em milisegundos 
	var dia = 1000*60*60*24;
	
	return Math.ceil((dateFim.getTime() - dateInicio.getTime())/(dia));
}

/*************************************************************************
Função que calcula a quantidade de meses desejada em uma data

Parâmetros:
	dataInicio - Data Inicial
	dataFim - Data Final


Válido para: 
	IE, Opera, Netscape, Mozilla, Firefox

Exemplo: 
	meses=calcularQtdeMesesW3c(txt_dataInicial.value,txt_dataFinal.value);
*************************************************************************/  
function calcularQtdeMesesW3c(dataInicio, dataFim)
{
	qtdMes=0;
	if(comparaDatasW3c(dataInicio, dataFim))
	{
		//alert("Início : "+dataInicio+" Fim : "+dataFim);
		anoInicio=parseInt(dataInicio.substr(6,4));
		mesInicio=dataInicio.substr(3,2);
		anoFim=parseInt(dataFim.substr(6,4));
		mesFim=dataFim.substr(3,2);
		if(mesFim=="08")
			mesFim=8;
		else if(mesFim=="09")
			mesFim=9;
		if(mesInicio=="08")
			mesInicio=8;
		else if(mesInicio=="09")
			mesInicio=9;
		if(anoFim==anoInicio)
		{
			qtdMes = parseInt(mesFim)-parseInt(mesInicio);				
		}
		else
		{
			for(i=parseInt(anoFim); i>parseInt(anoInicio); i--)
			{
					qtdMes=parseInt(qtdMes) + 12;
			}
			if((parseInt(anoFim)- parseInt(anoInicio))==1)
			{
				qtdMes=12-parseInt(mesInicio)+parseInt(mesFim);
			}		
			else
			{
				if (parseInt(mesFim)<parseInt(mesInicio))
				{
					qtdMes=parseInt(qtdMes) + parseInt(mesFim)+12-parseInt(mesInicio);
				}
				else if(parseInt(mesInicio)<parseInt(mesFim))
				{
					//qtdMes=parseInt(qtdMes) + 12 - parseInt(mesInicio)+parseInt(mesFim);					
					qtdMes=parseInt(qtdMes) + parseInt(mesFim)-parseInt(mesInicio);
				}										
			}
		}
	}
	return parseInt(qtdMes);
}
/*************************************************************************
Função para comparar se a data inicial de um período é maior que 
a data final de outro período

Parâmetros:
dtInicial - string da data inicial
dtFinal - string da data final
mst - mensagem de erro
Formato: 
dd/mm/aaaa

Válido para: 
IE, Opera, Netscape, Mozilla, Firefox

Exemplo: 
v_retorno = comparaDatasW3c(p_form.dtInicial.value, p_form.dtFinal.value);
if (!v_retorno)
return v_retorno;

*************************************************************************/
function comparaDatasPeriodoW3c(dtInicial, dtFinal, msg) {
	// Seta as variáveis com dia, mês e ano separados
	v_diainicio = dtInicial.substr(0,2);
	v_mesinicio = dtInicial.substr(3,2);
	v_anoinicio = dtInicial.substr(6,4);
	v_diafim = dtFinal.substr(0,2);
	v_mesfim = dtFinal.substr(3,2);
	v_anofim = dtFinal.substr(6,4);
	
	// Se o dia ou o mês for menos que 10, adiciona o número 0 (zero) para ficar com duas casas - para data de inicio
	/* if (v_diainicio < 10)
		v_diainicio = "0" + v_diainicio;
	if (v_mesinicio < 10)
		v_mesinicio = "0" + v_mesinicio;
	if (v_diafim < 10)
		v_diafim = "0" + v_diafim;
	if (v_mesfim < 10)
		v_mesfim = "0" + v_mesfim;*/
	
	// Depois concatena no formato YYYYMMDD para depois comparar
	v_dtinicio = v_anoinicio + v_mesinicio + v_diainicio;
	v_dtfim = v_anofim + v_mesfim + v_diafim;
	
	// Compara as datas no formato YYYYMMDD, se a inicio for maior que a fim, dá mensagem de erro ao usuário
	if (v_dtinicio > v_dtfim) 
	{
		alert(msg);
		return false;
	
	}
	return true;
}

/*************************************************************************
Função para comparar se a data inicial de um período é maior ou igual que 
a data final de outro período

Parâmetros:
dtInicial - string da data inicial
dtFinal - string da data final
mst - mensagem de erro
Formato: 
dd/mm/aaaa

Válido para: 
IE, Opera, Netscape, Mozilla, Firefox

Exemplo: 
v_retorno = comparaDatasW3c(p_form.dtInicial.value, p_form.dtFinal.value);
if (!v_retorno)
return v_retorno;

*************************************************************************/
function comparaDatasPeriodoMenorW3c(dtInicial, dtFinal, msg) {
	// Seta as variáveis com dia, mês e ano separados
	v_diainicio = dtInicial.substr(0,2);
	v_mesinicio = dtInicial.substr(3,2);
	v_anoinicio = dtInicial.substr(6,4);
	v_diafim = dtFinal.substr(0,2);
	v_mesfim = dtFinal.substr(3,2);
	v_anofim = dtFinal.substr(6,4);
	
	// Se o dia ou o mês for menos que 10, adiciona o número 0 (zero) para ficar com duas casas - para data de inicio
	/* if (v_diainicio < 10)
		v_diainicio = "0" + v_diainicio;
	if (v_mesinicio < 10)
		v_mesinicio = "0" + v_mesinicio;
	if (v_diafim < 10)
		v_diafim = "0" + v_diafim;
	if (v_mesfim < 10)
		v_mesfim = "0" + v_mesfim;*/
	
	// Depois concatena no formato YYYYMMDD para depois comparar
	v_dtinicio = v_anoinicio + v_mesinicio + v_diainicio;
	v_dtfim = v_anofim + v_mesfim + v_diafim;
	
	// Compara as datas no formato YYYYMMDD, se a inicio for maior ou igual que a fim, dá mensagem de erro ao usuário
	if (v_dtinicio >= v_dtfim) 
	{
		alert(msg);
		return false;
	
	}
	return true;
}

/*************************************************************
Função que formata números (separador de milhar)
Resultado: 123.456.789.123.456.789

Parâmetros:
	campo - objeto que contém o valor a ser formatado
	evt - evento


Válido para: 
	IE, Opera, Netscape, Mozilla, Firefox

Exemplo: 
	onKeyPress="return formataMilharW3c(this,event)";
*************************************************************/
function formataMilharW3c(campo,evt)
{
	if(formataNumeroW3c(campo,evt)!=false)
	{
		vr = limparStringW3c(campo.value,"0123456789");
		if(vr.length>2)
		{
			fim=vr.substr(vr.length-2,vr.length);
			inicio=vr.substr(0,vr.length-2);
			cont=inicio.length;
			while(inicio.length>3)
			{
				fim=inicio.substr(inicio.length-3,inicio.length) + "." + fim;
				inicio=inicio.substr(0,inicio.length-3);
			}
			campo.value=inicio + "." + fim;
			campo.selectionStart = campo.value.length;				
			campo.selectionEnd = campo.value.length; 
		}
	}
	else
		return false;
}
/*************************************************************
Função que retira caracteres inválidos de uma string

Parâmetros:
	valor - string de caracteres
	validos - caracteres permitidos na string


Válido para: 
	IE, Opera, Netscape, Mozilla, Firefox

Exemplo: 
	limparStringW3c(campo.value,"0123456789");
*************************************************************/
function limparStringW3c(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;
}
/*************************************************************
formata valor monetário
Resultado: 123.456.789.123.456,45

Parâmetros:
	campo - objeto que contém o valor a ser formatado
	evt - evento


Válido para: 
	IE, Opera, Netscape, Mozilla, Firefox

Exemplo: 
	onKeyPress="return formataMoedaW3c(this,event)";
*************************************************************/
function formataMoedaW3c(campo,evt)
{
	if(formataNumeroW3c(campo,evt)!=false)
	{
		vr = limparStringW3c(campo.value,"0123456789");
		if(vr.length>1)
		{
			fim=vr.substr(vr.length-1,vr.length);
			inicio=vr.substr(0,vr.length-1);
			while(inicio.length>3)
			{

				fim=inicio.substr(inicio.length-3,inicio.length) + "." + fim;
				inicio=inicio.substr(0,inicio.length-3);
			}
			campo.value= inicio + "." + fim;
			valor=campo.value;
			if(valor.charAt(valor.length-2)==".")
			{
				campo.value=campo.value.substr(0,campo.value.length-2) + "," + campo.value.substr(campo.value.length-1);
			}
			
			campo.selectionStart = campo.value.length;				
			campo.selectionEnd = campo.value.length; 
		}
	}
	else
		return false;
}
/*******************************************************
Função para validar Inscrição Estadual (I.E.)

Parâmetros:
	campo - objeto do campo a ser validado

Formato: 
	99999999999 (11 digitos) Obs: o ultimo digito é o digito verificador

Válido para: 
	IE, Opera, Netscape, Mozilla, Firefox

Exemplo:
	onblur = "validaInscEstdW3c(this)"
*******************************************************/
function validaInscEstdW3c(campo)
{
	var ie, soma, resto, dv;
	ie = campo;

	if(ie == '00000000000')
	{
		alert('A Inscrição Estadual informada não é válida.');
		return false;
	}
	soma = (3*ie.substr(0,1))+(2*ie.substr(1,1))+(9*ie.substr(2,1))+(8*ie.substr(3,1))+(7*ie.substr(4,1))+(6*ie.substr(5,1))+(5*ie.substr(6,1))+(4*ie.substr(7,1))+(3*ie.substr(8,1))+(2*ie.substr(9,1));
	resto = (soma%11);
	resto = (11-resto);

	if(resto==10 || resto==11) resto = 0;
	dv = resto;

	if(dv != ie.substr(10,1))
	{
		alert('A Inscrição Estadual informada não é válida.');
		return false;
	}
	else
	{
		return true;
	}
}


/*******************************************************
Função para formatar hora

Parâmetros:
	campo - objeto do campo a ser validado

Formato: 
	99:99 (5 dígitos) Obs: o ultimo digito é o digito verificador

Válido para: 
	IE, Opera, Netscape, Mozilla, Firefox

Exemplo:
	onblur="formataHoraW3c(this)
*******************************************************/
function formataHoraW3c(campo)
{
	valor  = campo.value;
	valido = '0123456789';
	valor1 = "";
	for (i=0; i<valor.length; i++ )
	{
		if (valido.indexOf(valor.charAt(i))>=0)
		{
			valor1=valor1+valor.charAt(i);
		}
	}
	if((valor1.length>2))
	{
		campo.value = valor1.substr(0,valor1.length-2)+":"+valor1.substr(valor1.length-2,valor1.length);
	}
	else
	{
		campo.value = valor1;
	}
}

/*******************************************************
Função para formatar hora

Parâmetros:
	campo - objeto do campo a ser validado

Formato: 
	99:99 (5 dígitos) Obs: o ultimo digito é o digito verificador

Válido para: 
	IE, Opera, Netscape, Mozilla, Firefox

Exemplo:
	onblur="validaFormataHoraW3c(this)
*******************************************************/
function validaFormataHoraW3c(campo)
{
	horaCompleta  = campo.value;
	if (horaCompleta == '')
	{
		return;
	}
	horaCompleta =  limparStringW3c(horaCompleta, '0123456789');
	if (horaCompleta == '')
	{
		alert("A hora informada não é válida.");
		campo.value = "";
		campo.focus();
		return false;
	}
	else
	{
		if(horaCompleta.length==1)
		{
			horaCompleta = '000'+horaCompleta;
		}
		else if(horaCompleta.length==2)
		{
			horaCompleta = '00'+horaCompleta;
		}
		else if(horaCompleta.length==3)
		{
			horaCompleta = '0'+horaCompleta;
		}
		else if(horaCompleta.length>4)
		{
			alert("A hora informada não é válida.");
			campo.value = "";
			campo.focus();
			return false;
		}
	}
	
	hora = horaCompleta.substr(0,(horaCompleta.length-2));
	minuto = horaCompleta.substr((horaCompleta.length-2), horaCompleta.length);

	if(hora>23)
	{
		alert("A hora informada não é válida.");
		campo.value = "";
		campo.focus();
		return false;
	}
	if(minuto>59)
	{
		alert("A hora informada não é válida.");
		campo.value = "";
		campo.focus();
		return false;
	}
	campo.value = hora+":"+minuto;
	return true;
}

/********************************************************
Função para formatar campos
Parâmetros:
objForm - Nome do formulário
strField - nome do campo
sMask - Máscara que define como o formato será apresentado: 
"9" para definir números e "!" para qualquer caracter
* CEP -> 99.999-999 
* CPF -> 999.999.999-99 
* CNPJ -> 99.999.999/9999-99 
* Data -> 99/99/9999 
* Tel Resid -> (99) 999-9999 
* Tel Cel -> (99) 9999-9999 
* Processo -> 99.999999999/999-99 
* C/C -> 999999-! 


Exemplo:
<input type="textbox" name="txt_cep" onKeyDown="return formatarCampoMascaraW3c(document.nomeForm, 'txt_cep', '99999-999');"> 

********************************************************/
function formatarCampoMascaraW3c(objForm, strField, sMask )
{
	var i, nCount, sValue, fldLen, mskLen,bolMask, sCod;
	
	sValue = objForm[strField].value;
	
	// Limpa todos os caracteres de formatação que
	// já estiverem no campo.
	sValue = sValue.toString().replace( "-", "" );
	sValue = sValue.toString().replace( "-", "" );
	sValue = sValue.toString().replace( ".", "" );
	sValue = sValue.toString().replace( ".", "" );
	sValue = sValue.toString().replace( "/", "" );
	sValue = sValue.toString().replace( "/", "" );
	sValue = sValue.toString().replace( "(", "" );
	sValue = sValue.toString().replace( "(", "" );
	sValue = sValue.toString().replace( ")", "" );
	sValue = sValue.toString().replace( ")", "" );
	sValue = sValue.toString().replace( " ", "" );
	sValue = sValue.toString().replace( " ", "" );
	fldLen = sValue.length;
	mskLen = sMask.length;
	
	i = 0;
	nCount = 0;
	sCod = "";
	mskLen = fldLen;
	
	while (i <= mskLen) {
		bolMask = ((sMask.charAt(i) == "-") || (sMask.charAt(i) == ".") || (sMask.charAt(i) == "/"))
		bolMask = bolMask || ((sMask.charAt(i) == "(") || (sMask.charAt(i) == ")") || (sMask.charAt(i) == " "))
		
		if (bolMask) 
		{
			sCod += sMask.charAt(i);
			mskLen++; 
		}
		else 
		{
			sCod += sValue.charAt(nCount);
			nCount++;
		}
		i++;
	}
	
	objForm[strField].value = sCod;

}

/********************************************************
Função para formatar campos
Parâmetros:
objForm - Nome do formulário
strField - nome do campo
sMask - Máscara que define como o formato será apresentado: 
"9" para definir números e "!" para qualquer caracter
* CEP -> 99.999-999 
* CPF -> 999.999.999-99 
* CNPJ -> 99.999.999/9999-99 
* Data -> 99/99/9999 
* Tel Resid -> (99) 999-9999 
* Tel Cel -> (99) 9999-9999 
* Processo -> 99.999999999/999-99 
* C/C -> 999999-! 
evtKeyPress - evento

Exemplo:
<input type="textbox" name="txt_cep" onKeyDown="return formatarCampos(document.nomeForm, 'txt_cep', '99999-999', event);"> 

********************************************************/
function formatarCamposW3c(objForm, strField, sMask, evtKeyPress)
{
	var i, nCount, sValue, fldLen, mskLen,bolMask, sCod, nTecla;
	
	nTecla = !isNaN(evtKeyPress.keyCode)? evtKeyPress.keyCode: evtKeyPress.which;
	if (nTecla == 0)
		nTecla = evtKeyPress.which;
	
	sValue = objForm[strField].value;
	
	// Limpa todos os caracteres de formatação que
	// já estiverem no campo.
	sValue = sValue.toString().replace( "-", "" );
	sValue = sValue.toString().replace( "-", "" );
	sValue = sValue.toString().replace( ".", "" );
	sValue = sValue.toString().replace( ".", "" );
	sValue = sValue.toString().replace( "/", "" );
	sValue = sValue.toString().replace( "/", "" );
	sValue = sValue.toString().replace( "(", "" );
	sValue = sValue.toString().replace( "(", "" );
	sValue = sValue.toString().replace( ")", "" );
	sValue = sValue.toString().replace( ")", "" );
	sValue = sValue.toString().replace( " ", "" );
	sValue = sValue.toString().replace( " ", "" );
	fldLen = sValue.length;
	mskLen = sMask.length;
	
	i = 0;
	nCount = 0;
	sCod = "";
	mskLen = fldLen;
	
	while (i <= mskLen) {
		bolMask = ((sMask.charAt(i) == "-") || (sMask.charAt(i) == ".") || (sMask.charAt(i) == "/"))
		bolMask = bolMask || ((sMask.charAt(i) == "(") || (sMask.charAt(i) == ")") || (sMask.charAt(i) == " "))
		
		if (bolMask) 
		{
			sCod += sMask.charAt(i);
			mskLen++; 
		}
		else 
		{
			sCod += sValue.charAt(nCount);
			nCount++;
		}
		i++;
	}
	
	objForm[strField].value = sCod;
	
	if ((nTecla != 8) && (nTecla != 13)) 
	{ // backspace e enter
		if (sMask.charAt(i-1) == "9") 
		{// apenas números...
			return ((nTecla != 9) && (nTecla != 110) && (nTecla != 111) && (nTecla != 190) && (nTecla != 191) && (nTecla != 0) && (nTecla != 16) && (nTecla != 17) && ((nTecla < 47) || (nTecla > 57)) && ((nTecla != 8) && (nTecla != 9) && (nTecla != 13) && (nTecla != 46))); } // números de 0 a 9
		else 
		{ // qualquer caracter...
			return true;
		}		
	}
	else 
	{
		return true;
	}
}

/*******************************************************
Função para formatar números telefônicos
Formato: (99)999-9999 ou (99)9999-9999

Parâmetros:
	campo - objeto do campo a ser formatado

Válido para: 
	IE, Opera, Netscape, Mozilla, Firefox

Exemplo: 
	onBlur="formataTelefoneW3c(this)"
*******************************************************/
function formataTelefoneW3c(campo)
{
	vr = limparStringW3c(campo.value,"0123456789");
	if(((vr.length<7) && (vr.length!=0)) || (vr.length>10))
	{
		alert("Número de telefone inválido.");
		campo.focus();
	}		
	else if(vr.length>=7)
	{
		if((vr.length==7) || (vr.length==8))
		{
			fim=vr.substr(vr.length-4,vr.length);
			if(vr.length==7)
				inicio=vr.substr(0,3);
			else if(vr.length==8)
				inicio=vr.substr(0,4);		
			campo.value="(xx)" + inicio + "-" + fim;
		}
		
		else 
		{
			if(vr.length==9)
			{
				fim=vr.substr(vr.length-4,vr.length);
				inicio=vr.substr(2,3);
				ddd=vr.substr(0,2);
				
			}
			else if(vr.length==10)
			{
				fim=vr.substr(vr.length-4,vr.length);
				inicio=vr.substr(2,4);
				ddd=vr.substr(0,2);
				
			}			
			campo.value="(" + ddd + ")" + inicio + "-" + fim;
		}
	}
}

/*******************************************************
Função para validar código de tipo de credenciamento
Formato: codigoGrupo.codigoSubGrupo.codigoTipoCredenciamento
Ex.: 015.0126.012

Parâmetros:
	campo - objeto do campo a ser validado

Válido para: 
	IE, Opera, Netscape, Mozilla, Firefox

Exemplo: 
	v_retorno = validarNumeroTipoCredenciamentoW3c(campo);
*******************************************************/
function validarNumeroTipoCredenciamentoW3c(campo)
{
	valorCampo = campo.value;
	codgGrupo = "";
	codgSubGrupo = "";
	codgTipoCredenciamento = "";
	qtdePontos = 0;
	for(contador=0; contador<=valorCampo.length; contador++)
	{
		caracterAtual = valorCampo.charAt(contador);
		if(caracterAtual==".")
		{
			qtdePontos++;
			continue;
		}
		if(eval(qtdePontos)==eval(0))
		{
			codgGrupo += caracterAtual;
		}
		else if(eval(qtdePontos)==eval(1))
		{
			codgSubGrupo += caracterAtual;
		}
		else if(eval(qtdePontos)==eval(2))
		{
			codgTipoCredenciamento += caracterAtual;
		}
	}
	if((eval(qtdePontos)!=eval(2)) || (codgGrupo=="" || codgGrupo=="0") || (codgSubGrupo=="" || codgSubGrupo=="0") || (codgTipoCredenciamento=="" || codgTipoCredenciamento=="0"))
	{
		alert("Código do tipo de credenciamento inválido.");
		return false;
	}
	return true;
}

/*************************************************************
Validar Campos CheckBox
Parâmetros:
	check - name do checkbox
	msg - mensagem a ser emitida caso não houver nenhum checkbox selecionado
Válido para: 
	IE, Opera, Netscape, Mozilla, Firefox
Exemplo:
	onSubmit="return validaCheckW3c(this.check,'Selecione uma opção')"
*************************************************************/
function validaCheckW3c(check,msg) 
{
	var cont = 0;
	tamanhoCheck = check.length;
	if(tamanhoCheck == undefined)
	{
		if (check.checked)
		{
			cont = cont + 1;
		}
	}
	else
	{
		for (var x=0; x < tamanhoCheck; x++) 
		{
		if (check[x].checked) 
		{
			cont = cont + 1;
			break;
		}
	}
	}
	if(cont>0)
	{
		return true;
	}		
	else 
	{
		alert(msg);
		return false;
	}
}
/*******************************************************
Função para permitir apenas números.
DEVE SER UTILIZADA EM COMUNHÃO COM "limparLetrasW3c(this, event)"

Parâmetros:
	campo - objeto do campo a ser formatado
	evt - evento utilizado

Válido para: 
	IE, Opera, Netscape, Mozilla, Firefox

Exemplo: 
	onKeyPress="return apenasNumeroW3c(this,event)" onKeyUp="return apenasNumeroW3c(this, event)" onblur="return limparLetrasW3c(this, event)"
*******************************************************/
function apenasNumeroW3c(campo, evt)
{
	
	tecla = !isNaN(evt.keyCode) ? evt.keyCode: evt.which;
	if ( tecla == 0)
	{
		tecla = evt.which;
	}
	
	if ((tecla != 0) &&  (tecla != 16) && (tecla != 17) && (tecla != 48) && (tecla != 49) && (tecla != 50) && (tecla != 51) && (tecla != 52) && (tecla != 53) && (tecla != 54) && (tecla != 55) && (tecla != 56) && (tecla != 57) && (tecla != 9) && (tecla != 13) && (tecla != 8))
	{
		campo.value = limparStringW3c(campo.value, '0123456789');
		return false;
	}
}

/*******************************************************
Função para permitir apenas números.
DEVE SER UTILIZADA EM COMUNHÃO COM "apenasNumeroW3c(this,event)"

Parâmetros:
	campo - objeto do campo a ser formatado
	evt - evento utilizado

Válido para: 
	IE, Opera, Netscape, Mozilla, Firefox

Exemplo: 
	onKeyPress="return apenasNumeroW3c(this,event)" onKeyUp="return apenasNumeroW3c(this, event)" onblur="return limparLetrasW3c(this, event)"
*******************************************************/

function limparLetrasW3c(campo, event)
{
	campo.value = limparStringW3c(campo.value, '0123456789');
}


/*******************************************************
Função para adicionar números zeros a um determinado campo para completar dígitos faltantes.
Esta função é útil na validação de Inscrição estadual e CNPJ, onde os campos devem ter tamanho mínimo para validação.

Parâmetros:
	campo - objeto do campo a ser formatado
	tamanho - tamanho que o campo deve ter

Válido para: 
	IE, Mozilla, Firefox

Exemplo: 
	onblur="addZeroW3c(this, 11); " //Antes da validação de inscrição estadual
	onblur="addZeroW3c(this, 14); " //Antes da validação de CNPJ
*******************************************************/
function addZeroW3c(campo, tamanho)
{
	if(campo.value!='' && campo.value!='0')
	{
		if(campo.value.length < tamanho)
		{
			var ie = campo.value;
			var cont = campo.value.length;
			var auxiliar = '';
			for(var i=1; i <=(tamanho-cont);i++)
			{
				auxiliar += "0";
			}
			auxiliar+=ie.toString();
			campo.value = auxiliar;
		}
	}
}

function mostrarLocalizarContribuinte()
{
	if(isInternetExplorer())
	{
		document.getElementById('botaoLocalizarContribuinte').disabled = false; //HABILITADO
		document.getElementById('botaoLocalizarContribuinte').value='Localizar';
		document.getElementById('botaoLocalizarContribuinte').title = 'Clique aqui para localizar o contribuinte.';
		document.getElementById('botaoValidarDocumento').style.visibility='hidden'; //OCULTO
	}
	else
	{
		document.getElementById('botaoLocalizarContribuinte').style.visibility='visible';//MOSTRA
		document.getElementById('botaoValidarDocumento').style.visibility='hidden';//OCULTA
	}
	document.getElementById('botaoLocalizarContribuinte').focus();
}

function ocultarLocalizarContribuinte()
{
	if(isInternetExplorer())
	{
		document.getElementById('botaoLocalizarContribuinte').disabled = true;//DESABILITA
		document.getElementById('botaoLocalizarContribuinte').value='   Validar   ';
		document.getElementById('botaoLocalizarContribuinte').title = 'Clique aqui para validar o documento.';
		document.getElementById('botaoValidarDocumento').style.visibility='hidden';//OCULTA
	}
	else
	{
		document.getElementById('botaoLocalizarContribuinte').style.visibility='hidden';//OCULTA
		document.getElementById('botaoValidarDocumento').style.visibility='visible';//MOSTRA
	}
}

function validaComponenteCNPJ(campo, evt)
{
	ocultarLocalizarContribuinte();
	if(campo.value!='')
	{
		addZeroW3c(campo, 14);
		if(validaCnpjW3c(campo))
		{
			mostrarLocalizarContribuinte();
		}
		else
		{
			ocultarLocalizarContribuinte();
		}
	}
	return limparLetrasW3c(campo, evt);
}

function validaComponenteCPF(campo, evt)
{
	ocultarLocalizarContribuinte();
	if(campo.value!='')
	{
		if(validaCpfW3c(campo)!=false)
		{
			mostrarLocalizarContribuinte();
		}
		else
		{
			ocultarLocalizarContribuinte();
		}
	}
	return limparLetrasW3c(campo, evt);
}

function isCPFValidoW3c(campo, evt)
{
	if(campo.value!='')
	{
		addZeroW3c(campo, 11);
		if(validaCpfW3c(campo)!=false)
		{
			formataNumeroCpfW3c(campo);
			return true;
		}
		else
		{
			campo.focus();
			return false;
		}
	}
	else
	{
		return true;
	}
}

function isCNPJValidoW3c(campo, evt)
{
	if(campo.value!='')
	{
		addZeroW3c(campo, 14);
		if(validaCnpjW3c(campo))
		{
			formataCampoCnpjW3c(campo);
			return true;
		}
		else
		{
			formataCampoCnpjW3c(campo);
			campo.focus();
			return false;
		}
	}
	else
	{
		return true;
	}
}

function formataEnquantoDigitaW3c(mascara, campo, proximoCampo, evt)
{
  var tecla = evt.keyCode;
  valor = campo.value;
  valor = removeMascaraW3c(valor);
  tam = valor.length;
  tamMask = mascara.length;
  resp = '';

  // não formata se for teclas de navegação/deleção etc
  switch (tecla)
  {
    case 8:  //Back Space
    case 9:  //Tab
    case 13: //Enter
    case 16: //Shift
    case 17: //Ctrl
    case 18: //Alt
    case 33: //Page Up
    case 34: //Page Down
    case 35: //End
    case 36: //Home
    case 37: //seta esquerda
    case 38: //seta cima
    case 39: //seta direita
    case 40: //seta baixo
    case 45: //Insert
    case 46: //Delete
      return;
  }

  i = tam - 1;
  j = tamMask - 1;
  while (j >= 0 && i >= 0)
  {
    if (i < tamMask)
    {
      if (mascara.charAt(j) != '9')
        resp = mascara.charAt(j) + resp;
      else
      {
        resp = valor.charAt(i) + resp;			
        i--;
      }
      j--;
    }
    else
    {
      resp = valor.charAt(i) + resp;			
      i--;
    }
  }
  campo.value = resp;
	
  if (resp.length >= tamMask && proximoCampo != null)
  {
    proximoCampo.focus();
  }
}

function removeMascaraW3c(valor)
{
   while(valor.indexOf(".") != -1)
      valor = valor.replace(".", "");
   while(valor.indexOf("/") != -1)
      valor = valor.replace( "/", "" );
   while(valor.indexOf("-") != -1)
      valor = valor.replace( "-", "" );
   while(valor.indexOf(",") != -1)
      valor = valor.replace( ",", "" );
   while(valor.indexOf(":") != -1)
      valor = valor.replace( ":", "" );
   while(valor.indexOf(")") != -1)
      valor = valor.replace( ")", "" );
   while(valor.indexOf("(") != -1)
      valor = valor.replace( "(", "" );
   while(valor.indexOf("[") != -1)
      valor = valor.replace( "[", "" );
   while(valor.indexOf("]") != -1)
      valor = valor.replace( "]", "" );
   while(valor.indexOf("{") != -1)
      valor = valor.replace( "{", "" );
   while(valor.indexOf("}") != -1)
      valor = valor.replace( "}", "" );
   while(valor.indexOf("%") != -1)
      valor = valor.replace( "%", "" );
   return valor;
}

function validaComponenteInscricaoEstadual(campo, evt)
{
	ocultarLocalizarContribuinte();
	if(campo.value!='')
	{
		addZeroW3c(campo, 11);
		if(validaInscEstdW3c(campo.value))
		{
			mostrarLocalizarContribuinte();
		}
		else
		{
			ocultarLocalizarContribuinte();
		}
	}
	return limparLetrasW3c(campo, evt);
}

function validaComponenteRazaoSocial(campo)
{
	ocultarLocalizarContribuinte();
	if(campo.value!='')
	{
		var valor = campo.value;
		if(valor.length >=6)
		{
			mostrarLocalizarContribuinte();
		}
		else
		{
			ocultarLocalizarContribuinte();
			alert("A pesquisa por nome razão social deve conter pelo menos 6 (seis) caractéres.");
		}
	}
}

function trimW3c(stringComEspaco)
{
	return retiraEspacosEsquerdaW3c(retiraEspacosDireitaW3c(stringComEspaco));
}

function isEspaco(caracterAVerificar)
{
	var caracteresDeEspaco = " \t\n\r\f";
	return (caracteresDeEspaco.indexOf(caracterAVerificar) != -1);
}

function retiraEspacosEsquerdaW3c(stringComEspaco)
{ 
	for(var k = 0; k < stringComEspaco.length && isEspaco(stringComEspaco.charAt(k)); k++);
	return stringComEspaco.substring(k, stringComEspaco.length);
}

function retiraEspacosDireitaW3c(stringComEspaco)
{
	for(var j=stringComEspaco.length-1; j>=0 && isEspaco(stringComEspaco.charAt(j)) ; j--);
	return stringComEspaco.substring(0,j+1);
}

function toUpperCaseW3c(campo)
{
	if(trimW3c(campo.value))
	{
		campo.value = campo.value.toUpperCase();
	}
}

function exibirOcultarInformacoesW3c(obj,img)
{

	var tipo = buscarTipoNavegador();
	
	if(document.getElementById(obj).style.display == 'none')
	{
		img.src = '/imagens/collapse.gif';
		document.getElementById(obj).style.display = tipo;
	}
	else
	{
		img.src = '/imagens/expand.gif';
		document.getElementById(obj).style.display = 'none';
	}
}

function buscarTipoNavegador()
{
	var nav = navigator.appName;
	if(nav == 'Microsoft Internet Explorer')
	{
		return 'inline';
	}
	else
	{
		return 'table-row';
	}
}

function isInternetExplorer()
{
	var navegador = navigator.appName;
	if(navegador == 'Microsoft Internet Explorer')
	{
		return true;
	}
	else
	{
		return false;
	}
}

function isMozillaFirefox()
{
	var navegador = navigator.appName;
	if(navegador == 'Netscape')
	{
		return true;
	}
	else
	{
		return false;
	}
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//// Metodo utilizado para validar uma data e formatar em mes e ano "MM/AAAA"    		///////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////// TODO Método ainda em teste /////////////////////////////////////////////////////////////////////////////////////////////////
function formataDataMesAnoW3c(campoData) 
{
	var checaString = "0123456789";
	var varData = campoData;
	var dataValor = "";
	var dateTemporaria = "";
	var seperador = "/";
	var mes;
	var ano;
	var erro = 0;
	var contador;
	erro = 0;
   dataValor = varData.value;
   
	/* Deleta todos os caracteres exceto de 0 a 9. */
	for (contador = 0; contador < dataValor.length; contador++) 
	{
		if (checaString.indexOf(dataValor.substr(contador,1)) >= 0) 
		{
			dateTemporaria = dateTemporaria + dataValor.substr(contador,1);
		}
	}
   dataValor = dateTemporaria;
   
	if (dataValor.length == 4) 
	{
		dataValor = dataValor.substr(0,2) + '20' + dataValor.substr(2,4); 
	}
   if (dataValor.length != 6) 
	{
		erro = 19;
	}
   
	ano = dataValor.substr(2,6);
   if (ano == 0) 
	{
		erro = 20;
	}
   
	mes = dataValor.substr(0,2);
   if ((mes < 1) || (mes > 12)) 
	{
		erro = 21;
	}   
	if ((mes == 0) && (ano == 00)) 
	{
		erro = 0; mes = ""; ano = ""; seperador = "";
	}
	if (erro == 0) 
	{
		varData.value = mes + seperador + ano;
	}
   else 
	{
		if(erro == 19)
		{
			alert('A data deve conter o formato "MM/AAAA". ');
			varData.value = "";
			varData.focus();
		}
		else
		{
			alert("Data inválida");
			varData.value = "";
			varData.focus();
		  return false;
		}
	}
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//// Metodo utilizado para retirar todos os caracteres diferentes de numero.				////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////// TODO Método ainda em teste /////////////////////////////////////////////////////////////////////////////////////////////////
function removeMascaraNumero(valor)
{
	var checaString = "0123456789";
	var contador;
   var retorno = '';
	for (contador = 0; contador < valor.length; contador++)
	{
		if (checaString.indexOf(valor.charAt(contador)) != -1)
		{
		   retorno = retorno + valor.charAt(contador);
		}
	}
	return retorno;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//// Metodo utilizado para comparar se a data inicial e maior que a data final.				/////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////// TODO Método ainda em teste /////////////////////////////////////////////////////////////////////////////////////////////////
function comparaDatasPeriodoMesAnoW3c(dtInicial, dtFinal, msg) {
	
	var checaString = "0123456789";
	var varDataInicio = dtInicial.value;
	var varDataFim = dtFinal.value;
	var dataValor = "";
	var dateInicialTemporaria = "";
	var dateFinalTemporaria = "";
	var seperador = "/";
	var mes;
	var ano;
	var erro = 0;
	var contador;
	erro = 0;
   dataInicialValor = varDataInicio;
	dataFinalValor = varDataFim;

	//Formata tamanho Data Inicio
	for (contador = 0; contador < dataInicialValor.length; contador++) 
	{
		if (checaString.indexOf(dataInicialValor.substr(contador,1)) >= 0) 
		{
			dateInicialTemporaria = dateInicialTemporaria + dataInicialValor.substr(contador,1);
		}
	}
	
	if (dataInicialValor.length == 4) 
	{
		dataInicialValor = dataInicialValor.substr(0,2) + '20' + dataInicialValor.substr(2,4); 
	}
	
	//Formata tamanho Data fim
	for (contador = 0; contador < dataFinalValor.length; contador++) 
	{
		if (checaString.indexOf(dataFinalValor.substr(contador,1)) >= 0) 
		{
			dateFinalTemporaria = dateFinalTemporaria + dataFinalValor.substr(contador,1);
		}
	}
	
	if (dataFinalValor.length == 4) 
	{
		dataFinalValor = dataFinalValor.substr(0,2) + '20' + dataFinalValor.substr(2,4); 
	}
	
	// Seta as variáveis com dia, mês e ano separados
	v_mesinicio = dateInicialTemporaria.substr(0,2);
	v_anoinicio = dateInicialTemporaria.substr(2,6)
	v_mesfim = dateFinalTemporaria.substr(0,2);
	v_anofim = dateFinalTemporaria.substr(2,6);
	
	// Depois concatena no formato YYYYMM para depois comparar
	v_dtinicio = v_anoinicio + v_mesinicio;
	v_dtfim = v_anofim + v_mesfim;
	// Compara as datas no formato YYYYMM se a inicio for maior que a fim, dá mensagem de erro ao usuário
	if (v_dtinicio > v_dtfim) 
	{
		alert(msg);
		return false;
	
	}
	return true;
}

 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // Método utilizado para limitar os caracteres do valor, para retirar o caracter final deixando o mesmo como numerico. //
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////                
 /////// TODO Método ainda em teste ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 function limitaCaracteres(nomeCampo, limite)
{
	  var campo = nomeCampo;
	  var valor = campo.value;
	  if(valor.length>limite)
	  {
			return false;
	  }
	  else
	  {
			return true;
	  }
 }
 
/*
	Função responsável por receber um valor por parâmetro de um campo texto e retirar todas as letras
	existente dentro do referido campo. 
*/
function extrairNumerosW3c(valor)
{
  var resultado = "";
	
  for(var i = 0; i < valor.length; i++)
  {
     if (!isNaN(valor.charAt(i))){
         resultado = resultado + valor.charAt(i);
		 resultado = resultado.replace(" ","");
	 }
  }
       
  return resultado;
}


/*
	Função responsável por colocar uma mascara(tipo moeda) em um valor numérico.
*/

function mascaraValorMoedaW3c(nomeForm, nomeCampo,quantidadeCasasDecimais,tamanhoMaximo,mostrarCasasDecimais,event)
{
  if(quantidadeCasasDecimais != 0)
     mostrarCasasDecimais = true;
    
  if (event.keyCode==9 || (event.keyCode>=37 && event.keyCode<=40))
      return true;

  var value = document.forms[nomeForm].elements[nomeCampo].value;
  
  value = extrairNumerosW3c(value);

  if(value.length >= tamanhoMaximo && mostrarCasasDecimais){
    value = value.substring(0,tamanhoMaximo-1);
  }

  if(mostrarCasasDecimais)
  {
    // Tira os zeros à esquerda.
    var temp = value;
    for(i = 0 ; i < value.length-1 ; i++)
    {
       if (value.charAt(i) == 0)
           temp = temp.substr(1);
       else
           break;
    }
    value = temp;
  }

  // Quebra dos valores em inteiro e decimal respeitando o número de casas decimais.
  if ((value.length) < quantidadeCasasDecimais)
  {
    var inteiro = value.substring(0, (value.length) - quantidadeCasasDecimais);
    var inteiro = 0;
    var decimal = value.substring((value.length) - quantidadeCasasDecimais, value.length);
    if (event.keyCode==8)
    {
      if (quantidadeCasasDecimais!=0)
      {
        var inteiro = value.substring(0, (value.length) - quantidadeCasasDecimais);
        var decimal = value.substring((value.length) - quantidadeCasasDecimais, value.length);
        if(decimal == 0)
        {
          decimal = "";
        }
      }
      else
      {
          var inteiro=value.substring(0, value.length);
          var decimal="";
      }
    }
    if (event.keyCode==8)
    {
      if(value != "" && decimal != "")
      {
        while((decimal.length) < quantidadeCasasDecimais)
        {
          decimal = "0" + decimal;
        }
      }
      else
      {
        decimal = "";
      }

    }
    if (event.keyCode!=9 && event.keyCode!=8)
    {
      while((decimal.length) < quantidadeCasasDecimais)
      {
          decimal = "0" + decimal;
      }
    }
   }
   else if (quantidadeCasasDecimais != 0)
   {
     var inteiro = value.substring(0, (value.length) - quantidadeCasasDecimais);
     var decimal = value.substring((value.length) - quantidadeCasasDecimais, value.length);
   }
   else
   {
     var inteiro = value.substring(0, (value.length+1) - quantidadeCasasDecimais);
     var decimal = value.substring((value.length+1) - quantidadeCasasDecimais, value.length);
   }
   if (mostrarCasasDecimais)
   {
     temp = "";
     for (i = inteiro.length ; i >= 0 ; i = i - 3)
        temp = inteiro.substring(i - 3 , i) + "." + temp;
      // Tirando os pontos desnecessários.
      if (temp.substring(0, 1) == ".")
       temp = temp.substr(1);
       temp = temp.substring(0, temp.length-1);
       inteiro = temp;
   }
	if (quantidadeCasasDecimais!=0 && inteiro=="" && decimal!="")
   {
     inteiro="0";
   }
   if(value != "")
   {
     if(quantidadeCasasDecimais == 0)
     {
        document.forms[nomeForm].elements[nomeCampo].value = inteiro;
     }
     else
     {
       if(decimal != "")
         document.forms[nomeForm].elements[nomeCampo].value = inteiro + "," + decimal;
       else
         document.forms[nomeForm].elements[nomeCampo].value = "";
     }
   }
   else
   {
     document.forms[nomeForm].elements[nomeCampo].value = "";
   }
}


 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // Método utilizado para limitar os caracteres do valor, para retirar o caracter final deixando o mesmo como numerico. //
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////                
 /*
 	Função responsável por substituir várias ocorrências
	de um valor proposto pelo usuário.
	@Parametros: conteudo(Conteúdo onde será realizado a permuta de valores)
				 valorConteudo(caracter a ser substituído)
				 novoValor(caracter proposto para substituição)
 */
 /////// TODO Método ainda em teste ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function replaceAll(conteudo, valorConteudo, novoValor ) {
	var valor = conteudo.indexOf( valorConteudo );
	while ( valor > -1 ) {
		conteudo = conteudo.replace(valorConteudo, novoValor );
		valor = conteudo.indexOf( valorConteudo );
	}
	return conteudo;
}

/*
Função responsável por limpar um combobox passado por parâmetro
Implementado: Maxwell Rocha
FUNÇÃO EM ANÁLISE
*/	
function limparComboW3c(campoAtualizacao)
{
	var lista = campoAtualizacao.length;
	//Estou atribuindo null na 1a posição, porque na posição 0 está o item "Selecione" da lista
	for(var i=0; i < lista; i++){
		campoAtualizacao.options[1] = null;
	}
}


/******************************************************* 
Função utilizada para validar se o campo monetário é um valor diferente e maior que ZERO, ou seja, se é válido. 
Parâmetros: 
 valor  - valor do campo a ser validado 
Válido para: 
 IE, Opera, Netscape, Mozilla, Firefox 
Exemplo: 
 onblur="isCampoMonetarioValidoW3c(this, "O valor é obrigatório.");" 
  
 ou 
  
 if(!isCampoMonetarioValidoW3c(document.form.campo, 'O valor é obrigatório.')) 
 { 
  return false; 
 } 
  
 Conforme necessário na funcionalidade. 
*******************************************************/ 
function isCampoMonetarioValidoW3c(campo, mensagem) 
{ 
	if(!verificaCamposW3c(campo,mensagem))
	{
		return false;
	}
	
	valor = campo.value;
	valor = valor.replace(".","");
	valor = valor.replace(",",".");
	valor = parseFloat(valor);
	
	if (valor <= 0.00)
	{
		alert(mensagem);
		campo.focus();
		return false;
	}
	else
	{
		return true;
	}
}
			
function selecionarCombo(text,combo,mensagemErro)
{
  achou = false;
  for (i=0;i<combo.length;i++)
  {
	  if (combo[i].value == text.value)
	  {
		  combo.options[i].selected=true
		  achou = true;
	  }
  }
  if (!achou)
  {
	  alert(mensagemErro);
  }
  return false;
}

function getValorSelecionado(text,combo)
{
  text.value = combo.value;
}