////////////////////////////////////////////////////////////
//DOCUMENTAÇÃO
//ANALISTA: Katryne Kris Lopes Lacerda Fontanari
//DATA DE CRIAÇÃO: 17/10/2003
//FUNÇÃO DESTE INCLUDE: Listas várias funções javascript que são usadas em várias telas do aplicativo para criticas diversas. Apenas 
//com o include deste arquivo na página, qualquer destas funções poderão ser utilizadas, sem repetição do código a cada tela.
////////////////////////////////////////////////////////////

// FUNÇÕES:

// abrejanela: Abre a próxima página numa nova janela.
// click: Impede a visualização do código-fonte clicando com o botão direito do mouse.
// FormataData: Formata a data, com as barras, bastando digitar os números.
// FormataDataBlur: Formata a data ao sair do campo.
// FormataCEP: Formata o CEP no formato (99999-999)
// chdata: checa validade da data digitada
// compara_data : Compara 2 datas e retorna um alerta se a data_anterior for maior.
// compara_data_com_hoje: Compara uma data com a data de hoje e alerta se ela for maior.
// placeFocus: posiciona o foco na primeira caixa de texto da página (não funciona bem se a //página tem algum refresh em campos intermediários).
// calcula_semana_epid: calcula semana epidemiológica, passando como parâmetro o campo que contém //a data e o campo destino do valor da semana
// datas_semana: calcula a data de início e a final de uma dada semana epidemiológica
// campo_num: critica presença de letras em campos numericos
// showobject: mostra as propriedades de um objeto para fins de depuracao
// movelist: move elementos de uma lista para outra lista.
// tiraacento : tira todos os acentos da string passada
// movelist :  função para mover elementos de uma lista para outra lista
// limpacombo: funcao para limpar o conteudo de um object SELECT
// keyDown(DnEvents) : Função para emular a tecla TAB


var nets = false;
var msie = false;
var versao = 0;

//-----------------------------------------------------
function reporTodas(texto, referenciaVelha, referenciaNova)
{
  textoFinal = texto;
  while(textoFinal.indexOf(referenciaVelha) >= 0)
    textoFinal = textoFinal.replace(referenciaVelha, referenciaNova);
  
  return(textoFinal);
}
//-----------------------------------------------------
function espacosDireita(valor,tam)
{
 varTamanho = valor.length;
 if (varTamanho < tam)
 {
  for(t=1; t<=tam - varTamanho; t++)
    valor = valor + " ";
 }
 return(valor);
}
//-----------------------------------------------------
function zerosEsquerda(valor,tam)
{
 varTamanho = valor.length;
 if (varTamanho < tam)
 {
  for(t=1;t<=tam - varTamanho;t++){valor = "0" + valor;}
 }
 return(valor);
}

//-----------------------------------------------------
function trim(texto)
{
 var tamanho   = 0;
 var resultado = "";
 var i;
 tamanho = texto.length;
 for (i=0; i<= tamanho; i++)
 {
  if (texto.substr(i,1) != " ")
  {
   resultado = texto.substr(i, tamanho-i);
   break;
  }
 }
 tamanho = resultado.length;
 texto   = resultado;
 for (i=tamanho; i != 0; i--)
 {
  if (texto.substr(i-1,1) != " ")
  {
   resultado = resultado.substr(0, i);
   break;
  }
 }
 return(resultado);
}



//funcao para retornar qual o browse
function verificabrowse() {
  if (navigator.appName.substring(0, 8) == "Netscape") {
     nets = true;
  } else {
     msie = true ;

  }
  if (navigator.appVersion.substr(17,6) == "MSIE 5") {
      versao = 5;
  } else {
      versao = parseFloat(navigator.appVersion.substring(0, 3) );
  }
//  alert('nets=' + nets + '\nmsie=' + msie + '\nversao=' + versao);
}

verificabrowse();

if (nets) document.captureEvents(Event.CLICK);
document.onmousedown=click;

function abrejanela(arquivo, nome, parametro, fecharatual){
var xwind;
   xwind = window.open('',nome,parametro);
   if (xwind != null) if (xwind.opener == null) xwind.opener = self;
   xwind.location.href = arquivo;
   if (fecharatual) {self.close();}
}


function click(e)
{ 
   return true;  // nao executar, temporariamente!!!
   if (msie) {
       k = event.button;
   } else {
       k = e.which;
   }
   if (k >=2)
   {
      window.alert('- ERRO -  \n\n\Não é permitida a visualização do código fonte.')
      return false;
   }
}


function RemoveNoNumeric(n){
  s = "";
  n = String(n);
  for (i=0; i < n.length; i++) {
      if (n.charAt(i) >= "0" && n.charAt(i) <= "9") {
         s = s + n.charAt(i);
      }
  }
  return s;
}

function RemoveNoNumericForFloat(n){
  s = "";
  n = String(n);
  for (i=0; i < n.length; i++) {
      if (n.charAt(i) >= "0" && n.charAt(i) <= "9" || n.charAt(i) == ",") {
         s = s + n.charAt(i);
      }
  }
  return s;
}

function Removeponto(n){
  s = "";
  for (i=0; i < n.length; i++) {
      if (n.charAt(i) != "." && n.charAt(i) != "/") {
         s = s + n.charAt(i);
      }
  }
  return s;
}

function tiraacento(p){ 
   var comacento = 'ÁÉÍÓÚÝáéíóúýÃÕÑãõñÂÊÎÔÛâêîôûÄËÏÖÜäëïöüÿÀÈÌÒÙàèìòùÇç'; 
   var semacento = 'AEIOUYaeiouyAONaonAEIOUaeiouAEIOUaeiouyAEIOUaeiouCc';
   var s = '';
   var n = -1;
   var i;
   for (i = 0; i < p.length; i++) {
      n = comacento.indexOf( p.charAt(i) );
      if ( n > -1) 
         s = s + semacento.charAt(n);
      else
         s = s + p.charAt(i);
   }
   return s;
}


function FormataData(Campo,teclapres) {
   if (versao >= 5 || msie) {
      FormataData1(Campo, teclapres);
   } else {
      FormataData2(Campo, teclapres);
   }
}
function FormataData1(Campo,teclapres) {
	var tecla = teclapres.keyCode;
	vr = RemoveNoNumeric(Campo.value);
	tam = vr.length + 1;

	if ( (tecla >= 48 && tecla <= 57) || (tecla >= 96 && tecla <= 105 ) ){
		if ( tam > 2 && tam < 5 )
			Campo.value = vr.substr( 0, 2  ) + '/' + vr.substr( 2, 2 );
		if ( tam >= 5 && tam <= 10 )
			Campo.value = vr.substr( 0, 2 ) + '/' + vr.substr( 2, 2 ) + '/' + vr.substr( 4, 4 ); 
	}
	else {
		if (tecla != 8 && tecla != 9 && tecla != 13){
			tam = Campo.value.length;
			vr = RemoveNoNumeric(Campo.value);
			Campo.value = vr.substr(0, tam - 1);
		}
	
	}
}

function FormataData2(Campo,teclapres) {
	if (nets) {tecla = teclapres.which;} else {tecla = teclapres.keyCode;}
	vr = RemoveNoNumeric(Campo.value);
	tam = vr.length;
	if ( tecla >= 48 && tecla <= 57 ){
		if ( tam >= 8 ) {
			Campo.value = vr.substr( 0, 2 ) + '/' + vr.substr( 2, 2 ) + '/' + vr.substr( 4, 4 ); 
		}
	}
	else{
		if (tecla != 9 && tecla != 13){
			tam = Campo.value.length;
			vr = RemoveNoNumeric(Campo.value);
			Campo.value = vr.substr(0, tam - 1);
		}
	}
}
function FormataDataBlur(Campo) {
	vr = RemoveNoNumeric(Campo.value);
	tam = vr.length;
		if ( tam == 8 ) {
			Campo.value = vr.substr( 0, 2 ) + '/' + vr.substr( 2, 2 ) + '/' + vr.substr( 4, 4 ); 
		}
}

function FormataCEP(Campo,teclapres) {
   if (versao >= 5 || msie) {
      FormataCEP1(Campo, teclapres);
   } else {
      FormataCEP2(Campo, teclapres);
   }
}

function FormataCEP1(Campo,teclapres) {
	var tecla = teclapres.keyCode;
	vr = RemoveNoNumeric(Campo.value);
	tam = vr.length + 1;
        if (tecla == 8) return true;
	if ( tam >= 6 )
	  Campo.value = vr.substr( 0, 5 ) + '-' + vr.substr( 5,3 ); 
        else Campo.value = vr;
}

function FormataCEP2(Campo,teclapres) {
	if (nets) {tecla = teclapres.which;} else {tecla = teclapres.keyCode;}
	vr = RemoveNoNumeric(Campo.value);
	tam = vr.length;
	if (tecla == 8) return true;
	if ( tam >= 8 ) 
	  Campo.value = vr.substr( 0, 5 ) + '-' + vr.substr( 5, 3 ); 
	else Campo.value = vr;
}

