//############################################
//# FUNÇÕES REVISADAS                        #
//############################################

//mostra um alert com o nome do operador e a data/hora da última atualização
function alertUltimaAtualizacao(operador, dua) {
  alert("Este registro foi atualizado pela última vez por\r\n"+operador+" em "+dua);
}

//alterna a seleção de todos os checkbox do formulário informado
function alternaSelecaoTodosCheckbox(formulario, desabilitado) {
  //seleciona o formulário a ser analisado
  with (formulario) {
    //percorre todos os elementos
    for (i=0; i<elements.length; i++) {
      elemento=elements[i];

      //verifica se o elemento é do tipo checkbox
      if (elemento.type == "checkbox") {
        //verifica se o elemento está habilitado/desabilitado ou indiferente, conforme o parâmetro
        if ((elemento.disabled == desabilitado) || (desabilitado.length == 0)) {
          elemento.checked=!elemento.checked;
        }
      }
    }
  }
}

//formata um campo
//sintaxe: onKeyPress="javascript: formataCampo(this, event, '#####-###');"
function formataCampo(campo, evento, mascara) {
  if (!verificaTeclaControle(evento)) {
    texto=mascara.substring(campo.value.length);
    
    if (texto.substring(0, 1) != mascara.substring(0, 1)) {
      campo.value+=texto.substring(0, 1);
    }
  }
}

//formata um texto
function formataTexto(texto, mensagem) {
  //retira os espaços em branco do início e fim do conteúdo do parâmetro texto
  texto=trim(texto);

  //verifica se foi passado algum conteúdo no parâmetro texto
  if (texto != "") {
    //retorna o conteúdo do parâmetro texto
    return texto;
  }
  else {
    //retorna a mensagem passada para a função
    return mensagem;
  }
}

//formata um valor
//sintaxe: onKeyPress="javascript: return formataValor(this, event, '.', ',', '2');"
function formataValor(campo, evento, separador_milhar, separador_decimal, nr_digitos_decimal) {
  if (!verificaTeclaControle(evento)) {
    if (verificaTeclaDigito(evento)) {
      codigo_tecla=recuperaCodigoTeclaPressionada(evento);
      tecla=String.fromCharCode(codigo_tecla);
      valor_formatado=retiraCaracteresInvalidos(campo.value, "0123456789", "", "")+tecla;
      
      //retira os zeros a esquerda
      for (i=0; i<valor_formatado.length; i++) {
        if (valor_formatado.charAt(i) != "0") {
          valor_formatado=valor_formatado.substr(i, valor_formatado.length);
          break;
        }
      }
      
      //adiciona os zeros a esquerda até o limite do parâmetro nr_digitos_decimal, se houver separador de decimal
      if ((nr_digitos_decimal > 0) && (separador_decimal != "")) {
        while (nr_digitos_decimal > valor_formatado.length) {
          valor_formatado="0"+valor_formatado;
        }
      }
      
      //divide o valor da esquerda e direita do separador de decimal, usando como base o parâmetro nr_digitos_decimal
      valor_esquerda_separador_decimal=valor_formatado.substr(0, valor_formatado.length-nr_digitos_decimal);
      valor_direita_separador_decimal=valor_formatado.substr(valor_formatado.length-nr_digitos_decimal, valor_formatado.length);
      
      //adiciona o zero a esquerda do separador decimal, se precisar e se houver separador de decimal
      if ((valor_esquerda_separador_decimal == "") && (separador_decimal != "")) {
        valor_esquerda_separador_decimal="0";
      }
      
      //formata o separador de milhar, se precisar e se houver separador de milhar
      if ((valor_esquerda_separador_decimal.length > 3) && (separador_milhar != "")) {
        valor_formatado="";
        j=1;
        for (i=valor_esquerda_separador_decimal.length-1; i>=0; i--) {
          valor_formatado=valor_esquerda_separador_decimal.charAt(i)+valor_formatado;
          
          if (((j % 3) == 0) && (i > 0)) {
            valor_formatado=separador_milhar+valor_formatado;
          }
          
          j++;
        }
      }
      else {
        valor_formatado=valor_esquerda_separador_decimal;
      }
      
      //monta o valor formatado
      valor_formatado+=separador_decimal+valor_direita_separador_decimal;
      
      //verifica se há restrição quanto ao número máximo de caracteres do valor
      //se não há definido o "maxlength" do campo, no Firefox "campo.maxLength" será -1, no IE será 2147483647
      if ((campo.maxLength == -1) || (campo.maxLength >= valor_formatado.length)) {
        //retorna ao campo o valor formatado
        campo.value=valor_formatado;
      }
      else {
        return false;
      }
    }
    
    return false;
  }
  
  return true;
}

