/******************************************************************************/
/* Funções para formatação automática de campos                               */
/* Autor: Gustavo Cardoso Pinto Coelho                                        */
/* Data de Criação: 17/12/2002                                                */
/* Última Atualização: 21/01/2003                                             */
/******************************************************************************/

// Variáveis globais
var verificaTab = true;
var campoSelecionado = false;
var sepDecimalDigitado = false;
var sinalDigitado = false;

// Função para contar o número de caracteres em determinado string
function contaCaracter(strExpressao, charAux)
{
  var resultado = 0;

  for (var i = 0; i < strExpressao.length; i++)
    if (strExpressao.substr(i, 1) == charAux)
      resultado++;

  return resultado;
}

// Função para substituir todas as ocorrências de um string em uma expressão
function replaceAll(strExpressao, strFind, strReplace)
{
  var strResultado = strExpressao;

  while (strResultado.indexOf(strFind) > -1)
    strResultado = strResultado.replace(strFind, strReplace);

  return strResultado;
}

// Função para evitar o AutoTab
function pararTab(objCampo)
{
  verificaTab = false;
  sepDecimalDigitado = false;
  sinalDigitado = false;
  objCampo.select();
}

// Função para habilitar o AutoTab
function checarTab()
{
  verificaTab = true;
}

// Função chamada para indicar que o texto do campo está selecionado
function statusSelOn()
{
  campoSelecionado = true;
}

// Função para forçar o tab automaticamente, após o preenchimento completo do campo
function autoTab(objCampo, tamanhoMaximo)
{
  try
  {
    // Aborta a função se for Netscape
    if (navigator.appName == "Netscape") return;

    var valorCampo = objCampo.value;
    var tamanhoValor = valorCampo.length;

    // Verifica se o campo já está totalmente preenchido e se o foco deve ser passado ao próximo campo
    if (verificaTab && tamanhoValor == tamanhoMaximo)
    {
      var i = 0, j = 0, indiceFormulario = -1;
      var tipoCampo = "";

      // Localiza o form onde está localizado o campo atual
      for (i = 0; i < document.forms.length; i++)
      {
        for (j = 0; j < document.forms[i].elements.length; j++)
          if (document.forms[i].elements[j].name == objCampo.name)
          {
            indiceFormulario = i;
            break;
          }

        if (indiceFormulario != -1)
          break;
      }

      // Localiza o próximo campo do form
      for (i = 0; i <= document.forms[indiceFormulario].elements.length; i++)
      {
        if (document.forms[indiceFormulario].elements[i].name == objCampo.name)
        {
          tipoCampo = document.forms[indiceFormulario].elements[(i + 1)].type.toUpperCase();
          var campoDesabilitado = document.forms[indiceFormulario].elements[(i + 1)].disabled;
          var campoInvisivel = document.forms[indiceFormulario].elements[(i + 1)].style.visibility.toUpperCase() == "HIDDEN";

          // Ignora os campos HIDDEN, RADIO, CHECKBOX, campos desabilitados e invisíveis
          while (i < document.forms[indiceFormulario].length && (tipoCampo == "HIDDEN" || tipoCampo == "RADIO" || tipoCampo == "CHECKBOX" || campoDesabilitado || campoInvisivel))
          {
            i++;
            tipoCampo = document.forms[indiceFormulario].elements[(i + 1)].type.toUpperCase();
            campoDesabilitado = document.forms[indiceFormulario].elements[(i + 1)].disabled;
            campoInvisivel = document.forms[indiceFormulario].elements[(i + 1)].style.visibility.toUpperCase() == "HIDDEN";
          }

          // Passa o foco ao próximo campo
          document.forms[indiceFormulario].elements[(i + 1)].focus();

          // Seleciona o conteúdo dos campos TEXT ou TEXTAREA
          if (tipoCampo == "TEXT" || tipoCampo == "TEXTAREA")
            document.forms[indiceFormulario].elements[(i + 1)].select();

          verificaTab = false;
          sepDecimalDigitado = false;
          sinalDigitado = false;
          break;
        }
      }
    }
  }
  catch (erro)
  {
  }
}

// Função para formatar a entrada de dados de campos livres
function formataInputLivre(objCampo, eventoKeyPress)
{
  // Verifica a necessidade de mudar o foco para o próximo registro
  checarTab();

  // Verifica se o browser é Internet Explorer
  if (document.all)
    var codigoTecla = eventoKeyPress.keyCode;
  else
    // Verifica se o browser é Nestcape
    if(document.layers)
      var codigoTecla = eventoKeyPress.which;

  // Se o Enter for pressionado, pula para o próximo campo (Enter = Tab)
  if (codigoTecla == 13)
  {
    autoTab(objCampo, objCampo.value.length);
    return false;
  }
  else
    return true;
}

// Função para formatar a entrada de dados de campos do tipo Data
function formataInputData(objCampo, eventoKeyPress)
{
  // Verifica a necessidade de mudar o foco para o próximo registro
  checarTab();

  // Verifica se o browser é Internet Explorer
  if (document.all)
    var codigoTecla = eventoKeyPress.keyCode;
  else
    // Verifica se o browser é Nestcape
    if(document.layers)
      var codigoTecla = eventoKeyPress.which;

  // Se o Enter for pressionado, pula para o próximo campo (Enter = Tab)
  if (codigoTecla == 13) autoTab(objCampo, objCampo.value.length);

  // Verifica se o campo está selecionado e se o valor digitado é um número
  if (campoSelecionado && codigoTecla > 47 && codigoTecla < 58)
  {
    campoSelecionado = false;
    return true;
  }

  // Verifica se o campo está completamente preenchido e se o valor digitado é um número
  if (codigoTecla > 47 && codigoTecla < 58 && objCampo.value.length < objCampo.maxLength)
  {
    var valorCampo = replaceAll(objCampo.value, "/", "");

    if (valorCampo.length >= 2 && valorCampo.length < 4)
      objCampo.value = valorCampo.substr(0, 2) + "/" + valorCampo.substr(2, valorCampo.length);
    else
    {
      if (valorCampo.length >= 4)
        objCampo.value = valorCampo.substr(0, 2) + "/" + valorCampo.substr(2, 2) + "/" +
          valorCampo.substr(4, valorCampo.length);
    }
    return true;
  }
  else
    return false;
}