function FormataDDD(Campo,teclapres) {
	var tecla = teclapres.keyCode;
	vr = RemoveNoNumeric(Campo.value);
	tam = vr.length + 1;
        if (tecla == 8) return true;
	if ( tam > 0 )
	  Campo.value = '(' + vr.substr( 0, 2 ) + ')' + vr.substr( 2,12 ); 
    else Campo.value = vr;
}


//verifica validade de e-mail
function verifica_email(valor){
  if (valor.value != ""){
	email = valor.value;
    for (i=0; i < email.length; i++) {
        if (email.charAt(i) != "@") {
            email_valido = false;
		}
		else{
    		email_valido = true;
			return;
	    }
    }
	alert('Endereço eletrônico inválido!');

	valor.value="";
	valor.focus();
  }
}


// Formata campos com numeracao de CNPJ, chamando as funcões FormataCNPJ1 ou FormataCNPJ2,
//dependendo do browse
function FormataCNPJ(Campo,teclapres) {
   if (versao >= 5 || msie) {
      FormataCNPJ1(Campo, teclapres);
   } else {
      FormataCNPJ2(Campo, teclapres);
   }
}

function FormataCNPJ1(Campo,teclapres) {
	var tecla = teclapres.keyCode;
	vr = RemoveNoNumeric(Campo.value);
	tam = vr.length + 1;
	if (tecla == 8) return true;
	if (tam <=2)
	  Campo.value = vr;
	else if ( tam > 2 && tam < 5 )
	  Campo.value = vr.substr( 0, 2  ) + '.' + vr.substr( 2, 3 );
	else if ( tam >= 5 && tam <= 7 )
	  Campo.value = vr.substr( 0, 2 ) + '.' + vr.substr( 2, 3 ) + '.' + vr.substr( 5,3 ); 
	else if ( tam >= 7 && tam <= 10 )
	  Campo.value = vr.substr( 0, 2 ) + '.' + vr.substr( 2, 3 ) + '.' + vr.substr( 5,3 ) + '/' + vr.substr( 8,4 ); 
	else if ( tam >= 11 )
	  Campo.value = vr.substr( 0, 2 ) + '.' + vr.substr( 2, 3 ) + '.' + vr.substr( 5,3 ) + '/' + vr.substr( 8,4 )+ '-' + vr.substr( 12,2 );  
}

function FormataCNPJ2(Campo,teclapres) {
	if (nets) {tecla = teclapres.which;} else {tecla = teclapres.keyCode;}
	vr = RemoveNoNumeric(Campo.value);
	tam = vr.length;

	if (tecla == 8) return true;
	if ( tam >= 13 ) 
	  Campo.value = vr.substr( 0, 2 ) + '.' + vr.substr( 2, 3 ) + '.' + vr.substr( 5,3 ) + '/' + vr.substr( 8,4 )+ '/' + vr.substr( 12,2 ); 
	else Campo.value = vr;
}

// verifica se o CNPJ foi completamente digitado
function verificaCNPJ(valor){
	if (valor.value != "") {
    	tam = valor.value;
	    if (tam.length < 18) {
 	     	alert('CNPJ incompleto!')
			valor.value = "";
			valor.focus();
		}
	}
}

// Formata campos com numeracao de CPF, chamando as funcões FormataCPF1 ou FormataCPF2,
//dependendo do browse
function FormataCPF(Campo,teclapres) {
   if (versao >= 5 || msie) {
      FormataCPF1(Campo, teclapres);
   } else {
      FormataCPF2(Campo, teclapres);
   }
}

function FormataSIAPE(Campo,teclapres) {
	var tecla = teclapres.keyCode;
	vr = RemoveNoNumeric(Campo.value);
	tam = vr.length + 1;
	if (tecla == 8) return true;
	if (tam <=1)
	  Campo.value = vr;
	else if ( tam > 1 && tam <= 4 )
	  Campo.value = vr.substr( 0, 1 ) + '.' + vr.substr( 1, 3 );
	else if ( tam > 4 && tam <= 7 )
	  Campo.value = vr.substr( 0, 1 ) + '.' + vr.substr( 1, 3 ) + '.' + vr.substr( 4,3 ); 
}

function FormataCPF1(Campo,teclapres) {
	var tecla = teclapres.keyCode;
	vr = RemoveNoNumeric(Campo.value);
	tam = vr.length + 1;
	if (tecla == 8) return true;
	if (tam <=3)
	  Campo.value = vr;
	else if ( tam > 3 && tam < 6 )
	  Campo.value = vr.substr( 0, 3  ) + '.' + vr.substr( 3, 3 );
	else if ( tam >= 6 && tam <= 8 )
	  Campo.value = vr.substr( 0, 3 ) + '.' + vr.substr( 3, 3 ) + '.' + vr.substr( 6,3 ); 
	else if ( tam > 8 && tam <= 11 )
	  Campo.value = vr.substr( 0, 3 ) + '.' + vr.substr( 3, 3 ) + '.' + vr.substr( 6,3 ) + '-' + vr.substr( 9,2 ); 
}

function FormataCPF2(Campo,teclapres) {
	if (nets) {tecla = teclapres.which;} else {tecla = teclapres.keyCode;}
	vr = RemoveNoNumeric(Campo.value);
	tam = vr.length;

	if (tecla == 8) return true;
	if ( tam >= 10 ) 
	  Campo.value = vr.substr( 0, 3 ) + '.' + vr.substr( 3, 3 ) + '.' + vr.substr( 6,3 ) + '-' + vr.substr( 9,2 ); 
	else Campo.value = vr;
}

// verifica se o CPF foi completamente digitado
function verificaCPF(valor){
	if (valor.value != "") {
    	tam = valor.value;
	    if (tam.length < 14) {
 	     	alert('CPF incompleto!')
			valor.value = "";
			valor.focus();
			return false;
		}
		else return true;
	}
	else return false;
}

// valida o número do CPF
function validaCPF (valor){
	if (verificaCPF(valor)){
		cpf = RemoveNoNumeric(valor.value);
		soma = parseInt(cpf.substr(0,1)*10) + parseInt(cpf.substr(1,1)*9) + parseInt(cpf.substr(2,1)*8) + 
			   parseInt(cpf.substr(3,1)*7) + parseInt(cpf.substr(4,1)*6) + parseInt(cpf.substr(5,1)*5) + parseInt(cpf.substr(6,1)*4) + 
			   parseInt(cpf.substr(7,1)*3) + parseInt(cpf.substr(8,1)*2);
		resto = soma - (11 * Math.floor(soma / 11));
		if (resto == 0 || resto == 1) 
			DV = 0;
		else
			DV = 11 - resto;
		if (DV != cpf.substr(9,1)){
			alert('CPF inválido!');
			valor.value = '';
			valor.focus();
			return false;
		  }
		else{
			soma = parseInt(cpf.substr(0,1)*11) + parseInt(cpf.substr(1,1)*10) + parseInt(cpf.substr(2,1)*9) + 
				   parseInt(cpf.substr(3,1)*8) + parseInt(cpf.substr(4,1)*7) + parseInt(cpf.substr(5,1)*6) + parseInt(cpf.substr(6,1)*5) + 
				   parseInt(cpf.substr(7,1)*4) + parseInt(cpf.substr(8,1)*3) + parseInt(cpf.substr(9,1)*2);
			resto = soma - (11 * Math.floor(soma / 11));
			if (resto == 0 || resto == 1) 
				DV = 0;
			else
				DV = 11 - resto;
			if (DV != cpf.substr(10,1)){
				alert('CPF inválido!');
				valor.value = '';
				valor.focus();
				return false;
			}
		}
	}
}

function FormataProcessoJF1(Campo,teclapres) {
	var tecla = teclapres.keyCode;
	vr = RemoveNoNumeric(Campo.value);
	tam = vr.length;
	if (tecla == 8) return true;
	//alert(tam);
	if (tam <=4)
	  Campo.value = vr;
	else if ( tam > 4 && tam <= 6 )
	  Campo.value = vr.substr( 0, 4 ) + '.' + vr.substr( 4, 2 );
	else if ( tam > 6 && tam <= 8 )
	  Campo.value = vr.substr( 0, 4 ) + '.' + vr.substr( 4, 2 ) + '.' + vr.substr( 6, 2 ); 
	else if ( tam > 8 && tam <= 14 )
	  Campo.value = vr.substr( 0, 4 ) + '.' + vr.substr( 4, 2 ) + '.' + vr.substr( 6, 2 ) + '.' + vr.substr( 8, 6 ); 
	else if (tam == 15)
	  Campo.value = vr.substr( 0, 4 ) + '.' + vr.substr( 4, 2 ) + '.' + vr.substr( 6, 2 ) + '.' + vr.substr( 8, 6 ) + '-' + vr.substr( 14, 1 ); 
}