//mascara a barra de status e evita mensagem de erro no Firefox quando utilizar a tag <a> com onClick em substituição ao href
//não funciona como esperado, se onClick submete algum formulário, não irá submeter no IE
function link() {
}

//mostra ou esconde elementos html
function mostraEscondeById(id_mae, tag, id, mostrar, manter_estrutura) {
  //verifica se foi passado algum conteúdo no parâmetro "id_mae"
  if (id_mae) {
    elementos=document.getElementById(id_mae).getElementsByTagName(tag);
  }
  else {
    elementos=document.getElementsByTagName(tag);
  }

  //percorre todos os elementos
  for (i=0; i<elementos.length; i++) {
    if (elementos[i].id == id) {
      if (mostrar) {
        elementos[i].style.display="";
      }
      else {
        if (manter_estrutura) {
          //não utilizar elementos[i].style.visibility="hidden";
          //pois se usar em tabelas, por exemplo, não mostrará a borda do elemento
          if (tag == "tr") {
            //percorre os elementos filhos da tag "tr"
            //no IE, se tivermos 2 td's ele irá contar 2 filhos,
            //mas no Firefox dependendo das quebras de linha e/ou dos espaços em branco no código, ele pode contar por exemplo 5 filhos
            for (j=0; j<elementos[i].childNodes.length; j++) {
              //verifica se o elemento está correto, baseado no problema acima
              if (elementos[i].childNodes[j].nodeType.toString() == "1") {
                elementos[i].childNodes[j].childNodes[0].parentNode.innerHTML='<span style="visibility: hidden;">'+elementos[i].childNodes[j].childNodes[0].parentNode.innerHTML+'</span>';
              }
            }
          }
          else {
            elementos[i].innerHTML='<span style="visibility: hidden;">'+elementos[i].innerHTML+'</span>';
          }
        }
        else {
          elementos[i].style.display="none";
        }
      }
    }
  }
}

//abre uma página em nova janela
//se a função for chamada novamente antes de fechar a janela anteriormente aberta, esta será atualizada e receberá o foco
function novaJanela01(pagina) {
  janela=window.open(pagina, "novaJanela01", "left=0,top=0,toolbar=0,scrollbars=1,width=500,height=400");
  janela.focus();
}

//abre uma página em nova janela
function novaJanela02(pagina) {
  window.open(pagina, "_blank", "");
}

//recupera o código da tecla pressionada
function recuperaCodigoTeclaPressionada(evento) {
  //verifica se o evento foi gerado no IE
  if (window.event) {
    return evento.keyCode;
  }
  else {
    return evento.which;
  }
}

//retira os caracteres inválidos do texto
function retiraCaracteresInvalidos(texto, caracteres_validos, caracteres_invalidos, mensagem) {
  //verifica se há definido os caracteres válidos ou inválidos
  if ((caracteres_validos.length > 0) || (caracteres_invalidos.length > 0)) {
    texto_formatado="";
    
    for (i=0; i<texto.length; i++) {
      //verifica se o caracter atual não é inválido
      //verifica se não há definido os caracteres válidos ou se o caracter atual é válido
      if ((caracteres_invalidos.indexOf(texto.substring(i, i+1)) < 0) &&
          ((caracteres_validos.length == 0) || (caracteres_validos.indexOf(texto.substring(i, i+1)) >= 0))) {
        texto_formatado+=texto.substring(i, i+1);
      }
    }
    
    //retorna o texto formatado
    return texto_formatado;
  }
  else {
    //retorna a mensagem passada para a função
    return mensagem;
  }
}