// Função para formatar a entrada de dados de campos do tipo Mês/Ano
function formataInputMesAno(objCampo, eventoKeyPress)
{
  // Verifica a necessidade de mudar o foco para o próximo registro
  checarTab();

  // Verifica se o browser é Internet Explorer
  if (document.all)
    var codigoTecla = eventoKeyPress.keyCode;
  else
    // Verifica se o browser é Nestcape
    if(document.layers)
      var codigoTecla = eventoKeyPress.which;

  // Se o Enter for pressionado, pula para o próximo campo (Enter = Tab)
  if (codigoTecla == 13) autoTab(objCampo, objCampo.value.length);

  // Verifica se o campo está selecionado e se o valor digitado é um número
  if (campoSelecionado && codigoTecla > 47 && codigoTecla < 58)
  {
    campoSelecionado = false;
    return true;
  }

  // Verifica se o campo está completamente preenchido e se o valor digitado é um número
  if (codigoTecla > 47 && codigoTecla < 58 && objCampo.value.length < objCampo.maxLength)
  {
    var valorCampo = replaceAll(objCampo.value, "/", "");

    if (valorCampo.length >= 2 && valorCampo.length < 4)
      objCampo.value = valorCampo.substr(0, 2) + "/" + valorCampo.substr(2, valorCampo.length);
    else
    {
      if (valorCampo.length >= 4)
        objCampo.value = valorCampo.substr(0, 2) + "/" + valorCampo.substr(2, valorCampo.length);
    }
    return true;
  }
  else
    return false;
}

// Função para formatar a entrada de dados de campos do tipo Real (Ponto Flutuante)
function formataInputValorReal(objCampo, eventoKeyPress, numDecimais, possuiSinal)
{
  var separadorMilhares = ".";
  var separadorDecimais = ",";

  // Verifica a necessidade de mudar o foco para o próximo registro
  checarTab();

  // Verifica se o browser é Internet Explorer
  if (document.all)
    var codigoTecla = eventoKeyPress.keyCode;
  else
    // Verifica se o browser é Nestcape
    if(document.layers)
      var codigoTecla = eventoKeyPress.which;

  // Se o Enter for pressionado, pula para o próximo campo (Enter = Tab)
  if (codigoTecla == 13) autoTab(objCampo, objCampo.value.length);

  // Verifica se o separador de decimais foi pressionado
  if ((separadorDecimais == "," && codigoTecla == 44) || (separadorDecimais == "." && codigoTecla == 46))
    sepDecimalDigitado = true;

  // Verifica se o sinal foi pressionado
  if (possuiSinal && (codigoTecla == 43 || codigoTecla == 45))
  {
    sinalDigitado = true;

    // Verifica se existe apenas um espaço em branco no campo
    if (objCampo.value == " ")
      objCampo.value = "";
  }

  // Verifica se o valor no campo possui o separador de decimais e os decimais já estão todos preenchidos
  if (objCampo.value.indexOf(separadorDecimais) > -1 && objCampo.value.length >= numDecimais + 2)
    sepDecimalDigitado = false;

  // Verifica se o campo está selecionado e se a tecla pressionada é válida
  if (campoSelecionado && ((codigoTecla > 47 && codigoTecla < 58) || sepDecimalDigitado || sinalDigitado))
  {
    campoSelecionado = false;
    return true;
  }

  // Verifica se o campo permite entrada de sinais e se o valor no campo já possui um caracter de sinal
  if (possuiSinal && (objCampo.value.indexOf("-") > -1 || objCampo.value.indexOf("+") > -1 || objCampo.value.indexOf(" ") > -1))
    sinalDigitado = false;

  // Verifica se o campo possui sinal e se um número foi digitado
  if (possuiSinal && (codigoTecla > 47) && (codigoTecla < 58) && objCampo.value.length <= 1)
  {
    if (objCampo.value.indexOf("-") < 0 && objCampo.value.indexOf("+") < 0 && objCampo.value.indexOf(" ") < 0)
    {
      objCampo.value = " " + objCampo.value;
      return true;
    }
  }

  // Verifica se o campo está completamente preenchido e se o valor digitado é um número
  if ((codigoTecla > 47 && codigoTecla < 58 && objCampo.value.length < objCampo.maxLength) || sepDecimalDigitado || sinalDigitado)
  {
    // Remove os caracteres de formatação do campo
    var valorCampo = replaceAll(objCampo.value, separadorMilhares, "");

    // Verifica se o separador de decimais não foi digitado, para remover esse caracter do campo
    if (! sepDecimalDigitado)
      valorCampo = valorCampo.replace(separadorDecimais, "");

    // Se o campo possuir sinal, armazena o sinal digitado e remove este caracter
    var caracterSinal = "";
    if (possuiSinal && (valorCampo.indexOf("-") > -1 || valorCampo.indexOf("+") > -1 || valorCampo.indexOf(" ") > -1))
    {
      caracterSinal = valorCampo.substr(0, 1);
      valorCampo = valorCampo.replace(caracterSinal, "");
    }

    // Verifica se o tamanho do valor é maior que o número de casas decimais
    if (valorCampo.length > (numDecimais - 1) && ! sepDecimalDigitado)
    {
      // Quebra o valor em duas partes (inteira e decimal)
      var porcaoInteira = valorCampo.substr(0, valorCampo.length - numDecimais + 1);
      var porcaoDecimal = valorCampo.substr(valorCampo.length - numDecimais + 1, numDecimais);
      var tamanhoInteiro = porcaoInteira.length;

      // Verifica se o inteiro possui mais de 3 dígitos
      if (tamanhoInteiro > 3)
      {
        // Declaração/inicialização das variáveis auxiliares
        var restoDivisao = (tamanhoInteiro % 3);              // Resto da divisão do tamanho da porção inteira por 3
        var divInteira = (tamanhoInteiro - restoDivisao) / 3; // Valor inteiro da divisão do tamanho da porção inteira por 3
        var inteiroFormatado = "";                            // Valor inteiro formatado, com os separadores de milhares
        var qtdeSeparadores = 0;                              // Quantidade de separadores que serão incluídos na formatação

        // Verifica se o tamanho da porção inteira é um valor divisível por 3
        if (restoDivisao == 0)
        {
          // Conta o número de separadores que deverão ser incluídos
          qtdeSeparadores = divInteira;

          // Formata a porção inteira, incluindo o separador de milhar
          for (var i = 0; i < qtdeSeparadores; i++)
          {
            // Verifica se o separador de milhar deve ser incluído
            if (i < qtdeSeparadores - 1)
              inteiroFormatado += porcaoInteira.substr(i * 3, 3) + separadorMilhares;
            else
              inteiroFormatado += porcaoInteira.substr(i * 3, 3);
          }
        }
        else
        {
          // Conta o número de separadores que deverão ser incluídos
          qtdeSeparadores = divInteira + 1;

          // Quebra a porção inteira em duas partes, já que o tamanho não é divisível por 3
          var valorAux1 = porcaoInteira.substr(0, restoDivisao); // Primeira parte da porção inteira
          var valorAux2 = porcaoInteira.substr(restoDivisao);    // Segunda parte da porção inteira (divisível por 3)

          // Formata a porção inteira, incluindo o separador de milhar
          for (var i = 0; i < qtdeSeparadores - 1; i++)
          {
            // Verifica se o separador de milhar deve ser incluído
            if (i < qtdeSeparadores - 2)
              inteiroFormatado += valorAux2.substr(i * 3, 3) + separadorMilhares;
            else
              inteiroFormatado += valorAux2.substr(i * 3, 3);
          }
          inteiroFormatado = valorAux1 + separadorMilhares + inteiroFormatado;
        } // if (restoDivisao == 0)

        objCampo.value = inteiroFormatado + separadorDecimais + porcaoDecimal; // Preenche o campo com o valor formatado
      }
      else
        objCampo.value = porcaoInteira + separadorDecimais + porcaoDecimal; // Preenche o campo com o valor formatado
    }
    else
      objCampo.value = valorCampo; // Preenche o campo com o valor formatado

    // Verifica se o campo possui sinal
    if (possuiSinal)
    {
      // Inclui o sinal no início do campo
      objCampo.value = caracterSinal + objCampo.value;

      // Troca o sinal "+" por um espaço em branco
      objCampo.value = objCampo.value.replace("+", " ");
    }
    return true; // Entrada de dados correta
  }
  else
    return false; // Caracter inválido
}