function FormataProcessoJF2(Campo,teclapres) {
	var tecla = teclapres.keyCode;
	vr = RemoveNoNumeric(Campo.value);
	tam = vr.length + 1;
	if (tecla == 8) return true;
	if (tam <=2)
	  Campo.value = vr;
	else if ( tam > 2 && tam <= 5 )
	  Campo.value = vr.substr( 0, 2 ) + '.' + vr.substr( 2, 3 );
	else if ( tam > 5 && tam <= 9 )
	  Campo.value = vr.substr( 0, 2 ) + '.' + vr.substr( 2, 3 ) + '.' + vr.substr( 5, 4 ); 
	else if (tam == 10)
	  Campo.value = vr.substr( 0, 2 ) + '.' + vr.substr( 2, 3 ) + '.' + vr.substr( 5, 4 ) + '-' + vr.substr( 9, 1 ); 
}

function FormataProcessoJT(Campo,teclapres) {
	var tecla = teclapres.keyCode;
	vr = Removeponto(Campo.value);
	tam = vr.length + 1;
	if (tecla == 8) return true;
	if (tam <=4)
	  Campo.value = vr;
	else if ( tam > 4 && tam <= 6 )
	  Campo.value = vr.substr( 0, 4 ) + '.' + vr.substr( 4, 2 );
	else if (tam == 10)
	  Campo.value = vr.substr( 0, 4 ) + '.' + vr.substr( 4, 2 ) + '/' + vr.substr( 6, 40 ); 
}

// valida o número do CNPJ
function validaCNPJ (valor){
	if (verificaCNPJ(valor)){
		cnpj = RemoveNoNumeric(valor.value);
		soma = parseInt(cnpj.substr(0,1)*5) + parseInt(cnpj.substr(1,1)*4) + parseInt(cnpj.substr(2,1)*3) + 
			   parseInt(cnpj.substr(3,1)*2) + parseInt(cnpj.substr(4,1)*9) + parseInt(cnpj.substr(5,1)*8) + 
			   parseInt(cnpj.substr(6,1)*7) + parseInt(cnpj.substr(7,1)*6) + parseInt(cnpj.substr(8,1)*5) + 
			   parseInt(cnpj.substr(9,1)*4) + parseInt(cnpj.substr(10,1)*3) + parseInt(cnpj.substr(11,1)*2);
		resto = soma - (11 * Math.floor(soma / 11));
		if (resto == 0 || resto == 1) 
			DV = 0;
		else
			DV = 11 - resto;
		if (DV != cnpj.substr(12,1)){
			alert('CNPJ inválido!');
			valor.value = '';
			valor.focus();
			return false;
		  }
		else{
			soma = parseInt(cnpj.substr(0,1)*6) + parseInt(cnpj.substr(1,1)*5) + parseInt(cnpj.substr(2,1)*4) + 
				   parseInt(cnpj.substr(3,1)*3) + parseInt(cnpj.substr(4,1)*2) + parseInt(cnpj.substr(5,1)*9) + 
				   parseInt(cnpj.substr(6,1)*8) + parseInt(cnpj.substr(7,1)*7) + parseInt(cnpj.substr(8,1)*6) + 
				   parseInt(cnpj.substr(9,1)*5) + parseInt(cnpj.substr(10,1)*4) + parseInt(cnpj.substr(11,1)*3) +
				   DV * 2;
			resto = soma - (11 * Math.floor(soma / 11));
			if (resto == 0 || resto == 1) 
				DV = 0;
			else
				DV = 11 - resto;
			if (DV != cnpj.substr(13,1)){
				alert('CNPJ inválido!');
				valor.value = '';
				valor.focus();
				return false;
			}
		}
	}
}

//FUNÇÃO PARA FORMATAR VALOR NUMÉRICO, deve ser chamado no OnBlur
function FormataNumero(obj){
   vr = obj.value;
   tam = vr.length;
   vr = RemoveNoNumericForFloat(vr);
   for (tam = 0; tam < vr.length && vr.charAt(tam) != "," ; tam++);
   for (i = tam-3; i > 0; i -= 3){
      vr = vr.substr(0, i) + '.' + vr.substr(i, 15);
   }
   obj.value = vr;
}


// Formata o campo na forma decimal, tendo como parametros o nome do campo,
// o comando event, o comprimento da parte inteira e o da decimal (chamada no evento onkeyup)
function Formatadecimal(Campo,teclapres,inteiro,decimal) {
	var tecla = teclapres.keyCode;
	//decimal = dec;
	//inteiro = int;
	vr = Campo.value;
	vr = vr.replace( ".", "" );
	vr = vr.replace( ",", "" );
	tam = vr.length;
     
	if (tam > 0){
	  if (tam <= inteiro)
	    Campo.value = vr ;
	  else
	    Campo.value = vr.substr(0 , inteiro) + ',' + vr.substr(inteiro,decimal)
	Campo.focus();
	}
}

// Completa o numero com zeros, passando-se como parametros o nome do campo e o comprimento
// da parte decimal (chamada no evento onblur)
function Completadecimal(campo,dec) {
	valor = campo.value;
	if (valor != "") {
		casas_decimais = "";
		for (x = 0 ; x < dec ; x++) { 
			casas_decimais = casas_decimais + "0";
		}
		virgula = "";
		for (x = 0 ; x < valor.length ; x++) {
			if (valor.charAt(x) == ",") 
				virgula = "virgula";
		} 		

		if (virgula != "virgula")
			campo.value = valor + "," + casas_decimais
		}
}

function anobissexto(ano){
   if (ano % 100 == 0) {
      if (ano % 400 == 0) { return true; }
  }
  else {
    if ((ano % 4) == 0) { return true; }
}
return false;

}

function chdata(xcampo){
    
	var campo = xcampo.value
	var datavalida = true;
	var quatro = true;
	if (campo!=""){
	  if (campo.length != 10)
		datavalida = false	
	  else {	
		dia = (campo.substr(0, 2));
		mes = (campo.substr(3, 2));
		ano = (campo.substr(6, 4));
		if (anobissexto(ano) == true)
		  var dias = new Array(31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31)
		else
		  var dias = new Array(31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31);
		if (ano < 1000){
		  quatro = false;
		}
		if ((ano < 1) || (ano > 9999)) {
		    datavalida = false;
		} else
		   if ((mes < 1) || (mes > 12)) {
		      datavalida = false;
		   } else
		      if ((dia < 1) || (dia > dias[mes-1])) {
		            datavalida = false;
		      }
	  }	      
	}
	if (datavalida == false) {
	  alert('Data informada está inválida');
	  xcampo.value = "";
	  xcampo.focus();	  
	}
	else if (quatro == false) {
	  alert('Informe o ano com 4 dígitos');
	  xcampo.value = "";
	  xcampo.focus();
	}
	return datavalida;
}
	
// Compara 2 campos numéricos para crítica
function compara_campos(tipo,menor,maior,str_menor,str_maior,campo){
	var valor1 = parseInt(menor);
	var valor2 = parseInt(maior);

	if ((menor!="") && (maior!="")){
		falso = true
		if (valor2>=valor1)
			falso = false;
		if (falso) {
			if (tipo=="menor"){
				alert(''+str_menor+' deve ser no máximo igual a '+str_maior+' ('+valor2+')');
				}
			else	{
				alert(''+str_maior+' deve ser no mínimo igual a '+str_menor+' ('+valor1+')');
				}
			if (falso==true){
				campo.value = "";
				campo.focus();
				return false
			}
			else return true}
	}	
}

	
//Compara 2 datas para crítica
function compara_data(tipo,data_anterior,data_posterior,str_data_anterior,str_data_posterior){
	var data1 = data_anterior.value
	var data2 = data_posterior.value
	
	if (data1!=""){
		dia1 = (data1.substr(0, 2));
		mes1 = (data1.substr(3, 2));
		ano1 = (data1.substr(6, 4)); 
	   
		if (data2!=""){
			dia2 = (data2.substr(0, 2));
			mes2 = (data2.substr(3, 2));
			ano2 = (data2.substr(6, 4));   
		  	
			checagem = false  
			if (ano2>ano1)
				{
				checagem = true;
				}
			else {
				if (ano2==ano1)
					{
					if (mes2>mes1)
						{
						checagem = true;
						}
					else {
						if (mes2==mes1)
							{
							if (dia2>=dia1)
								{
								checagem = true;
								}
							}
						}	
					}
					}
			if (checagem==false) {
				if (tipo=="anterior"){
					alert(''+str_data_anterior + ' deve ser no máximo igual à ' + str_data_posterior + ' (' + dia2 + '/' + mes2 + '/' + ano2 + ')' );
					data_anterior.value = "";
					data_anterior.focus();
					}
				else	{
					alert(''+str_data_posterior+' deve ser no mínimo igual à '+str_data_anterior+' ('+dia1+'/'+mes1+'/'+ano1+')');
					data_posterior.value = "";
					data_posterior.focus();
					}
				if (checagem==false)
					return false
				else return true}
			}
		}	
		
}


