/******************************************************************************/
/* Funções para formatação automática de campos                               */
/******************************************************************************/
// 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 converter valor do campo para Maiusculo
function toUpper(objCampo)
{
   // Convertendo para maiusculo
   objCampo.value = objCampo.value.toUpperCase();
}

// função para converter caracteres especial (acentos, cedilha) para letras normais
function converterCaracterEspecial(objCampo)
{
   var caracterEspecial = "äàáâãëèéêïìíîöòóôõüùúûñçÄÀÁÂÃËÈÉÊÏÌÍÎÖÒÓÔÕÜÙÚÛÑÇ`´^~%:;.,></?!@#$%¨&*()_+{}-=[]ºª§°\|¹²³£¢¬";
   var caracterNormal   = "aaaaaeeeeiiiiooooouuuuncAAAAAEEEEIIIIOOOOOUUUUNC '                                         ";

   var strCampoAtual = objCampo.value;
   var strCampoNovo = "";
   var strCaracter = "";
   
   for (var i = 0; i < strCampoAtual.length; i++)
   {
      strCaracter = strCampoAtual.substring(i, i+1);
      
      for (var j = 0; j <= caracterEspecial.length; j++)
      {
         if (strCaracter == caracterEspecial.substring(j, j+1))
         {
            strCaracter = caracterNormal.substring(j, j+1);
            break;
         }
      }
   
      strCampoNovo = strCampoNovo + strCaracter;
   }

   // Atribuindo valores convertidos
   objCampo.value = strCampoNovo;
}

// função para alinha o campo a esquerda e preechendo com caracteres
function leftPad(objCampo, intTamanhoCampo, strCaracter)
{
   var strCampoAtual = leftTrim(objCampo.value);
   var strCampoNovo = "";
   
   for (var i = 1; i < intTamanhoCampo; i++)
   {
      strCampoNovo = strCampoNovo + strCaracter;
   }
   // Atribuindo valores convertidos
   objCampo.value = strCampoNovo.substring(0, (strCampoNovo.length - strCampoAtual.length)+1) +
                    strCampoAtual;
}

// 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);

  // Se o campo for somente leitura (readonly), sai da função
  if (objCampo.readOnly == true) return false;

  // 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 permitir somente números (0 a 9) e Espacos na entrada de dados do campo, sem formatação
function formataInputApenasNumerosEspacos(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 
  if (campoSelecionado)
  {
     // valor digitado é um número
     if (codigoTecla > 47 && codigoTecla < 58)
     {
         campoSelecionado = false;
         return true;
     }
     else
     // valor digitado é um espaço
     if (codigoTecla == 32)
     {
        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
     // valor digitado é um espaço
     if (codigoTecla == 32)
        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 formatar a entrada de dados de campos do tipo Real (Ponto Flutuante)
function formataInputValorRealSemMilhar(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);

  // Se o campo for somente leitura (readonly), sai da função
  if (objCampo.readOnly == true) return false;

  // 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);

      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 do tipo Real (Ponto Flutuante)
function formataValorReal(dblCampo, numDecimais)
{
   var separadorMilhares = ".";
   var separadorDecimais = ",";
   
   var strCampo = replaceAll(dblCampo.toString(), ".", ",");
   
   // Verifica se o valor no campo possui o separador de decimais
   var bolPossuiDecimal = strCampo.indexOf(separadorDecimais) > -1;
   
   // Verifica se o campo possui sinal
   var bolPossuiSinal = strCampo.indexOf("-") > -1;
   
   // Retira o sinal, caso exista
   if (bolPossuiSinal) 
      strCampo = replaceAll(strCampo, "-", "");
   
   // Separa parte inteira e decimal
   var strParteInteira = "";
   var strParteDecimal = "";
   
   // Preparando parte decimal
   if (bolPossuiDecimal)
   {
      strParteInteira = strCampo.substr(0, strCampo.indexOf(separadorDecimais));
      strParteDecimal = strCampo.substr(strCampo.indexOf(separadorDecimais)+1);

      if (strParteDecimal.length < numDecimais)
      {
         for (var i = strParteDecimal.length; i < numDecimais; i++)
         {
            strParteDecimal += "0";
         }
      }
      else
      {
         if (strParteDecimal.length > numDecimais)
         {
            strParteDecimal = strParteDecimal.substr(0, numDecimais);
         }
      }
   }
   else
   {
      strParteInteira = strCampo;
      
      for (var i = strParteDecimal.length; i < numDecimais; i++)
      {
         strParteDecimal += "0";
      }
   }
   
   // Edita para inteira
   var tamanhoInteiro = strParteInteira.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 strInteiroFormatado = "";                         // 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)
               strInteiroFormatado += strParteInteira.substr(i * 3, 3) + separadorMilhares;
            else
               strInteiroFormatado += strParteInteira.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 = strParteInteira.substr(0, restoDivisao); // Primeira parte da porção inteira
         var valorAux2 = strParteInteira.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)
               strInteiroFormatado += valorAux2.substr(i * 3, 3) + separadorMilhares;
            else
               strInteiroFormatado += valorAux2.substr(i * 3, 3);
         }
         
         strInteiroFormatado = valorAux1 + separadorMilhares + strInteiroFormatado;
         
      } // if (restoDivisao == 0)
   }
   else
   {
      var strInteiroFormatado = strParteInteira;
   } // if (tamanhoInteiro > 3)
   
   if (bolPossuiSinal)
   {
      return "-" + strInteiroFormatado + separadorDecimais + strParteDecimal;
   }
   else
   {
      return strInteiroFormatado + separadorDecimais + strParteDecimal;
   }
   
}

function completaStringEsquerda(strValor, intTamanho, strCaracter)
{
   var strStringCaracter = "";
   var strStringRetorno = "";
   
   if (strValor.length < intTamanho)
   {
      for (var i = strValor.length; i < intTamanho; i++)
      {
         strStringCaracter += strCaracter;
      }
      
      strStringRetorno = strStringCaracter + strValor;
   }
   else
   {
      if (strValor.length == intTamanho)
      {
         strStringRetorno = strValor.substr(0, intTamanho);
      }
      else
      {
         for (var i = 0; i < intTamanho; i++)
         {
            strStringCaracter += strCaracter;
         }
         strStringRetorno = strStringCaracter;
      }
   }

   return strStringRetorno;
}

function completaStringDireita(strValor, intTamanho, strCaracter)
{
   var strStringCaracter = "";
   var strStringRetorno = "";
   
   if (strValor.length < intTamanho)
   {
      for (var i = strValor.length; i < intTamanho; i++)
      {
         strStringCaracter += strCaracter;
      }
      
      strStringRetorno = strValor + strStringCaracter;
   }
   else
   {
      if (strValor.length == intTamanho)
      {
         strStringRetorno = strValor.substr(0, intTamanho);
      }
      else
      {
         for (var i = 0; i < intTamanho; i++)
         {
            strStringCaracter += strCaracter;
         }
         strStringRetorno = strStringCaracter;
      }
   }

   return strStringRetorno;
}