// Função para formatar a entrada de dados de campos do tipo Indice percentual (Ponto Flutuante)
function formataInputValorIndice(objCampo, eventoKeyPress, numDecimais, possuiSinal)
{
  // Separador de milhares nulo, unica diferença dessa função para a formataInputValorReal
  var separadorMilhares = "";
  var separadorDecimais = ",";

  // Verifica a necessidade de mudar o foco para o próximo registro
  checarTab();

  // Verifica se o browser é Internet Explorer
  if (document.all)
    var codigoTecla = eventoKeyPress.keyCode;
  else
    // Verifica se o browser é Nestcape
    if(document.layers)
      var codigoTecla = eventoKeyPress.which;

  // Se o Enter for pressionado, pula para o próximo campo (Enter = Tab)
  if (codigoTecla == 13) autoTab(objCampo, objCampo.value.length);

  // Verifica se o separador de decimais foi pressionado
  if ((separadorDecimais == "," && codigoTecla == 44) || (separadorDecimais == "." && codigoTecla == 46))
    sepDecimalDigitado = true;

  // Verifica se o sinal foi pressionado
  if (possuiSinal && (codigoTecla == 43 || codigoTecla == 45))
  {
    sinalDigitado = true;

    // Verifica se existe apenas um espaço em branco no campo
    if (objCampo.value == " ")
      objCampo.value = "";
  }

  // Verifica se o valor no campo possui o separador de decimais e os decimais já estão todos preenchidos
  if (objCampo.value.indexOf(separadorDecimais) > -1 && objCampo.value.length >= numDecimais + 2)
    sepDecimalDigitado = false;

  // Verifica se o campo está selecionado e se a tecla pressionada é válida
  if (campoSelecionado && ((codigoTecla > 47 && codigoTecla < 58) || sepDecimalDigitado || sinalDigitado))
  {
    campoSelecionado = false;
    return true;
  }

  // Verifica se o campo permite entrada de sinais e se o valor no campo já possui um caracter de sinal
  if (possuiSinal && (objCampo.value.indexOf("-") > -1 || objCampo.value.indexOf("+") > -1 || objCampo.value.indexOf(" ") > -1))
    sinalDigitado = false;

  // Verifica se o campo possui sinal e se um número foi digitado
  if (possuiSinal && (codigoTecla > 47) && (codigoTecla < 58) && objCampo.value.length <= 1)
  {
    if (objCampo.value.indexOf("-") < 0 && objCampo.value.indexOf("+") < 0 && objCampo.value.indexOf(" ") < 0)
    {
      objCampo.value = " " + objCampo.value;
      return true;
    }
  }

  // Verifica se o campo está completamente preenchido e se o valor digitado é um número
  if ((codigoTecla > 47 && codigoTecla < 58 && objCampo.value.length < objCampo.maxLength) || sepDecimalDigitado || sinalDigitado)
  {
    var valorCampo = objCampo.value;

    // Verifica se o separador de decimais não foi digitado, para remover esse caracter do campo
    if (! sepDecimalDigitado)
      valorCampo = valorCampo.replace(separadorDecimais, "");

    // Se o campo possuir sinal, armazena o sinal digitado e remove este caracter
    var caracterSinal = "";
    if (possuiSinal && (valorCampo.indexOf("-") > -1 || valorCampo.indexOf("+") > -1 || valorCampo.indexOf(" ") > -1))
    {
      caracterSinal = valorCampo.substr(0, 1);
      valorCampo = valorCampo.replace(caracterSinal, "");
    }

    // Verifica se o tamanho do valor é maior que o número de casas decimais
    if (valorCampo.length > (numDecimais - 1) && ! sepDecimalDigitado)
    {
      // Quebra o valor em duas partes (inteira e decimal)
      var porcaoInteira = valorCampo.substr(0, valorCampo.length - numDecimais + 1);
      var porcaoDecimal = valorCampo.substr(valorCampo.length - numDecimais + 1, numDecimais);
      var tamanhoInteiro = porcaoInteira.length;

      objCampo.value = porcaoInteira + separadorDecimais + porcaoDecimal; // Preenche o campo com o valor formatado
    }
    else
      objCampo.value = valorCampo; // Preenche o campo com o valor formatado

    // Verifica se o campo possui sinal
    if (possuiSinal)
    {
      // Inclui o sinal no início do campo
      objCampo.value = caracterSinal + objCampo.value;

      // Troca o sinal "+" por um espaço em branco
      objCampo.value = objCampo.value.replace("+", " ");
    }
    return true; // Entrada de dados correta
  }
  else
    return false; // Caracter inválido
}