//Compara data com a data atual
function compara_data_com_hoje(data_anterior,str_data_anterior){
	var data1 = data_anterior.value
	
	if (data1!="")
	{
		dia2 = (data1.substr(0, 2));
		mes2 = (data1.substr(3, 2));
		ano2 = (data1.substr(6, 4)); 
	   
		thedate = new Date();
		mes1 = thedate.getMonth()+1;
		dia1 = thedate.getDate();
		ano1 = thedate.getYear();
                if (ano1 < 1900) {
                   ano1 = ano1 + 1900;
                }
		  	
		checagem = false  
		if (ano2>ano1)
			checagem = true;
		else {
			if (ano2==ano1){
				if (mes2>mes1)
					checagem = true;
				else {
					if (mes2==mes1){
						if (dia2>=dia1)
							checagem = true;
					}	
				     }
				}
			
			}
		if (checagem==false) {
			alert(''+str_data_anterior+' deve ser no mínimo igual à data de hoje ('+dia1+'/'+mes1+'/'+ano1+')');
			data_anterior.value = "";
			data_anterior.focus();
			}
	}	
	//return true;	
}

//Compara data com a data atual e não pode ser maior que hoje + 48 horas úteis
function compara_data_com_hoje_2(data_anterior,str_data_anterior){
	var data1 = data_anterior.value
		
	if (data1!="")
	{
// TESTANDO COM HOJE
		dia2 = (data1.substr(0, 2));
		mes2 = (data1.substr(3, 2));
		ano2 = (data1.substr(6, 4));
		if (dia2.substr(0,1) == "0"){dia2 = dia2.substr(1,1);}
		if (mes2.substr(0,1) == "0"){mes2 = mes2.substr(1,1);}
		dataAtual = new Date(parseInt(ano2), parseInt(mes2)-1, parseInt(dia2), 23, 59, 59);
		Hoje = new Date();
		dia1 = Hoje.getDate();
		mes1 = Hoje.getMonth()+1;
		ano1 = Hoje.getFullYear();
		if (dia1 < 10) {dia1= "0" + dia1}
		if (mes1 < 10) {mes1= "0" + mes1}
		if (dataAtual < Hoje) {
			alert(''+str_data_anterior+' deve ser no mínimo igual à data de hoje ('+dia1+'/'+mes1+'/'+ano1+')');
			data_anterior.value = "";
			data_anterior.focus();
			}
		
// TESTANDO COM HOJE + 2 DIAS ÚTEIS
//		Use para testar se está pulando fim de semanas e feriados
//		dataLimite = new Date(parseInt(2004),parseInt(9),parseInt(29),0,0,0);
		dataAtual = new Date(parseInt(ano2), parseInt(mes2)-1, parseInt(dia2), 0, 0, 0);
		dataLimite = new Date();
		diasuteis = 0;
		while (diasuteis < 2){
			dataLimite.setDate(dataLimite.getDate()+1);
			diaLimite = dataLimite.getDate();
			mesLimite = dataLimite.getMonth()+1;
			data = diaLimite.toString() + '/' + mesLimite.toString();
			if  ((dataLimite.getDay() != 0)
				&& (dataLimite.getDay() != 6)
				&& (data != '1/1')
				&& (data != '21/4')
				&& (data != '7/9')
				&& (data != '12/10')
				&& (data != '2/11')
				&& (data != '15/11')
				&& (data != '25/12')
				) {diasuteis= diasuteis + 1}
		}		
		anoLimite = dataLimite.getFullYear(); 
		if (diaLimite < 10) {diaLimite= "0" + diaLimite}
		if (mesLimite < 10) {mesLimite= "0" + mesLimite}		
		if (dataAtual > dataLimite) {
			alert(''+str_data_anterior+' deve ser no máximo igual à data de hoje mais 2 dias úteis ('+diaLimite+'/'+mesLimite+'/'+anoLimite+')');
			data_anterior.value = "";
			data_anterior.focus();
			}		
	}
}

// Posiciona o foco no primeiro campo texto da página
function placeFocus() {
   if (document.forms.length > 0) {
      var field = document.forms[0];
      for (i = 0; i < field.length; i++) {
         if ((field.elements[i].type == "text") || (field.elements[i].type == "textarea") || (field.elements[i].type.toString().charAt(0) == "s")) {
           document.forms[0].elements[i].focus();
           break;
         }
      }
   }
}

//<!-- STEP TWO: Insert the onLoad event handler into your BODY tag  -->

//<BODY OnLoad="placeFocus()">


//FUNÇ+O QUE CALCULA A SEMANA EPIDEMIOLÓGICA
function calcula_semana_epid(data, campo){
if (data.value == '')
	campo.value = '';
else { 
    	str_data = data.value;
//	if (str_data.lenght == 10) {
	valor_data = data.value.substr(3,3) + data.value.substr(0,3) + data.value.substr(6,4);
	ano = valor_data.substr(6,4);
	ano = parseInt(ano)+1;
	semana = 0;
	while (semana == 0){
		valor_data = data.value.substr(3,3) + data.value.substr(0,3) + data.value.substr(6,4);
		ano = ano - 1;
		novadata = new Date('01/01/'+ano);
		dia_semana = novadata.getDay();
		switch (dia_semana){							
			case 0: data_inicio = '01/01/' + ano; break;
			case 1: data_inicio='12/31/'+(ano-1); break;
			case 2: data_inicio='12/30/'+(ano-1); break;
			case 3: data_inicio='12/29/'+(ano-1); break;
			case 4: data_inicio='01/04/'+ano; break;
			case 5: data_inicio='01/03/'+ano; break;
			case 6: data_inicio='01/02/'+ano; break;
		}

		novadata = new Date('12/31/'+ano);
		dia_semana = novadata.getDay();
		switch (dia_semana){
			case 0: data_fim='12/30/'+ano; break;
			case 1: data_fim='12/29/'+ano; break;
			case 2: data_fim='12/28/'+ano; break;
			case 3: data_fim='01/03/'+(ano+1); break;
			case 4: data_fim='01/02/'+(ano+1); break;
			case 5: data_fim='01/01/'+(ano+1); break;
			case 6: data_fim='12/31/'+ano; break;
		}
		

		if (Date.parse(valor_data) > Date.parse(data_fim)){
			ano = ano+1;
			semana = 1;
			}
		else if (Date.parse(valor_data) < Date.parse(data_inicio)) {
			semana = 0;
			}	
		else {	
			semana = (((Date.parse(valor_data) - Date.parse(data_inicio))/86400000)/7) + 1;  //86400000 é 1 dia em milissegundos;
			semana = Math.floor(semana);
			}
		if (semana < 10)
  			semana = '0'+semana;
	}
	campo.value = semana+'/'+ano;	
//	}
}
}


//FUNÇ+O QUE CALCULA A QUINZENA
function quinzena(data, campo){
if (data.value == '')
	campo.value = '';
else { 
    	str_data = data.value;
	valor_data = data.value.substr(3,3) + data.value.substr(0,3) + data.value.substr(6,4);
	ano = valor_data.substr(6,4);
	ano = parseInt(ano)+1;
	semana = 0;
	while (semana == 0){
		valor_data = data.value.substr(3,3) + data.value.substr(0,3) + data.value.substr(6,4);
		ano = ano - 1;
		novadata = new Date('01/01/'+ano);
		dia_semana = novadata.getDay();
		switch (dia_semana){							
			case 0: data_inicio = '01/01/' + ano; break;
			case 1: data_inicio='12/31/'+(ano-1); break;
			case 2: data_inicio='12/30/'+(ano-1); break;
			case 3: data_inicio='12/29/'+(ano-1); break;
			case 4: data_inicio='01/04/'+ano; break;
			case 5: data_inicio='01/03/'+ano; break;
			case 6: data_inicio='01/02/'+ano; break;
		}

		novadata = new Date('12/31/'+ano);
		dia_semana = novadata.getDay();
		switch (dia_semana){
			case 0: data_fim='12/30/'+ano; break;
			case 1: data_fim='12/29/'+ano; break;
			case 2: data_fim='12/28/'+ano; break;
			case 3: data_fim='01/03/'+(ano+1); break;
			case 4: data_fim='01/02/'+(ano+1); break;
			case 5: data_fim='01/01/'+(ano+1); break;
			case 6: data_fim='12/31/'+ano; break;
		}
		

		if (Date.parse(valor_data) > Date.parse(data_fim)){
			ano = ano+1;
			semana = 1;
			}
		else if (Date.parse(valor_data) < Date.parse(data_inicio)) {
			semana = 0;
			}	
		else {	
			semana = (((Date.parse(valor_data) - Date.parse(data_inicio))/86400000)/7) + 1;  //86400000 é 1 dia em milissegundos;
			semana = Math.floor(semana);
			}
		if (semana < 10)
  			semana = '0'+semana;
	}

	if (parseInt(semana) % 2 == 0)
		campo.value = (parseInt(semana) / 2) +'/'+ano;
	else
		campo.value = round(parseInt(semana) / 2) +'/'+ano;

}
}


//FUNÇ+O QUE CALCULA O M-S EM QUEST+O
function calcula_mes(data, campo){
if (data.value == '')
	campo.value = '';
else { 
    	str_data = data.value;
	campo.value = srt_data.substr(3,5);	
	}

}