//retira os espaços em branco do início e fim do texto
function trim(texto) {
  //retira os espaços em branco do início do texto
  while (texto.charAt(0) == " ") {
    texto=texto.substr(1, texto.length-1);
  }

  //retira os espaços em branco do fim do texto
  while (texto.charAt(texto.length-1) == " ") {
    texto=texto.substr(0, texto.length-1);
  }

  return texto;
}

//valida uma data no formato "dd mm aa" ou "dd mm aaaa"
function validaData_dd_mm_aaaa(campo) {
  //formata o conteúdo do parâmetro campo
  campo.value=formataTexto(campo.value, "");

  //divide em dia, mês e ano o conteúdo do parâmetro campo
  dia=campo.value.substring(0, 2);
  mes=campo.value.substring(3, 5);
  ano=campo.value.substring(6, 10);

  //define a situação padrão
  situacao=true;

  //verifica se o conteúdo do parâmetro campo não está em branco
  if (campo.value != "") {
    //verifica se o conteúdo do parâmetro campo não tem 8 (dd mm aa) e nem 10 (dd mm aaaa) caracteres
    if ((campo.value.length != 8) && (campo.value.length != 10)) {
      situacao=false;
    }
    else {
      //verifica se o dia não é válido
      if ((dia < 1) || (dia > 31) || ((dia > 30) && ((mes == 2) || (mes == 4) || (mes == 6) || (mes == 9) || (mes == 11)))) {
        situacao=false;
      }
      
      //verifica se o mês não é válido
      if ((mes < 1) || (mes > 12)) {
        situacao=false;
      }
      
      //verifica se o mês é fevereiro e o dia não é válido
      if ((mes == 2) && ((dia > 29) || ((dia > 28) && (parseInt(ano/4) != ano/4)))) {
        situacao=false;
      }
    }
  }

  //verifica se a data é inválida
  if (situacao == false) {
    //retorna a mensagem para o usuário e coloca o foco no campo específico
    alert("A data informada é inválida");
    campo.focus();
    return false;
  }
  else {
    return true;
  }
}

//valida uma data (não pode ser nulo) no formato "dd mm aa" ou "dd mm aaaa"
function validaData_dd_mm_aaaa_not_null(campo, descricao_campo) {
  //verifica se o conteúdo do parâmetro campo está em branco
  if (!verificaCampoBranco(campo, descricao_campo)) {
    return false;
  }

  //valida uma data no formato "dd mm aa" ou "dd mm aaaa"
  return validaData_dd_mm_aaaa(campo);
}