// Função para formatar a entrada de dados de campos do tipo Inteiro
function formataInputValorInteiro(objCampo, eventoKeyPress, possuiSinal)
{
  var separadorMilhares = ".";

  // Verifica a necessidade de mudar o foco para o próximo registro
  checarTab();

  // Verifica se o browser é Internet Explorer
  if (document.all)
    var codigoTecla = eventoKeyPress.keyCode;
  else
    // Verifica se o browser é Nestcape
    if(document.layers)
      var codigoTecla = eventoKeyPress.which;

  // Se o Enter for pressionado, pula para o próximo campo (Enter = Tab)
  if (codigoTecla == 13) autoTab(objCampo, objCampo.value.length);

  // Verifica se o sinal foi pressionado
  if (possuiSinal && (codigoTecla == 43 || codigoTecla == 45))
  {
    sinalDigitado = true;

    // Verifica se existe apenas um espaço em branco no campo
    if (objCampo.value == " ")
      objCampo.value = "";
  }

  // Verifica se o campo está selecionado e se a tecla pressionada é válida
  if (campoSelecionado && ((codigoTecla > 47 && codigoTecla < 58) || sinalDigitado))
  {
    campoSelecionado = false;
    return true;
  }

  // Verifica se o campo permite entrada de sinais e se o valor no campo já possui um caracter de sinal
  if (possuiSinal && (objCampo.value.indexOf("-") > -1 || objCampo.value.indexOf("+") > -1 || objCampo.value.indexOf(" ") > -1))
    sinalDigitado = false;

  // Verifica se o campo possui sinal e se um número foi digitado
  if (possuiSinal && (codigoTecla > 47) && (codigoTecla < 58) && objCampo.value.length <= 1)
  {
    if (objCampo.value.indexOf("-") < 0 && objCampo.value.indexOf("+") < 0 && objCampo.value.indexOf(" ") < 0)
    {
      objCampo.value = " " + objCampo.value;
      return true;
    }
  }

  // Verifica se o campo está completamente preenchido e se o valor digitado é um número
  if ((codigoTecla > 47 && codigoTecla < 58 && objCampo.value.length < objCampo.maxLength) || sinalDigitado)
  {
    // Remove os caracteres de formatação do campo
    var valorCampo = replaceAll(objCampo.value, separadorMilhares, "");

    // Se o campo possuir sinal, armazena o sinal digitado e remove este caracter
    var caracterSinal = "";
    if (possuiSinal && (valorCampo.indexOf("-") > -1 || valorCampo.indexOf("+") > -1 || valorCampo.indexOf(" ") > -1))
    {
      caracterSinal = valorCampo.substr(0, 1);
      valorCampo = valorCampo.replace(caracterSinal, "");
    }

    // Inicialização das variáveis auxiliares da formatação do campo
    var porcaoInteira = valorCampo;
    var tamanhoInteiro = porcaoInteira.length + 1;

    // Verifica se o inteiro possui mais de 3 dígitos
    if (tamanhoInteiro > 3)
    {
      // Declaração/inicialização das variáveis auxiliares
      var restoDivisao = (tamanhoInteiro % 3);              // Resto da divisão do tamanho da porção inteira por 3
      var divInteira = (tamanhoInteiro - restoDivisao) / 3; // Valor inteiro da divisão do tamanho da porção inteira por 3
      var inteiroFormatado = "";                            // Valor inteiro formatado, com os separadores de milhares
      var qtdeSeparadores = 0;                              // Quantidade de separadores que serão incluídos na formatação

      // Verifica se o tamanho da porção inteira é um valor divisível por 3
      if (restoDivisao == 0)
      {
        // Conta o número de separadores que deverão ser incluídos
        qtdeSeparadores = divInteira;

        // Formata a porção inteira, incluindo o separador de milhar
        for (var i = 0; i < qtdeSeparadores; i++)
        {
          // Verifica se o separador de milhar deve ser incluído
          if (i < qtdeSeparadores - 1)
            inteiroFormatado += porcaoInteira.substr(i * 3, 3) + separadorMilhares;
          else
            inteiroFormatado += porcaoInteira.substr(i * 3, 3);
        }
      }
      else
      {
        // Conta o número de separadores que deverão ser incluídos
        qtdeSeparadores = divInteira + 1;

        // Quebra a porção inteira em duas partes, já que o tamanho não é divisível por 3
        var valorAux1 = porcaoInteira.substr(0, restoDivisao); // Primeira parte da porção inteira
        var valorAux2 = porcaoInteira.substr(restoDivisao);    // Segunda parte da porção inteira (divisível por 3)

        // Formata a porção inteira, incluindo o separador de milhar
        for (var i = 0; i < qtdeSeparadores - 1; i++)
        {
          // Verifica se o separador de milhar deve ser incluído
          if (i < qtdeSeparadores - 2)
            inteiroFormatado += valorAux2.substr(i * 3, 3) + separadorMilhares;
          else
            inteiroFormatado += valorAux2.substr(i * 3, 3);
        }
        inteiroFormatado = valorAux1 + separadorMilhares + inteiroFormatado;
      } // if (restoDivisao == 0)

      objCampo.value = inteiroFormatado; // Preenche o campo com o valor formatado
    }
    else
      objCampo.value = porcaoInteira; // Preenche o campo com o valor formatado

    // Verifica se o campo possui sinal
    if (possuiSinal)
    {
      // Inclui o sinal no início do campo
      objCampo.value = caracterSinal + objCampo.value;

      // Troca o sinal "+" por um espaço em branco
      objCampo.value = objCampo.value.replace("+", " ");
    }
    return true; // Entrada de dados correta
  }
  else
    return false; // Caracter inválido
}