//FUNÇ+O QUE CALCULA O BIMESTRE EM QUEST+O
function calcula_bimestre(data, campo){
	if (data.value == '')
		campo.value = '';
	else { 
    		str_data = data.value;
		mes = str_data.substr(3,5);	
		if (parseInt(mes) % 2 == 0)
			campo.value = parseInt(mes) / 2;
		else
			campo.value = round(parseInt(mes) / 2);
	}
}



// Passa o foco adiante, dando a impressão de que o campo está desabilitado
function perde_foco(campo){
//alert("campo: "+ campo);
campo.focus()
}


// Calcula as datas inicial e final dada a semana epidemiológica (o formato do campo passado como //parâmetro deve ser "00/0000")
function datas_semana(semepid){

	ano = semepid.value.substr(3,4);
	semana_epid = parseInt(semepid.value.substr(0,2));
	if (semana_epid == '00'){
		semana_epid = '01';
		semepid.value = semana_epid+'/'+ano;
	}
	novadata = new Date('01/01/'+ano);
	dia_semana = novadata.getDay();
	switch (dia_semana){							
		case 0: data_inicio = '01/01/' + ano; break;
		case 1: data_inicio = '12/31/'+(ano-1); break;
		case 2: data_inicio = '12/30/'+(ano-1); break;
		case 3: data_inicio = '12/29/'+(ano-1); break;
		case 4: data_inicio = '01/04/'+ano; break;
		case 5: data_inicio = '01/03/'+ano; break;
		case 6: data_inicio = '01/02/'+ano; break;
	}

	novadata = new Date('12/31/'+ano);
	dia_semana = novadata.getDay();
	switch (dia_semana){
		case 0: data_fim='12/30/'+ano; break;
		case 1: data_fim='12/29/'+ano; break;
		case 2: data_fim='12/28/'+ano; break;
		case 3: data_fim='01/03/'+(ano+1); break;
		case 4: data_fim='01/02/'+(ano+1); break;
		case 5: data_fim='01/01/'+(ano+1); break;
		case 6: data_fim='12/31/'+ano; break;
	}
		
	data_inicio_semana = Date.parse(data_inicio);
	data_fim_semana = Date.parse(data_inicio) + 518400000;
	for(semana = 1; semana < semana_epid; semana++) {
		data_inicio_semana = data_inicio_semana + 604800000;
		data_fim_semana = data_fim_semana + 604800000;
	}	

	if (data_fim_semana > Date.parse(data_fim))
		alert('O ano em questão não possui semana ' + semana_epid)

	else{
		valdatainicio = new Date();
		valdatafim = new Date();
		valdatainicio.setTime(data_inicio_semana);
		valdatafim.setTime(data_fim_semana);
	
		dia = valdatainicio.getDate();
		if (dia < 10) 
			dia = '0' + dia;
		mes = valdatainicio.getMonth() + 1;
		if (mes < 10) 
			mes = '0' + mes;
		ano = valdatainicio.getYear();
		
		alert('início: '+ dia+'/'+mes+'/'+ano);
		
		dia = valdatafim.getDate();
		if (dia < 10) 
			dia = '0' + dia;
		mes = valdatafim.getMonth() + 1;
		if (mes < 10) 
			mes = '0' + mes;
		ano = valdatafim.getYear();

		alert('fim: '+ dia+'/'+mes+'/'+ano);
	}
}

// Critica presença de letras em campos numericos (pode conter virgula)
function campo_num(campo) {
	texto = campo.value;
	num = "true";
	virgula = "";
	if (texto != "") {
		for (i = 0 ; i <= texto.length-1; i++) {
			sub_texto = texto.substring(i,i+1);
			if (sub_texto == "1" || sub_texto == "2" ||sub_texto == "3" ||sub_texto == "4" ||sub_texto == "5" ||sub_texto == "6" ||sub_texto == "7" ||sub_texto == "8" ||sub_texto == "9" ||sub_texto == "0" ) {
				num = "true";
			}	
			else if ((sub_texto ==",") || (sub_texto ==".")) {
				virgula = "virgula"
			}
			else {
				alert("Este campo deve conter apenas caracteres numéricos");
				campo.value = "";
				campo.focus();
				campo.select();
				return false
			}
		}
		if (virgula == "virgula") {
			campo.value = texto.replace(",", ".");
			return true
		}
		if (num == "true"){
			return true
		}
	}	
}


// Critica presença de letras em campos numericos (não pode conter virgula)
function campo_num_int(campo) {
	texto = campo.value;
	num = "true";
	if (texto != "") {
		for (i = 0 ; i <= texto.length-1; i++) {
			sub_texto = texto.substring(i,i+1);
			if (sub_texto == "1" || sub_texto == "2" ||sub_texto == "3" ||sub_texto == "4" ||sub_texto == "5" ||sub_texto == "6" ||sub_texto == "7" ||sub_texto == "8" ||sub_texto == "9" ||sub_texto == "0" ) {
				num = "true";
			}	
			else {
				alert("Este campo deve conter apenas caracteres numéricos");
				campo.value = "";
				campo.focus();
				campo.select();
				return false
			}
		}
		if (num == "true"){
			return true
		}
	}	
}





//Função para emular a tecla TAB
nextfield='';
function keyDown(DnEvents) { // processa a tecla pressionada
   // identifica o browser
   tp = (nets) ? DnEvents.target.type : window.event.srcElement.type;
   k = (nets) ? DnEvents.which : window.event.keyCode;
   if (k == 13 && tp != "textarea") { // tecla enter pressionada
      if (nextfield == 'done') return true; // submit, terminados os campos
      else { // não terminada ainda, posiciona o foco no próximo campo
           //alert('Para navegar entre os campos, utilize a tecla TAB');
           return false;
           } 
      }
}

if (msie) {
	document.onkeydown = keyDown; 
}


function showobject(obj){
var i;
var result = "<html><body>\n";
   for (var i in obj) {
      result += "obj." + i + "=" + obj[i] + "<br>\n";
   }
   result = result + "</body></html>";
   w = window.open('', 'property', '');
   w.document.write(result);
//   alert(result);
}



// função para mover elementos de uma lista para outra lista
function movelist(ori, des){
	for (i=ori.length-1; i >= 0; i--){
		if ( ori.options[i].selected ) {
			des.options[des.length] = new Option(ori.options[i].text, ori.options[i].value, false, false);
			ori.options[i] = null;
		} // if
	} // for
	// ordena o destino
	for (i = des.length-1; i >= 0; i--) {
		for (k = 0 ; k < i; k++) {
			if (des.options[k].text > des.options[i].text ){
				o = new Option(des.options[i].text, des.options[i].value, false, false);
				des.options[i].value = des.options[k].value;
				des.options[i].text = des.options[k].text;
				des.options[k].value = o.value;
				des.options[k].text = o.text;
			} // if
		} // for
	} // for
}  // function

// funcao para limpar o conteudo de um object SELECT
function limpacombo(obj){
var i;
   for (i = obj.length - 1; i > 0; i--)
      obj.options[i] = null;
   return false;
}

function copiacombo(cd, tx, obj){
var i;
   if (tx.type && tx.type.substr(0, 6)  == 'select')
      for (i=0; i < tx.length; i++) 
         obj.options[obj.length] = new Option(tx[i].text, tx[i].value, false, false);
   else
      for (i=0; i < cd.length; i++)
         obj.options[obj.length] = new Option(tx[i].value, cd[i].value, false, false);
    
   return false;
}


/*
@name Normalize
@description Retira os zeros da esquerda de uma string e a preenche com zeros à direita de forma
 que ela terá pelo menos três caracteres
@created 02/12/2003
@param valor: o valor a ser normalizado
@return a string normalizada

*/
function Normalize(valor)
{
	var number;
	var vlNormalizado;

	// verifique se o valor é zero - eu testo se o valor é vazio porque se eu converter vazio para um número
	// o resultado é zero
	if (new Number(valor).valueOf() == 0 && valor != "")
	{
		return "000";
	}
	else
	{
		// tire os zeros da esquerda do número
		while(valor.substr(0,1) == "0")
			valor = valor.substr(1, valor.length - 1)

		// se o número só tiver 1 dígito, preencha-o com 2 zeros à esquerda
		if (valor.length == 1)
			vlNormalizado = "00" + valor;
		// se o número tiver 2 dígitos, preencha-o com 1 dígito à esquerda
		else if (valor.length == 2)
			vlNormalizado = "0" + valor;
		// se o número tiver mais do que 2 dígitos, ele já está normalizado
		else
			vlNormalizado = valor;

		return vlNormalizado;
	}

}

//*************************************************************************************************************
/**
@name pfnFormataMoeda
@description Formata um número como moeda à medida que ele é digitado
 Não impede o usuário de teclar dígitos, apenas não realiza a formatação caso a tecla digitada não seja um dígito
@created 02/12/2003
@param field: o campo onde o número está sendo digitado
@return Não retorna nada

*/
function pfnFormataMoeda(field)
{
	// só prossiga se a tecla pressionada foi um dígito ou a tecla BACKSPACE e caso haja algum valor inserido no campo
	if (((event.keyCode >= 48 && event.keyCode <= 57) || (event.keyCode >= 96 && event.keyCode <= 105) || event.keyCode == 8 || event.keyCode == 46) && field.value.length != 0)
	{
		pfnFormateMoedaOnBlur(field);
	}
}