//valida e-mail, segundo a referência abaixo
//http://www.mhavila.com.br/topicos/web/valform.html
function validaEmail(campo) {
  //define algumas expressões regulares que podem ser usadas para a validação de e-mails
  er_liberada=/^[\w!#$%&'*+\/=?^`{|}~-]+(\.[\w!#$%&'*+\/=?^`{|}~-]+)*@(([\w-]+\.)+[A-Za-z]{2,6}|\[\d{1,3}(\.\d{1,3}){3}\])$/;
  er_compacta=/^[\w-]+(\.[\w-]+)*@(([\w-]{2,63}\.)+[A-Za-z]{2,6}|\[\d{1,3}(\.\d{1,3}){3}\])$/;
  er_restrita=/^[\w-]+(\.[\w-]+)*@(([A-Za-z\d][A-Za-z\d-]{0,61}[A-Za-z\d]\.)+[A-Za-z]{2,6}|\[\d{1,3}(\.\d{1,3}){3}\])$/;

  //define a expressão regular a ser utilizada na validação
  er_aplicada=er_compacta;

  //formata o conteúdo do parâmetro campo
  campo.value=formataTexto(campo.value, "");

  //converte o e-mail para letras minúsculas
  campo.value=campo.value.toLowerCase();

  //define a situação padrão
  situacao=true;

  //verifica se o e-mail não está em branco
  if (campo.value != "") {
    //verifica se o e-mail é inválido através da expressão regular
    if (!er_aplicada.test(campo.value)) {
      situacao=false;
    }
  }

  //verifica se o e-mail é inválido
  if (situacao == false) {
    //retorna a mensagem para o usuário e coloca o foco no campo específico
    alert("O e-mail informado é inválido");
    campo.focus();
    return false;
  }
  else {
    return true;
  }
}

//verifica se o campo está em branco
function verificaCampoBranco(campo, descricao_campo) {
  //formata o texto do campo
  campo.value=formataTexto(campo.value, "");

  //verifica se o texto do campo está em branco
  if (campo.value == "") {
    //retorna a mensagem para o usuário e coloca o foco no campo específico
    alert("O campo ["+descricao_campo+"] deve ser preenchido");
    campo.focus();
    return false;
  }

  return true;
}

//verifica se o caractere é um dígito
function verificaDigito(caractere) {
  digitos="0123456789";

  //verifica se o caractere é permitido
  if (digitos.indexOf(caractere) == -1) {
    return false;
  }

  return true;
}

//verifica se pelo menos um checkbox foi selecionado no formulário informado
function verificaSelecaoCheckbox(formulario, desabilitado, mensagem) {
  //seleciona o formulário a ser analisado
  with (formulario) {
    situacao=false;

    //percorre todos os elementos
    for (i=0; i<elements.length; i++) {
      elemento=elements[i];

      //verifica se o elemento é do tipo checkbox
      if (elemento.type == "checkbox") {
        //verifica se o elemento está habilitado/desabilitado ou indiferente, conforme o parâmetro
        if ((elemento.disabled == desabilitado) || (desabilitado.length == 0)) {
          //verifica se o elemento está selecionado
          if (elemento.checked) {
            situacao=true;
            break;
          }
        }
      }
    }

    //verifica se não há algum checkbox selecionado
    if (situacao == false) {
      alert(mensagem);
      return false;
    }
    else {
      return true;
    }
  }
}

//verifica se pelo menos um radio button foi selecionado no formulário informado ou no formulário.nome do campo informado
function verificaSelecaoRadioButton(formulario, nome_campo, desabilitado, mensagem) {
  //seleciona o formulário a ser analisado
  with (formulario) {
    situacao=false;

    //percorre todos os elementos
    for (i=0; i<elements.length; i++) {
      elemento=elements[i];

      //verifica se o elemento é do tipo radio button
      if (elemento.type == "radio") {
        //verifica se o nome do elemento é igual ao nome do campo passado como parâmetro ou se é para ignorar o nome do elemento
        if ((elemento.name == nome_campo) || (nome_campo == "")) {
          //verifica se o elemento está habilitado/desabilitado ou indiferente, conforme o parâmetro
          if ((elemento.disabled == desabilitado) || (desabilitado.length == 0)) {
            //verifica se o elemento está selecionado
            if (elemento.checked) {
              situacao=true;
              break;
            }
          }
        }
      }
    }

    //verifica se não há algum radio button selecionado
    if (situacao == false) {
      alert(mensagem);
      return false;
    }
    else {
      return true;
    }
  }
}

//verifica o suporte à ajax no browser do usuário
function verificaSuporteAjax() {
  //verifica se o browser pode criar um objeto XMLHttpRequest
  if ((typeof XMLHttpRequest == "undefined") && (typeof ActiveXObject == "undefined") && (window.createRequest == "undefined")) {
    return false;
  }
  else {
    if (typeof ActiveXObject != "undefined") {
      XHR=null;

      try {
        XHR=new ActiveXObject("Msxml2.XMLHTTP");
      } catch (e1) {
        try {
          XHR=new ActiveXObject("Microsoft.XMLHTTP");
        } catch (e2) {
          try {
            XHR=new ActiveXObject("Msxml2.XMLHTTP.4.0");
          } catch (e3) {
            XHR=null;
          }
        }
      }

      if (XHR == null) {
        return false;
      }
    }

    return true;
  }
}

//verifica o suporte à xajax no browser do usuário
function verificaSuporteXajax() {
  //verifica se o browser do usuário suporta ajax e se existe a função encodeURIComponent do JavaScript
  if ((verificaSuporteAjax()) && (window.encodeURIComponent)) {
    return true;
  }
  else {
    return false;
  }
}

//verifica se a tecla pressionada é de controle
function verificaTeclaControle(evento) {
  codigo_tecla=recuperaCodigoTeclaPressionada(evento);

  //0 = outras teclas de controle (Firefox); 8 = backspace; 13 = enter;
  if ((codigo_tecla == 0) || (codigo_tecla == 8) || (codigo_tecla == 13)) {
    return true;
  }

  return false;
}

//verifica se a tecla pressionada é um dígito
//sintaxe: onKeyPress="javascript: return verificaTeclaDigito(event);"
function verificaTeclaDigito(evento) {
  codigo_tecla=recuperaCodigoTeclaPressionada(evento);
  tecla=String.fromCharCode(codigo_tecla);

  if ((verificaDigito(tecla)) || (verificaTeclaControle(evento))) {
    return true;
  }

  return false;
}

//verifica se os dados referentes à troca de senha estão corretos
function verificaTrocaSenha(campo_senha_atual, descricao_campo_senha_atual, campo_senha_nova, descricao_campo_senha_nova, campo_senha_confirmacao, descricao_campo_senha_confirmacao) {
  //formata o texto das senhas repassadas
  campo_senha_atual.value=formataTexto(campo_senha_atual.value, "");
  campo_senha_nova.value=formataTexto(campo_senha_nova.value, "");
  campo_senha_confirmacao.value=formataTexto(campo_senha_confirmacao.value, "");

  //verifica se os campos referentes à troca de senha estão preenchidos
  if ((campo_senha_atual.value != "") || (campo_senha_nova.value != "") || (campo_senha_confirmacao.value != "")) {
    //verifica se o campo senha atual está em branco
    if (campo_senha_atual.value == "") {
      //retorna a mensagem para o usuário e coloca o foco no campo específico
      alert("O campo ["+descricao_campo_senha_atual+"] deve ser preenchido para trocar a senha");
      campo_senha_atual.focus();
      return false;
    }
    //verifica se o campo senha nova está em branco
    if (campo_senha_nova.value == "") {
      //retorna a mensagem para o usuário e coloca o foco no campo específico
      alert("O campo ["+descricao_campo_senha_nova+"] deve ser preenchido para trocar a senha");
      campo_senha_nova.focus();
      return false;
    }
    //verifica se o campo senha confirmação está em branco
    if (campo_senha_confirmacao.value == "") {
      //retorna a mensagem para o usuário e coloca o foco no campo específico
      alert("O campo ["+descricao_campo_senha_confirmacao+"] deve ser preenchido para trocar a senha");
      campo_senha_confirmacao.focus();
      return false;
    }

    //verifica se os campos senha nova e senha confirmação não conferem
    if (campo_senha_nova.value != campo_senha_confirmacao.value) {
      //retorna a mensagem para o usuário e coloca o foco no campo específico
      alert("Os campos ["+descricao_campo_senha_nova+"] e ["+descricao_campo_senha_confirmacao+"] não conferem");
      campo_senha_confirmacao.focus();
      return false;
    }
  }

  return true;
}

//verifica se o valor do campo está dentro do limite especificado
function verificaValorLimite(campo, descricao_campo, valor_minimo, valor_maximo) {
  //formata o texto do campo
  campo.value=formataTexto(campo.value, "");

  if ((campo.value < valor_minimo) || (campo.value > valor_maximo)) {
    //retorna a mensagem para o usuário e coloca o foco no campo específico
    alert("O valor do campo ["+descricao_campo+"] está fora do limite ("+valor_minimo+" - "+valor_maximo+")");
    campo.select();
    return false;
  }

  return true;
}

//verifica se o valor do campo (não pode ser nulo) está dentro do limite especificado
function verificaValorLimite_not_null(campo, descricao_campo, valor_minimo, valor_maximo) {
  if (!verificaCampoBranco(campo, descricao_campo) || !verificaValorLimite(campo, descricao_campo, valor_minimo, valor_maximo)) {
    return false;
  }

  return true;
}

//############################################
//# FUNÇÕES NÃO REVISADAS                    #
//############################################

//resume o texto conforme a quantidade de caracteres
function textoResumo(texto_completo, qtd_caracteres) {
  //verifica se foi passado algum conteúdo no parâmetro "texto_completo"
  if (texto_completo) {
    //verifica se o texto completo é maior que o desejado
    if (texto_completo.length > qtd_caracteres) {
      //retorna o texto resumido
      return texto_completo.substr(0, texto_completo.substr(0, qtd_caracteres-3).lastIndexOf(" "))+" ...";
    }
    else {
      //retorna o texto completo, pois não é necessário resumir
      return texto_completo;
    }
  }
  else {
    //tratamento utilizado para não retornar o texto em branco
    return "-";
  }
}

//mostra um alert com o nome do operador e a data do último acesso
function alertUltimoAcesso(operador, data) {
  alert(operador+" acessou pela última vez em "+data);
}

//mensagem para confirmar a ação efetuada
function confirmaAcao(acao) {
  //converte o texto em maiúsculas
  acao=acao.toUpperCase();
  if (confirm("Deseja realmente "+acao+" este registro?")) {
    return true;
  }
  return false;
}

//incrementa e decrementa a quantidade de linhas de um textarea
function qtdLinhasTextarea(campo, acao) {
  if (acao == "-") {
    if (campo.rows > 5) {
      campo.rows-=5;
    }
  }
  else {
    campo.rows+=5;
  }
}

/*retorna o número de caracteres digitados e restantes
  sintaxe: onKeyUp="caracteresDigitadosRestantes(this, 1000, 'id_nr_digitados', 'id_nr_restantes')"*/
function caracteresDigitadosRestantes(campo, limite, id_nr_digitados, id_nr_restantes) {
  mais_um=eval(campo.value.length-1);
  mais_um++;
  if (campo.value.length > limite) {
    campo.value=campo.value.substr(0, limite);
    alert("Limite de "+limite+" caracteres excedido");
  }
  else {
    document.getElementById(id_nr_digitados).innerHTML=eval(mais_um);
    document.getElementById(id_nr_restantes).innerHTML=eval(limite-mais_um);
  }
}

//valida hora no formato hh:mm
function validaHora_hh_mm(campo) {
  hora=trim(campo.value);
  horas=hora.substring(0, 2);
  minutos=hora.substring(3, 5);
  situacao=true;

  if (hora != "") {
    //verifica se a hora tem menos de 5 caracteres
    if (hora.length != 5) {
      situacao=false;
    }
    else {
      //verifica se a hora e os minutos são válidos
      if (horas < 0 || horas > 23 || minutos < 0 || minutos > 59) {
        situacao=false;
      }
    }
  }

  //verifica se a hora é inválida
  if (situacao == false) {
    alert("A hora informada é inválida");
    campo.focus();
    return false;
  }
  else {
    return true;
  }
}

//valida hora (não pode ser nulo) no formato hh:mm
function validaHora_hh_mm_not_null(campo, nome) {
  if (!verificaCampoBranco(campo, nome)) {
    return false;
  }
  return validaHora_hh_mm(campo);
}

//valida timestamp no formato dd/mm/aaaa hh:mm
function validaTimestamp(campo) {
  data_hora=trim(campo.value);
  data=data_hora.substring(0, 10);
  hora=data_hora.substring(11, 16);

  //verifica se a data e a hora são válidas
  if (validaData_dd_mm_aaaa(data) && validaHora_hh_mm(hora)) {
    return true;
  }
  else {
    return false;
  }
}

//valida timestamp (não pode ser nulo) no formato dd/mm/aaaa hh:mm
function validaTimestamp_not_null(campo, nome) {
  if (!verificaCampoBranco(campo, nome)) {
    return false;
  }

  //verifica se a data e a hora (não pode ser nulo) são válidas
  if (validaData_dd_mm_aaaa_not_null(campo, nome) && validaHora_hh_mm_not_null(campo, nome)) {
    return true;
  }
  else {
    return false;
  }
}

//valida CPF, segundo as referências abaixo
//http://www.receita.fazenda.gov.br/publico/Legislacao/atos/AtosConjuntos/AnexoIADEConjuntoCoratCotec0012002.doc
//http://www.mhavila.com.br/topicos/web/cpf_cnpj.html
//http://www.imasters.com.br/artigo.php?cn=2410&cc=78
function validaCpf(campo) {
  cpf=trim(campo.value);
  cpf=retiraCaracteresInvalidos(cpf, "0123456789", "", "");
  situacao=true;

  if (cpf != "") {
    if (cpf.length != 11) {
      situacao=false;
    }
    else {
      cpf_correto=cpf.substring(0, 9);

      for (i=1; i<=2; i++) {
        k=2;
        soma=0;
        for (j=cpf_correto.length-1; j>=0; j--) {
          soma+=(cpf_correto.charAt(j) - "0") * k;
          k=(k - 1) % 11 + 2;
        }
        digito=11 - soma % 11;
        if (digito > 9) {
          digito=0;
        }
        cpf_correto+=digito;
      }

      if (cpf != cpf_correto) {
        situacao=false;
      }
      else {
        //não é considerado válido o CPF com os números iguais de 00000000000 a 99999999999
        if (cpf == "00000000000" || cpf == "11111111111" || cpf == "22222222222" || cpf == "33333333333" ||
            cpf == "44444444444" || cpf == "55555555555" || cpf == "66666666666" || cpf == "77777777777" ||
            cpf == "88888888888" || cpf == "99999999999") {
          situacao=false;
        }
      }
    }
  }

  //verifica se o CPF é inválido
  if (situacao == false) {
    alert("O CPF informado é inválido");
    campo.focus();
    return false;
  }
  else {
    return true;
  }
}

//valida CNPJ, segundo as referências abaixo
//http://www.receita.fazenda.gov.br/publico/Legislacao/atos/AtosConjuntos/AnexoIADEConjuntoCoratCotec0012002.doc
//http://www.mhavila.com.br/topicos/web/cpf_cnpj.html
//http://www.imasters.com.br/artigo.php?cn=2451&cc=78
function validaCnpj(campo) {
  cnpj=trim(campo.value);
  cnpj=retiraCaracteresInvalidos(cnpj, "0123456789", "", "");
  situacao=true;

  if (cnpj != "") {
    if (cnpj.length != 14) {
      situacao=false;
    }
    else {
      cnpj_base=cnpj.substring(0, 8);
      cnpj_ordem=cnpj.substring(8, 12);
      cnpj_correto=cnpj_base+cnpj_ordem;

      for (i=1; i<=2; i++) {
        k=2;
        soma=0;
        for (j=cnpj_correto.length-1; j>=0; j--) {
          soma+=(cnpj_correto.charAt(j) - "0") * k;
          k=(k - 1) % 8 + 2;
        }
        digito=11 - soma % 11;
        if (digito > 9) {
          digito=0;
        }
        cnpj_correto+=digito;
      }

      if (cnpj != cnpj_correto) {
        situacao=false;
      }
      else {
        //não é considerado válido o CNPJ com os números básicos iguais de 11111111 a 99999999
        if (cnpj_base == "11111111" || cnpj_base == "22222222" || cnpj_base == "33333333" || cnpj_base == "44444444" ||
            cnpj_base == "55555555" || cnpj_base == "66666666" || cnpj_base == "77777777" || cnpj_base == "88888888" ||
            cnpj_base == "99999999") {
          situacao=false;
        }
        else {
          //não é considerado válido o CNPJ com número de ordem igual a 0000
          //não é considerado válido o CNPJ com número de ordem maior do que 0300 e com as três primeiras posições do número básico com 000
          //a crítica da linha acima não é feita quando o número básico for igual a 00000000
          if ((cnpj_ordem == "0000") || ((parseInt(cnpj_ordem, 10) > 300) && (cnpj_base.substring(0, 3) == "000") && (cnpj_base != "00000000"))) {
            situacao=false;
          }
        }
      }
    }
  }

  //verifica se o CNPJ é inválido
  if (situacao == false) {
    alert("O CNPJ informado é inválido");
    campo.focus();
    return false;
  }
  else {
    return true;
  }
}

// Desabilita o botão direito
var message="Function Disabled!";

function clickIE4(){
	if (event.button==2){
		//alert(message);
	return false;
	}
}

function clickNS4(e){
	if (document.layers || document.getElementById && !document.all){
		if (e.which==2||e.which==3){
			//alert(message);
			return false;
		}
	}
}

if (document.layers){
	document.captureEvents(Event.MOUSEDOWN);
	document.onmousedown=clickNS4;
} else if (document.all && !document.getElementById){
	document.onmousedown=clickIE4;
}
document.oncontextmenu=new Function("return false")