// Função para permitir somente texto (caracteres de "A" a "Z", "a" a "z" e espaço) na entrada de dados do campo
function formataInputApenasTexto(objCampo, eventoKeyPress)
{
  // Verifica a necessidade de mudar o foco para o próximo registro
  checarTab();

  // Verifica se o browser é Internet Explorer
  if (document.all)
    var codigoTecla = eventoKeyPress.keyCode;
  else
    // Verifica se o browser é Nestcape
    if(document.layers)
      var codigoTecla = eventoKeyPress.which;

  // Se o Enter for pressionado, pula para o próximo campo (Enter = Tab)
  if (codigoTecla == 13) autoTab(objCampo, objCampo.value.length);
 
  // Verifica se o campo está selecionado e se o valor digitado é um caracter
  if (campoSelecionado && ((codigoTecla > 64 && codigoTecla < 91) || (codigoTecla > 96 && codigoTecla < 123) || codigoTecla == 32))
  {
    campoSelecionado = false;
    return true;
  }

  // Verifica se o campo está completamente preenchido e se o valor digitado é um caracter entre "A" e "Z", "a" e "z" ou espaço
  if ((codigoTecla == 32 || (codigoTecla > 64 && codigoTecla < 91) || (codigoTecla > 96 && codigoTecla < 123)) && objCampo.value.length < objCampo.maxLength)
    return true;
  else
    return false;
}

// Função para permitir somente números (0 a 9) na entrada de dados do campo, sem formatação
function formataInputApenasNumeros(objCampo, eventoKeyPress)
{
  // Verifica a necessidade de mudar o foco para o próximo registro
  checarTab();

  // Verifica se o browser é Internet Explorer
  if (document.all)
    var codigoTecla = eventoKeyPress.keyCode;
  else
    // Verifica se o browser é Nestcape
    if(document.layers)
      var codigoTecla = eventoKeyPress.which;

  // Se o Enter for pressionado, pula para o próximo campo (Enter = Tab)
  if (codigoTecla == 13) autoTab(objCampo, objCampo.value.length);

  // Verifica se o campo está selecionado e se o valor digitado é um número
  if (campoSelecionado && codigoTecla > 47 && codigoTecla < 58)
  {
    campoSelecionado = false;
    return true;
  }

  // Verifica se o campo está completamente preenchido e se o valor digitado é um número
  if (codigoTecla > 47 && codigoTecla < 58 && objCampo.value.length < objCampo.maxLength)
    return true;
  else
    return false;
}

// Função para formatar a entrada de dados de campos do tipo Hora
function formataInputHora(objCampo, eventoKeyPress)
{
  // Verifica a necessidade de mudar o foco para o próximo registro
  checarTab();

  // Verifica se o browser é Internet Explorer
  if (document.all)
    var codigoTecla = eventoKeyPress.keyCode;
  else
    // Verifica se o browser é Nestcape
    if(document.layers)
      var codigoTecla = eventoKeyPress.which;

  // Se o Enter for pressionado, pula para o próximo campo (Enter = Tab)
  if (codigoTecla == 13) autoTab(objCampo, objCampo.value.length);

  // Verifica se o campo está selecionado e se o valor digitado é um número
  if (campoSelecionado && codigoTecla > 47 && codigoTecla < 58)
  {
    campoSelecionado = false;
    return true;
  }

  // Verifica se o campo está completamente preenchido e se o valor digitado é um número
  if (codigoTecla > 47 && codigoTecla < 58 && objCampo.value.length < objCampo.maxLength)
  {
    var valorCampo = replaceAll(objCampo.value, ":", "");

    if (valorCampo.length >= 2 && valorCampo.length < 4)
      objCampo.value = valorCampo.substr(0, 2) + ":" + valorCampo.substr(2, valorCampo.length);
    else
    {
      if (valorCampo.length >= 4)
        objCampo.value = valorCampo.substr(0, 2) + ":" + valorCampo.substr(2, 2) + ":" +
          valorCampo.substr(4, valorCampo.length);
    }
    return true;
  }
  else
    return false;
}