//*************************************************************************************************************
/**
@name pfnFormateMoedaOnBlur
@description Formata um campo como moeda (usado no evento onBlur)
@created 04/02/2004
@param field: o campo onde o número que deve ser formatado está
@return Não retorna nada

*/
function pfnFormateMoedaOnBlur(field)
{
	field.value = pfnFormateValorMoeda(field.value);
}


//*************************************************************************************************************
/**
@name pfnFormateValorMoeda
@description Formata um número como moeda
@created 04/02/2004
@param valor: o valor a ser formatado
@return O valor formatado

*/
function pfnFormateValorMoeda(valor_)
{
	// a próxima conversão é para compatibilidade com páginas em vbscript, para ter certeza que valor será
	// uma string UTF-8
	var valor;
	valor = new String(valor_);
	
	// o valor digitado sem formatação
	var valorSemFormatacao; 
	// o valor final a ser mostrado ao usuário
	var valorFinal;
	// o número de conjuntos de três números antes da parte decimal do número
	var casas;
	// determine o número de dígitos que sobram por não completar grupos de 3 dígitos 
	var casasIncompletas;
	// determina se o valor digitado é um número negativo
	var numeroNegativo = false;
	
	//tire qualquer espaço do começo e fim de valor
	valor = valor.replace(/(\s)*$|^(\s)*/g, "");
	
	// tire os pontos e troque as vírgulas pelos pontos para transformar o número brasileiro em um número americano
	valorSemFormatacao = pfnToNumeroAmericano(valor);
	
	// verifique se o número é válido
	if (isNaN(valorSemFormatacao))
		return valor;
	
	// verifique se o número é negativo
	if (valorSemFormatacao.substr(0, 1) == "-")
		numeroNegativo = true;

	// agora retire todos os pontos e traço (do número negativo) para formatá-lo
	valorSemFormatacao = valorSemFormatacao.replace(/[.-]/g, "");
		
	// o primeiro dígito que o usuário digita é especial - coloque os zeros à esquerda e saia
	if (valor.length == 1)
	{
		valor = "0,0" + valor;
		return valor;
	}
	
	// coloque ou tire os zeros necessários da esquerda
	valorSemFormatacao = Normalize(valorSemFormatacao);
	
	// aqui há outro caso especial: se o resultado dessa função é uma string vazia, então só
	// havia zeros na string digitada, então retorne um 0 formatado e saia
	if (valorSemFormatacao.length == 0)
	{
		valor = ""
		return valor;
	}
	
	// determine quantos conjuntos de três dígitos há no número
	// não leve em conta os dois últimos números dos centavos
	casas = Math.floor((valorSemFormatacao.length - 2)/3);
	casasIncompletas = (valorSemFormatacao.length - 2) % 3;

	// comece colocando os dígitos à esqeuerda do valor original que não completam um grupo de três dígitos
	valorFinal = valorSemFormatacao.substr(0, casasIncompletas);

	for (i = 0; i < casas; i++)
	{	
		// pegue grupos de 3 dígitos seguidos do valor original e adicione-os ao valor final acrescentando os pontos
		if (i != 0 || ( i == 0 && casasIncompletas > 0))
			valorFinal = valorFinal + ".";
		valorFinal = valorFinal + valorSemFormatacao.substr(casasIncompletas + i * 3, 3);
	}

	// termine colocando os dígitos equivalentes aos centavos
	valorFinal = valorFinal + "," + valorSemFormatacao.substr(valorSemFormatacao.length - 2, 2);
	
	// se o número for negativo, recoloque o sinal
	if (numeroNegativo)
		valorFinal = "-" + valorFinal;
		
	return valorFinal;
}

//*************************************************************************************************************
/**
@name pfnIsNumeric
@description Determina se a última tecla digitada no teclado é um dígito
@created 24/11/2003
@return true, se a tecla for um dígito, false, caso contrário

*/
function pfnIsNumeric()
{
    if (event.keyCode < 48 || event.keyCode > 57)
    {
        event.returnValue = false;
        return false;
    }
    else
    {
        event.returnValue = true;
        return true;
    }
}

//*************************************************************************************************************
/**
@name pfnValideFormateMoeda
@description Valida e formata um número. A validação verifica se o número contém apenas caracters numéricos 
 (dígitos, e opcionalmente pontos e uma vírgula), se ele é maior ou igual a zero e se ele é menor do que o 
 tamanho máximo permitido
@created 10/03/2004
@param valor: o número (ou string equivalente ao número) a ser validado
@param mensagemErro: a mensagem a ser exibida se a validação falhar
@return O número formatado, caso a validação tenha sucesso, ou o número passado como parâmetro, caso contrário

*/
function pfnValideFormateMoeda(valor, mensagemErro)
{
	if (pfnValideValorMaximo(valor, mensagemErro) && pfnValideNumeroNaoNegativo(valor, mensagemErro, true))
		return pfnFormateValorMoeda(valor);
	else
		return valor;
}


//*************************************************************************************************************
/**
@name pfnValideFormateMoedaOnBlur
@description Valida e formata um número quando um campo perde o foco. A validação verifica se um número contém
 apenas caracters numéricos (dígitos, e opcionalmente pontos e uma vírgula), se ele é maior ou igual a zero e
 se ele é menor do que o tamanho máximo permitido
@created 10/03/2004
@param input: o campo onde o valor foi digitado
@param mensagemErro: a mensagem a ser exibida se a validação falhar
@return Não retorna nada

*/
function pfnValideFormateMoedaOnBlur(input, mensagemErro)
{
	if (pfnValideValorMaximo(input.value, mensagemErro) && pfnValideNumeroNaoNegativo(input.value, mensagemErro, true))
		pfnFormateMoedaOnBlur(input);
	else
	{
		input.select();
		input.focus();
	}
}


//*************************************************************************************************************
/**
@name pfnValideNumeric
@description Valida se um campo contém somente caracteres numéricos, exibe a mensagem de erro (se esta for não-vazia)
 e focaliza o campo
@created 28/04/2004
@param campo: o campo que contém o texto a ser validado
@param mensagem: a mensagem de erro a ser exibida - se for vazia, nada é exibido
@return true, se o campo só tiver caracteres numéricos, false, caso contrário

*/
function pfnValideNumeric(campo, mensagem)
{
    // assuma que a validação terá sucesso
    var resultado = true;

    // verifique se o campo é non-null
    if (campo != null)
    {
        // recupere o texto digitado
        var texto = campo.value;
        // verifique se algo foi digitado
        if (pfnTrim(texto).length > 0)
        {
            // se há caracteres não-numéricos, há um erro
            if (texto.search(/\D/g, "") != -1)
            {
                // verifique se uma mensagem deve ser exibida
                if (mensagem != "")
                    alert(mensagem);
                // selecione o campo
                campo.select();
                campo.focus();
                resultado = false;
            }
        }
    }
    // retorne o resultado
    return resultado;
}


//*************************************************************************************************************
/**
@name pfnToNumeroAmericano
@description Transforma um número brasileiro em um número americano sem separadores de casas decimais,
 para que possa ser tratado no javascript. Tira todos os pontos (os separadores de casas decimais no Brasil, 
 e troca as vírgulas por pontos (os separadores de decimais).
@created 04/02/2004
@param numeroBr: o número no formato brasileiro
@return o número no formato americano

*/
function pfnToNumeroAmericano(numeroBr)
{
	return numeroBr.replace(/\./g, "").replace(/\,/g, ".");
}


//*************************************************************************************************************
/**
@name ValideNumeroMaximo
@description Verifica se um número é maior que o máximo especificado. Se for, opcionalmente exibe mensagem de erro.
@created 28/07/2004
@param input: o input onde o número está sendo digitado
@param valorMaximo: o número máximo
@param msgErroValorMaximo: a mensagem de erro a ser exibida se o valor máximo for excedido. Se for uma string 
 vazia e houver um errro, não exiba nada
@param msgErroValorInvalido: a mensagem de erro a ser exibida se o valor for inválido. Se for uma string 
 vazia e houver um errro, não exiba nada
@return true, se o valor do input for válido e menor ou igual ao valor máximo e false, caso contrário. 
 Se algum dos parâmetros  for inválido, o retorno será undefined, para facilitar o debugging.

*/
function ValideNumeroMaximo(input, valorMaximo, msgErroValorMaximo, msgErroValorInvalido)
{	
  if (input != null)
  {
    var valor = input.value;
    if (pfnTrim(valor) != "")
    {
    	// primeiro verifique se o input é válido e se há dígitos no campo
    	if (!isNaN(valor) && !isNaN(valorMaximo))
    	{
    		var numero = pfnToNumeroAmericano(pfnTrim(valor));
    		// verifique se o número é válido
    		var numObject = new Number(numero);
    		if (!isNaN(numObject))
    		{
    			// se o número for maior que o permitido e houver uma mensagem de erro, exiba a mensagem
    			if (numObject > valorMaximo && msgErroValorMaximo != "")
    			{
    				alert(msgErroValorMaximo);
    				input.select();
    				input.focus();
    			}
    			// retorne o resultado
    			return numObject > valorMaximo;
    		}
    	}
    	else if (msgErroValorInvalido != "")
    	{
    		alert(msgErroValorInvalido);
    		input.select();
    		input.focus();
    		return false;
    	}
    }
  }
}

//*************************************************************************************************************
/**
@name pfnValideNumeroNaoNegativo
@description Verifica se um número é não-negativo. Exibe a mensagem de erro caso valor contenha qualquer 
 caractere não-numérico ou se for um número negativo. Não exibe uma mensagem de erro se o parâmetro permiteVazio 
 for verdadeiro e o número for equivalente a uma string vazia
@created 08/03/2004
@param valor: o número (ou string correspondente ao número) a ser validado
@param mensagemErro: a mensagem a ser exibida caso a verificação falhe. Só exibe a mensagem se mensagemErro não 
 for uma string vazia
@param permiteVazio: se for verdadeiro e o número for equivalente a uma string vazia, não exibe a mensagem de erro.
@return true, se a validação tiver sucesso, ou seja, valor for um número válido e não-negativo; false, caso contrário.

*/
function pfnValideNumeroNaoNegativo(valor, mensagemErro, permiteVazio)
{
	// converta o valor para uma string
	var str = new String(valor);
	if (str == "")
	{
		if (!permiteVazio)
		{	
			if (mensagemErro != "")
				alert(mensagemErro);
			return false;
		}
		else
			return true;
	}
	else
	{
		var numero = new Number(pfnToNumeroAmericano(str)).valueOf();
		if (isNaN(numero) || numero < 0)
		{
			if (mensagemErro != "")
				alert(mensagemErro);
			return false;
		}
	}
	// nesse ponto a validação teve sucesso
	return true;
}
			
	
/*************************************************************************************************************
/**
@name pfnValideNumeroNaoNegativoOnBlur
@description Verifica se um input contém um número não-negativo. Exibe a mensagem de erro caso a string do
 input tenha qualquer caractere não-numérico ou se for um número negativo. Não exibe uma mensagem de erro
 se o parâmetro permiteVazio for verdadeiro e o input estiver vazio
@created 08/03/2004
@param input: O input html que contém a string a ser validada
@param mensagemErro: a mensagem a ser exibida caso a verificação falhe. Só exibe a mensagem se mensagemErro não
 for uma string vazia
@param permiteVazio: se for verdadeiro e o input estiver vazio, não exibe a mensagem de erro
@return Não retorna nada

*/
function pfnValideNumeroNaoNegativoOnBlur(input, mensagemErro, permiteVazio)
{
	if (!pfnValideNumeroNaoNegativo(input.value, mensagemErro, permiteVazio))
	{
		input.focus();
	}
}


//*************************************************************************************************************
/**
@name pfnValideValorMaximo
@description Verifica se um número é válido, ou seja, só contém caracteres numéricos (e uma vírgula e pontos, 
 opcionais) e não é maior que o valor máximo permitido no site da cobrança
@created 10/03/2004
@param valor: o número a ser validado
@param mensagemErro: a mensagem a ser exibida caso a verificação falhe. A mensagem só é exibida se for diferente
 de uma string vazia
@return true, se a validação tiver sucesso; false, caso contrário

*/
function pfnValideValorMaximo(valor, mensagemErro)
{
	// converta o número para o formato americano
	var numero = new Number(pfnToNumeroAmericano(valor)).valueOf();
	
	// verifique se o número é válido ou maior do que o máximo permitido
	if (isNaN(numero) || numero > 99999999.99)
	{
		if (mensagemErro != "")
			alert(mensagemErro);
		return false;
	}
	return true;
}


//*************************************************************************************************************
/*
@name pfnValideValorMaximoOnBlur
@description Verifica se um número é válido, ou seja, só contém caracteres numéricos (e úma vírgula e pontos, 
 opcionais) e não é maior que o valor máximo permitido no site da cobrança
@created 10/03/2004
@param input: o campo onde o número foi digitado
@param mensagemErro: a mensagem a ser exibida caso a verificação falhe. A mensagem só é exibida se for diferente
 de uma string vazia
@return true, se a validação tiver sucesso; false, caso contrário

*/
function pfnValideValorMaximoOnBlur(input, mensagemErro)
{
	if (!pfnValideValorMaximo(input.value, mensagemErro))
		input.focus();
}
function dataValida(campo, nomeCampo, campoObrigatorio)
{
  var diaStr, mesStr, anoStr
  var diaInt, mesInt, anoInt
  var tam, sep1, sep2, verAno

  tam = campo.value.length;

  if (campoObrigatorio && tam==0)
  {
    campo.focus();
    alert('Favor preencher o campo "'+nomeCampo+'"');
    return false;
  }

  sep1 = parseInt(campo.value.indexOf("/", 0));


  if (sep1<0)
  {
    campo.focus();
    alert('A data digitada no campo "'+nomeCampo+'" deve ter o seguinte formato: DD/MM/AAAA !');
    return false;
  }

  sep2 = parseInt(campo.value.indexOf("/", sep1+1))

  if (sep2<5)
  {
    campo.focus();
    alert('A data digitada no campo "'+nomeCampo+'" deve ter o seguinte formato: DD/MM/AAAA !');
    return false;
  }

  verAno = tam-sep2;

  if(verAno < 5 )
  {
    campo.focus();
    alert('A data digitada no campo "'+nomeCampo+'" deve ser preenchidas utilizando 4 dígitos para informar o Ano (ex.: DD/MM/AAAA)!');
    return false;
  }

  diaStr = campo.value.substring(0, sep1);

  if(diaStr.substring(0, 1) == "0")
    diaStr = diaStr.substring(1, 2);

  if (stringNumerica(campo, diaStr, nomeCampo))
  {
    mesStr = campo.value.substring(sep1+1, sep2);

    if(mesStr.substring(0, 1) == "0")
      mesStr = mesStr.substring(1, 2);

    if (stringNumerica(campo, mesStr, nomeCampo))
    {
      anoStr = campo.value.substring(sep2+1, tam);

      if (stringNumerica(campo, anoStr, nomeCampo))
      {
        diaInt = parseInt(diaStr);
        mesInt = parseInt(mesStr);
        anoInt = parseInt(anoStr);

        if ((diaInt <= 0) || (diaInt > 31))
        {
          campo.focus();
          alert('O dia informado no campo "'+nomeCampo+'" não é válido!');
          return false;
        }

       if ((mesInt <= 0) || (mesInt > 12))
       {
         campo.focus();
         alert('O mês informado no campo "'+nomeCampo+'" não é válido!');
         return false;
       }

       if ((mesInt == 4) || (mesInt == 6) || (mesInt == 9) || (mesInt == 11))
       {
         if( diaInt > 30)
         {
           campo.focus();
           alert('O mês informado no campo "'+nomeCampo+'" não possui mais de 30 dias!');
           return false;
         }
       }

       if (mesInt == 2)
       {
         if ((anoInt % 4 == 0) && ( (anoInt % 100 != 0) || (anoInt % 400 == 0)))
         {
           if (diaInt > 29)
           {
             campo.focus();
             alert('O mês informado no campo "'+nomeCampo+'" não possui mais de 29 dias!');
             return false;
           }
         }
         else
         {
           if(diaInt > 28)
           {
             campo.focus();
             alert('O mês informado no campo "'+nomeCampo+'" não possui mais de 28 dias!');
             return false;
           }
         }
         return true;
       }
       return true;
     }
     else
       return false;
   }
   else
     return false;
 }
 else
   return false;
}

// Verifica se somente números foram digitados no campo;
function stringNumerica (campo, objTextControl, nomeCampo)
{
  var strValidNumber = "1234567890";

  for (nCount=0; nCount < objTextControl.length; nCount++)
  {
    strTempChar=objTextControl.substring(nCount,nCount+1);
    if ( strValidNumber.indexOf(strTempChar,0)==-1)
    {
      alert('O campo "' + nomeCampo + '" deve conter somente números!');
      campo.focus();
      return false;
    }
  }

  return true;
}

function campoPreenchido(campo, nomeCampo)
{
  if (campo.value.length==0)
  {
    campo.focus();
    alert('Favor preencher o campo "'+nomeCampo+'"');
    return false;
  }

  return true;
}

function campoNumerico(campo, nomeCampo, campoObrigatorio)
{
  tam = campo.value.length;

  if (campoObrigatorio && tam==0)
  {
    campo.focus();
    alert('Favor preencher o campo "'+nomeCampo+'"');
    return false;
  }

  var strValidNumber = "1234567890";

  for (nCount=0; nCount < campo.value.length; nCount++)
  {
    strTempChar=campo.value.substring(nCount,nCount+1);
    if ( strValidNumber.indexOf(strTempChar,0)==-1)
    {
      alert('O campo "' + nomeCampo + '" deve conter somente números!');
      campo.focus();
      return false;
    }
  }

  return true;
}