// Função para fazer o enter funcionar como tab no campo
function enterIsTab(objCampo, eventoKeyPress)
{
  // Aborta a função se for Netscape
  if (navigator.appName == "Netscape") return;

  // Verifica se o browser é Internet Explorer
  if (document.all)
    var codigoTecla = eventoKeyPress.keyCode;
  else
    // Verifica se o browser é Nestcape
    if(document.layers)
      var codigoTecla = eventoKeyPress.which;

  // Se o Enter for pressionado, pula para o próximo campo (Enter = Tab)
  if (codigoTecla == 13)
  {
    try
    {
      var i = 0, j = 0, indiceFormulario = -1;
      var tipoCampo = "";

      // Localiza o form onde está localizado o campo atual
      for (i = 0; i < document.forms.length; i++)
      {
        for (j = 0; j < document.forms[i].elements.length; j++)
          if (document.forms[i].elements[j].name == objCampo.name)
          {
            indiceFormulario = i;
            break;
          }
          
        if (indiceFormulario != -1)
          break;
      }

      // Localiza o próximo campo do form
      for (i = 0; i <= document.forms[indiceFormulario].elements.length; i++)
      {
        if (document.forms[indiceFormulario].elements[i].name == objCampo.name)
        {
          tipoCampo = document.forms[indiceFormulario].elements[(i + 1)].type.toUpperCase();
          var campoDesabilitado = document.forms[indiceFormulario].elements[(i + 1)].disabled;
          var campoInvisivel = document.forms[indiceFormulario].elements[(i + 1)].style.visibility.toUpperCase() == "HIDDEN";

          // Ignora os campos HIDDEN, RADIO, CHECKBOX, campos desabilitados e invisíveis
          while (i < document.forms[indiceFormulario].length && (tipoCampo == "HIDDEN" || tipoCampo == "RADIO" || tipoCampo == "CHECKBOX" || campoDesabilitado || campoInvisivel))
          {
            i++;
            tipoCampo = document.forms[indiceFormulario].elements[(i + 1)].type.toUpperCase();
            campoDesabilitado = document.forms[indiceFormulario].elements[(i + 1)].disabled;
            campoInvisivel = document.forms[indiceFormulario].elements[(i + 1)].style.visibility.toUpperCase() == "HIDDEN";
          }

          // Passa o foco ao próximo campo
          document.forms[indiceFormulario].elements[(i + 1)].focus();

          // Seleciona o conteúdo dos campos TEXT ou TEXTAREA
          if (tipoCampo == "TEXT" || tipoCampo == "TEXTAREA")
            document.forms[indiceFormulario].elements[(i + 1)].select();

          verificaTab = false;
          sepDecimalDigitado = false;
          sinalDigitado = false;
          break;
        }
      }
    }
    catch (erro)
    {
    }
    return false;
  }
  return true;
}



// Função para formatar a entrada de dados de campos do 999999/99
// O valor 'antes' significa o numero de casa antes da barra
function formataInputBarra(objCampo, eventoKeyPress, casas)
{
  // Verifica a necessidade de mudar o foco para o próximo registro
  checarTab();

  // Verifica se o browser é Internet Explorer
  if (document.all)
    var codigoTecla = eventoKeyPress.keyCode;
  else
    // Verifica se o browser é Nestcape
    if(document.layers)
      var codigoTecla = eventoKeyPress.which;

  // Se o Enter for pressionado, pula para o próximo campo (Enter = Tab)
  if (codigoTecla == 13) autoTab(objCampo, objCampo.value.length);

  // Verifica se o campo está selecionado e se o valor digitado é um número
  if (campoSelecionado && codigoTecla > 47 && codigoTecla < 58)
  {
    campoSelecionado = false;
    return true;
  }

  // Verifica se o campo está completamente preenchido e se o valor digitado é um número
  if (codigoTecla > 47 && codigoTecla < 58 && objCampo.value.length < objCampo.maxLength)
  {
    var valorCampo = replaceAll(objCampo.value, "/", "");

    if (valorCampo.length >= casas && valorCampo.length < (objCampo.maxLength-1))
      objCampo.value = valorCampo.substr(0, valorCampo.length-casas+1) + "/" + valorCampo.substr(valorCampo.length-casas+1, valorCampo.length);
    else
    {
      if (valorCampo.length >= (objCampo.maxLength-1))
        objCampo.value = valorCampo.substr(0, casas) + "/" + valorCampo.substr(6, valorCampo.length);
    }
    return true;
  }
  else
    return false;
}



// Função para permitir somente números (0 a 9) na entrada de dados do campo, sem formatação
function formataCPF(objCampo, eventoKeyPress, TipoPrem)
{
  // Verifica a necessidade de mudar o foco para o próximo registro
  checarTab();
  var tipo = TipoPrem.value;
  // Verifica se o browser é Internet Explorer
  if (document.all)
    var codigoTecla = eventoKeyPress.keyCode;
  else
    // Verifica se o browser é Nestcape
    if(document.layers)
      var codigoTecla = eventoKeyPress.which;

  // Se o Enter for pressionado, pula para o próximo campo (Enter = Tab)
  if (codigoTecla == 13) autoTab(objCampo, objCampo.value.length);

  // Verifica se o campo está selecionado e se o valor digitado é um número
  if (campoSelecionado && codigoTecla > 47 && codigoTecla < 58)
  {
    campoSelecionado = false;
    return true;
  }

  // Verifica se o campo está completamente preenchido e se o valor digitado é um número
  if (codigoTecla > 47 && codigoTecla < 58 && objCampo.value.length < objCampo.maxLength)
  {
    var valorCampo = replaceAll(objCampo.value, ".", "");
    valorCampo = replaceAll(valorCampo, "-", "");
    valorCampo = replaceAll(valorCampo, "/", "");

    if (tipo == "F")
    {
		if (valorCampo.length >= 3 && valorCampo.length < 6)
		  objCampo.value = valorCampo.substr(0, 3) + "." + valorCampo.substr(3, valorCampo.length);
		else {
				if (valorCampo.length >= 6 && valorCampo.length < 9)
				 objCampo.value = valorCampo.substr(0, 3) + "." + valorCampo.substr(3, 3)+ "." + valorCampo.substr(6, valorCampo.length);
				else
				{ 
				 if (valorCampo.length >= 9)
				  objCampo.value = valorCampo.substr(0, 3) + "." + valorCampo.substr(3, 3) + "." + valorCampo.substr(6, 3) + "-" + valorCampo.substr(9, valorCampo.length); 
				}
			 }
	}
	else
	{
		if (valorCampo.length >= 2 && valorCampo.length < 5)
		  objCampo.value = valorCampo.substr(0, 2) + "." + valorCampo.substr(2, valorCampo.length);
		else {
				if (valorCampo.length >= 5 && valorCampo.length < 8)
				 objCampo.value = valorCampo.substr(0, 2) + "." + valorCampo.substr(2, 3)+ "." + valorCampo.substr(5, valorCampo.length);
				else
				{ 
				 if (valorCampo.length >= 8 && valorCampo.length < 12)
				  objCampo.value = valorCampo.substr(0, 2) + "." + valorCampo.substr(2, 3)+ "." + valorCampo.substr(5, 3) + "/" + valorCampo.substr(8, valorCampo.length); 
				 else
				 {
				  if (valorCampo.length >= 12)
				   objCampo.value = valorCampo.substr(0, 2) + "." + valorCampo.substr(2, 3)+ "." + valorCampo.substr(5, 3) + "/" + valorCampo.substr(8, 4) + "-" + valorCampo.substr(12, valorCampo.length);
				 }
				}
			 }
	}
    return true;
  }
  else
    return false;

}

// Função para permitir somente números (0 a 9) na entrada de dados do campo, sem formatação
function formataTelefone(objCampo, eventoKeyPress)
{
  // Verifica a necessidade de mudar o foco para o próximo registro
  checarTab();

  // Verifica se o browser é Internet Explorer
  if (document.all)
    var codigoTecla = eventoKeyPress.keyCode;
  else
    // Verifica se o browser é Nestcape
    if(document.layers)
      var codigoTecla = eventoKeyPress.which;

  // Se o Enter for pressionado, pula para o próximo campo (Enter = Tab)
  if (codigoTecla == 13) autoTab(objCampo, objCampo.value.length);

  // Verifica se o campo está selecionado e se o valor digitado é um número
  if (campoSelecionado && codigoTecla > 47 && codigoTecla < 58)
  {
    campoSelecionado = false;
    return true;
  }

  // Verifica se o campo está completamente preenchido e se o valor digitado é um número
  if ((codigoTecla > 47 && codigoTecla < 58 && objCampo.value.length < objCampo.maxLength) || (codigoTecla == 32))
  {
    var valorCampo = replaceAll(objCampo.value, "(", "");
    valorCampo = replaceAll(valorCampo, "-", "");
    valorCampo = replaceAll(valorCampo, ")", "");

    if (valorCampo.length == 1)
      objCampo.value = "(" + valorCampo.substr(0, 1)
    else {
			if (valorCampo.length >= 2 && valorCampo.length < 6)
			 objCampo.value = "(" + valorCampo.substr(0, 2) + ")" + valorCampo.substr(2, valorCampo.length);
			else
			{ 
			 if (valorCampo.length >= 6)
			  objCampo.value = "(" + valorCampo.substr(0, 2) + ")" + valorCampo.substr(2, 4) + "-" + valorCampo.substr(6, valorCampo.length);
			}
		 }
    return true;
  }
  else
    return false;

}

// Função para permitir somente números (0 a 9) na entrada de dados do campo, sem formatação
function formataCEP(objCampo, eventoKeyPress)
{
  // Verifica a necessidade de mudar o foco para o próximo registro
  checarTab();

  // Verifica se o browser é Internet Explorer
  if (document.all)
    var codigoTecla = eventoKeyPress.keyCode;
  else
    // Verifica se o browser é Nestcape
    if(document.layers)
      var codigoTecla = eventoKeyPress.which;

  // Se o Enter for pressionado, pula para o próximo campo (Enter = Tab)
  if (codigoTecla == 13) autoTab(objCampo, objCampo.value.length);

  // Verifica se o campo está selecionado e se o valor digitado é um número
  if (campoSelecionado && codigoTecla > 47 && codigoTecla < 58)
  {
    campoSelecionado = false;
    return true;
  }

  // Verifica se o campo está completamente preenchido e se o valor digitado é um número
  if ((codigoTecla > 47 && codigoTecla < 58 && objCampo.value.length < objCampo.maxLength) || (codigoTecla == 32))
  {
    var valorCampo = replaceAll(objCampo.value, ".", "");
    valorCampo = replaceAll(valorCampo, "-", "");

    if (valorCampo.length >= 2 && valorCampo.length < 5)
      objCampo.value = valorCampo.substr(0, 2) + "." + valorCampo.substr(2, valorCampo.length);
    else {
			if (valorCampo.length >= 5)
			 objCampo.value = valorCampo.substr(0, 2)  + "." +  valorCampo.substr(2, 3) + "-" + valorCampo.substr(5, valorCampo.length);
		 }
    return true;
  }
  else
    return false;

}