function radioMarcado(campo, numItens, nomeCampo)
{

  marcado = false;
  for (nCount=0; (nCount < numItens && !marcado) ; nCount++)
  {
    if(campo[nCount].checked)
      marcado = true;
  }
  if (!marcado)
  {
    alert('Favor selecionar uma opção no campo "' + nomeCampo + '"!');
    campo[0].focus();
  }

  return marcado;
}


//-----------------------------------------------------
function desabilitarRetornarCache()
{
  which = String.fromCharCode(event.keyCode);
  xCode=which.charCodeAt(0);

  if(xCode == 8)// BackSpace
  {
    alert('Função desabilitada');
    event.keyCode = 0;
  }           
  else if(event.altKey && xCode == 37)// ALT + LEFT
  {
    alert('Função desabilitada');
    event.keyCode = 0;
  }  
  
}
//-----------------------------------------------------
function reporTodas(texto, referenciaVelha, referenciaNova)
{
  textoFinal = texto;
  while(textoFinal.indexOf(referenciaVelha) >= 0)
    textoFinal = textoFinal.replace(referenciaVelha, referenciaNova);
  
  return(textoFinal);
}

//-----------------------------------------------------
function trocarCaraterComercial(texto)
{
  textoFinal =  reporTodas(texto, '&', '%26');
  return(textoFinal);
}


//-----------------------------------------------------
function espacosDireita(valor,tam)
{
 varTamanho = valor.length;
 if (varTamanho < tam)
 {
  for(t=1; t<=tam - varTamanho; t++)
    valor = valor + " ";
 }
 return(valor);
}

//-----------------------------------------------------
function dataAtualDesformatada()
{
  dataAtual = new Date();
  ano = dataAtual.getYear();
  mes = dataAtual.getMonth()+1;
  dia = dataAtual.getDate();

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

  if (dia < 10)
    dia= '0'+dia;

  dataFormatada = dia+mes+ano;
 
  return(dataFormatada);
}

//-----------------------------------------------------
function zerosEsquerda(valor,tam)
{
 varTamanho = valor.length;
 if (varTamanho < tam)
 {
  for(t=1;t<=tam - varTamanho;t++){valor = "0" + valor;}
 }
 return(valor);
}


//-----------------------------------------------------
function TiraZerosEsq(n)
{
 var i = 0;
 var varRetorna;
 while (n.substring(i, i+1) == "0")
  i++;
 varRetorna = n.substring(i, n.length);
 if (varRetorna == '')
 {varRetorna = '0';}
 return(varRetorna);
}

//-----------------------------------------------------
function funEnter(valor)
{
 if(valor =="13")
 {
  funConsultar();
  event.keyCode =0;
 }
}

//-----------------------------------------------------
function mOvr(src)
{
 if (!src.contains(event.fromElement))
 {
  src.bgColor = '#DFF1F2';
 }
}

//-----------------------------------------------------
function mOut(src)
{
 if (!src.contains(event.toElement))
 {
  src.bgColor = 'white';
 }
}

//-----------------------------------------------------
function funN(valor1)
{
 if ((valor1<"48") || (valor1>"57")){
  event.keyCode = 0;
 }
}

//-----------------------------------------------------
function funNV(valor1)
{
 if ((valor1 < '48' || valor1>'57') && valor1 != '13' && valor1 != '44'){
  event.keyCode = 0;
 }
}

//-----------------------------------------------------
function funMOL(varLink)
{
 if (eval(varLink+".className") != "Invisivel")
 {
  eval(varLink+".className = 'Invisivel'");
 }
 else
 {
  eval(varLink+".className = 'Visivel'");
 }
}

//-----------------------------------------------------
function trim(texto)
{
 var tamanho   = 0;
 var resultado = "";
 var i;
 tamanho = texto.length;
 for (i=0; i<= tamanho; i++)
 {
  if (texto.substr(i,1) != " ")
  {
   resultado = texto.substr(i, tamanho-i);
   break;
  }
 }
 tamanho = resultado.length;
 texto   = resultado;
 for (i=tamanho; i != 0; i--)
 {
  if (texto.substr(i-1,1) != " ")
  {
   resultado = resultado.substr(0, i);
   break;
  }
 }
 return(resultado);
}

//-----------------------------------------------------
//--Funcao para formatar o número em moeda. Ex: 123456 para 1.234,56
function FormatarNumero(n)
{
    n              = n + '';
    var tamanho    = n.length;
    var posicao    = tamanho;
    var nFormatado = '';
    var index      = 1;
    posicao       -= 1;
 
    while(posicao >= 0)
    {
      nFormatado =  n.substr(posicao, 1)+nFormatado;  
      if (index == 2)
      {
        nFormatado = ','+nFormatado;
      }
      if (index == 5 && tamanho > 5)
      {
        nFormatado = '.'+nFormatado;
        index = 2;
      } 

      posicao -= 1;
      index   += 1;
    }
    return nFormatado;
}
  
//-----------------------------------------------------
function forData(varfunData)
{
    return(varfunData.substr(0, 2)+'/'+varfunData.substr(2, 2)+'/'+varfunData.substr(4, 4))
}

//-----------------------------------------------------
//--Esta função retira os caracteres não aceitos pelo SADS
function retirarCaracteresInvalidos(texto)
{
 filtrado = "";
 for(i=0;i < texto.length;i++)
 {
  numAsc = texto.charCodeAt(i);
  if(
     (numAsc >= 65 && numAsc<= 90)//A..Z
     ||
     (numAsc >= 97 && numAsc <= 122)//a..z
     ||
     (numAsc >= 48 && numAsc <= 57)//0..9
     ||
     (numAsc == 46)// .
     ||
     (numAsc == 59)// ;
     ||
     (numAsc == 44)// ,
     ||
     (numAsc == 63)// ?
     ||
     (numAsc == 33)// !
     ||
     (numAsc == 58)// :
     ||
     (numAsc == 60)// <
     ||
     (numAsc == 62)// >
     ||
     (numAsc == 47)// /
     ||
     (numAsc == 92)// \
     ||
     (numAsc == 124)// |
     ||
     (numAsc == 40)// (
     ||
     (numAsc == 41)// )
     ||
     (numAsc == 123)// {
     ||
     (numAsc == 125)// }
     ||
     (numAsc == 91)// [
     ||
     (numAsc == 93)// ]
     ||
     (numAsc == 45)// -
     ||
     (numAsc == 95)// _
     ||
     (numAsc == 61)// =
     ||
     (numAsc == 43)// +
     ||
     (numAsc == 42)// *
     ||
     (numAsc == 37)// %
     ||
     (numAsc == 36)// $
     ||
     (numAsc == 34)// "
     ||
     (numAsc == 32)//
     ||
     (numAsc == 39)// '
     ||
     (numAsc == 64)// @
     ||
     (numAsc == 35)// #
    )
     filtrado += texto.charAt(i);
    else if (numAsc == 225 || numAsc == 227 || numAsc == 226 ||
             numAsc == 228 || numAsc == 224 || numAsc == 170)//á,ã,â,ä,à,ª
     filtrado += 'a';
    else if (numAsc == 193 || numAsc == 195 || numAsc == 197 ||
             numAsc == 196 || numAsc == 192 )//Á,Ã,Â,Ä,À
     filtrado += 'A';
    else if (numAsc == 233 || numAsc == 234 || numAsc == 235 ||
             numAsc == 232  )//é,ê,ë,è
     filtrado += 'e';
    else if (numAsc == 202 || numAsc == 201 || numAsc == 203 ||
             numAsc == 200  )//Ê,É,Ë,È
     filtrado += 'E';
    else if (numAsc == 237 || numAsc == 238 || numAsc == 239 ||
             numAsc == 236  )//"í","î","ï","ì"
     filtrado += 'i';
    else if (numAsc == 206 || numAsc == 205 || numAsc == 207 ||
             numAsc == 204  )//Î,Í,Ï,Ì
     filtrado += 'I';
    else if (numAsc == 243 || numAsc == 245 || numAsc == 244 ||
             numAsc == 246 || numAsc == 242 || numAsc == 176 )//ó,õ,ô,ö,ò,º
     filtrado += 'o';
    else if (numAsc == 211 || numAsc == 213 || numAsc == 212 ||
             numAsc == 214 || numAsc == 210 )//Ó,Õ,Ô,Ö,Ò
     filtrado += 'O';
    else if (numAsc == 250 || numAsc == 251 || numAsc == 252 ||
             numAsc == 249 )//ú,û,ü,ù,û
     filtrado += 'u';
    else if (numAsc == 219 || numAsc == 218 || numAsc == 220 ||
             numAsc == 217 )//Û,Ú,Û,Ü,Ù
     filtrado += 'U';
    else if (numAsc == 199)//Ç
     filtrado += 'C';
    else if (numAsc == 231)//ç
     filtrado += 'c';
 }
 return filtrado

}