function formataValorReal(objCampo, numDecimais, possuiSinal)
{
  var separadorMilhares = ".";
  var separadorDecimais = ",";

  // Remove os caracteres de formatação do campo
  objCampo.value = replaceAll(objCampo.value, ".", separadorDecimais);  
  var valorCampo = objCampo.value;
  
  if (valorCampo.indexOf(",") == -1)
	valorCampo = valorCampo + ",00";

  valorCampo = valorCampo + "000"		
  // Pega Somente Duas casas decimais
  valorCampo = valorCampo.substr(0,valorCampo.indexOf(",")+3);

  // Verifica se o separador de decimais não foi digitado, para remover esse caracter do campo
  valorCampo = valorCampo.replace(separadorDecimais, "");

    // Verifica se o tamanho do valor é maior que o número de casas decimais
    if (valorCampo.length > (numDecimais - 1))
    {
      // Quebra o valor em duas partes (inteira e decimal)
      var porcaoInteira = valorCampo.substr(0, valorCampo.length - numDecimais);
      var porcaoDecimal = valorCampo.substr(valorCampo.length - numDecimais, numDecimais);
      var tamanhoInteiro = porcaoInteira.length;

      // Verifica se o inteiro possui mais de 3 dígitos
      if (tamanhoInteiro > 3)
      {
        // Declaração/inicialização das variáveis auxiliares
        var restoDivisao = (tamanhoInteiro % 3);              // Resto da divisão do tamanho da porção inteira por 3
        var divInteira = (tamanhoInteiro - restoDivisao) / 3; // Valor inteiro da divisão do tamanho da porção inteira por 3
        var inteiroFormatado = "";                            // Valor inteiro formatado, com os separadores de milhares
        var qtdeSeparadores = 0;                              // Quantidade de separadores que serão incluídos na formatação

        // Verifica se o tamanho da porção inteira é um valor divisível por 3
        if (restoDivisao == 0)
        {
          // Conta o número de separadores que deverão ser incluídos
          qtdeSeparadores = divInteira;

          // Formata a porção inteira, incluindo o separador de milhar
          for (var i = 0; i < qtdeSeparadores; i++)
          {
            // Verifica se o separador de milhar deve ser incluído
            if (i < qtdeSeparadores - 1)
              inteiroFormatado += porcaoInteira.substr(i * 3, 3) + separadorMilhares;
            else
              inteiroFormatado += porcaoInteira.substr(i * 3, 3);
          }
        }
        else
        {
          // Conta o número de separadores que deverão ser incluídos
          qtdeSeparadores = divInteira + 1;

          // Quebra a porção inteira em duas partes, já que o tamanho não é divisível por 3
          var valorAux1 = porcaoInteira.substr(0, restoDivisao); // Primeira parte da porção inteira
          var valorAux2 = porcaoInteira.substr(restoDivisao);    // Segunda parte da porção inteira (divisível por 3)

          // Formata a porção inteira, incluindo o separador de milhar
          for (var i = 0; i < qtdeSeparadores - 1; i++)
          {
            // Verifica se o separador de milhar deve ser incluído
            if (i < qtdeSeparadores - 2)
              inteiroFormatado += valorAux2.substr(i * 3, 3) + separadorMilhares;
            else
              inteiroFormatado += valorAux2.substr(i * 3, 3);
          }
          inteiroFormatado = valorAux1 + separadorMilhares + inteiroFormatado;
        } // if (restoDivisao == 0)

        objCampo.value = inteiroFormatado + separadorDecimais + porcaoDecimal; // Preenche o campo com o valor formatado
      }
      else
        objCampo.value = porcaoInteira + separadorDecimais + porcaoDecimal; // Preenche o campo com o valor formatado
    }
    else
      objCampo.value = valorCampo; // Preenche o campo com o valor formatado

    // Verifica se o campo possui sinal
    if (possuiSinal)
    {
      // Inclui o sinal no início do campo
      objCampo.value = caracterSinal + objCampo.value;

      // Troca o sinal "+" por um espaço em branco
      objCampo.value = objCampo.value.replace("+", " ");
    }
    return true; // Entrada de dados correta
}

function formataNumCartao(objCampo)
{
		  var zeros;
		  var valorCampo = objCampo.value;
		  var tamanhoValor = valorCampo.length;
		  zeros = "";
          for (var i = 0; i < (16 - tamanhoValor); i++)
          {
            zeros = zeros + "0";
          }
          objCampo.value = zeros + valorCampo;
          
          return true;
}



// Função para permitir somente números (0 a 9) na entrada de dados do campo, sem formatação
function formataCartao(form, objCampo, eventoKeyPress)
{
  
  // Verifica a necessidade de mudar o foco para o próximo registro
  checarTab();

  // Verifica se o browser é Internet Explorer
  if (document.all)
    var codigoTecla = eventoKeyPress.keyCode;
  else
    // Verifica se o browser é Nestcape
    if(document.layers)
      var codigoTecla = eventoKeyPress.which;

  // Se o Enter for pressionado, pula para o próximo campo (Enter = Tab)
  if (codigoTecla == 13) autoTab(objCampo, objCampo.value.length);

  // Verifica se o campo está selecionado e se o valor digitado é um número
  if (campoSelecionado && codigoTecla > 47 && codigoTecla < 58)
  {
    campoSelecionado = false;
    return true;
  }


  // Verifica se o campo está completamente preenchido e se o valor digitado é um número
  if ((codigoTecla > 47 && codigoTecla < 58 && objCampo.value.length < objCampo.maxLength) || (codigoTecla == 32))
  {
    var valorCampo = replaceAll(objCampo.value, ".", "");

    if (form.txtCampoInclusao.value == "Prem_num_cartao")
    if (valorCampo.length >= 4 && valorCampo.length < 8)
      objCampo.value = valorCampo.substr(0, 4) + "." + valorCampo.substr(4, valorCampo.length);
    else if (valorCampo.length >= 8 && valorCampo.length < 12)
		  objCampo.value = valorCampo.substr(0, 4) + "." + valorCampo.substr(4, 4) + "." + valorCampo.substr(8, valorCampo.length);	
		 else if (valorCampo.length >= 12){			
			 objCampo.value = valorCampo.substr(0, 4) + "." + valorCampo.substr(4, 4) + "." + valorCampo.substr(8, 4) + "." + valorCampo.substr(12, valorCampo.length);
		 }
    return true;
  }
  else
    return false;
}