/*
linha para incluir arquivo nas telas
  <link  type="text/css" rel="stylesheet" href="padrao.css">
  <script type="text/javascript"           src="basic.js"></script>
*/

// ************ ROTINAS PARA ENVIAR DADOS MODO AJAX ************
// variavel a ser utilizada para retorno do ajax
var ajax = false;
// funcao para montar linha de POST
function montaLinhaPost(pform)
{
   var form = document.forms[pform];
   var el = form.length;
   var linha = "";
   for (var i = 0; i < el; i++)
   {
      nome  = form.elements[i].name;
      if (nome != '')
      {
         valor = escape(form.elements[i].value);
         linha += nome + "=" + valor;
         if (i < (el - 1))
         { linha += "&"; }
      }
   }
   return linha;
}

// rotina para enviar os dados
function enviaDadosAjax(sArqAjax, sNmFormParaPost, fFuncao)
{
   var sLinha_post_ajx = '';
   if (window.XMLHttpRequest)
   {
      ajax = new XMLHttpRequest();
   }
   else if (window.ActiveXObject)
   {
      ajax = new ActiveXObject("Microsoft.XMLHTTP");
   }
   
   getCampo('hArq').value = sArqAjax;
   
//   var sLinha_post_ajx = montaLinhaPost(sNmFormParaPost);
   if(getCampo('frmPortalGlobecall') == undefined)
   {
		sLinha_post_ajx = montaLinhaPost(sNmFormParaPost);
//		alert(sNmFormParaPost+'\n'+sLinha_post_ajx);
	}
   else
   {
		sLinha_post_ajx = montaLinhaPost('frmPortalGlobecall');
//		alert('frmPortalGlobecall\n'+sLinha_post_ajx);
	}
   
   ajax.onreadystatechange = fFuncao;
   ajax.open("POST", 'procPortal.php', true);
   ajax.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
   ajax.send(sLinha_post_ajx);
}

function enviaDadosAjaxParaRetornoAsin(sArqAjax, sNmFormParaPost, objRetorno)
{
   var sLinha_post_ajx = '';
   if (window.XMLHttpRequest)
   {  ajax2 = new XMLHttpRequest(); }
   else if (window.ActiveXObject)
   {  ajax2 = new ActiveXObject("Microsoft.XMLHTTP"); }

   getCampo('hArq').value = sArqAjax;

//   var sLinha_post_ajx = montaLinhaPost(sNmFormParaPost);
   if(sNmFormParaPost == 'frmJanela')
   {
      sLinha_post_ajx = montaLinhaPost(sNmFormParaPost);
   }
   else
   {
      sLinha_post_ajx = montaLinhaPost('frmPortalGlobecall');
   }
   
   ajax2.onreadystatechange = new Function('retornoAjax("'+objRetorno+'");');
   ajax2.open("POST", 'procPortal.php', true);
   ajax2.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
   ajax2.send(sLinha_post_ajx);
}

function retornoAjax(objRet)
{
   var texto = '';
   var obj = getCampo(objRet);
   if (ajax2.readyState == 4)
   {
      texto = ajax2.responseText;
      texto=texto.replace(/\+/g," ");
      texto=unescape(texto);
   }
   else
   {
      texto = 'Carregando...';
   }
   if (obj != null)
   {
      obj.innerHTML = texto;
   }
}

function TAjax(pArqAjax, pNmFormParaPost)
{
   var ajax;
   var sArqAjax = '';
   var sNmFormParaPost = '';
   var objRetorno = '';
   var bExibeCarregando = true;
   var bModo = true;
   this.sArqAjax = pArqAjax;
   this.sNmFormParaPost = pNmFormParaPost;
   
   this.retornaParaObj = envDadosParaRetorno;

   function envDadosParaRetorno(pObjeto)
   {
      objRetorno = getCampo(pObjeto);
      ajax = null;
      if (window.XMLHttpRequest)
      {  ajax = new XMLHttpRequest(); }
      else if (window.ActiveXObject)
      {  ajax = new ActiveXObject("Microsoft.XMLHTTP"); }
      if (ajax !=null)
      {
         var sLinha_post_ajx = montaLinhaPost(this.sNmFormParaPost);
         ajax.onreadystatechange = retAjax;
         ajax.open("POST", this.sArqAjax, this.bModo);
         ajax.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
         ajax.send(sLinha_post_ajx);
      }
      else
      { alert('Seu navegador nao suportar XMLHTTP.'); }
   }

   function retAjax()
   {
      var texto = '';
      var obj = objRetorno;
      if (ajax.readyState == 4)
      {
         texto = ajax.responseText;
         texto=texto.replace(/\+/g," ");
         texto=unescape(texto);
      }
      else
      {
        if (this.bExibeCarregando)
        {   texto = 'Carregando...'; }
        else
        { texto = ''; }
      }

      if (obj != null)
      {
        if (obj.getAttributeNode('value') != null)
        { obj.value = texto;}
        else
        { obj.innerHTML = texto;}
      }
   }
} // fim do objeto TAjax.

//-------------------------------

// ************ ROTINAS PARA VALIDAR DATAS ************
// rotina para validar digito de um campo para receber as datas
//   só sera aceito digitos numericos e / como separador
// sintaxe: onKeyPress='return (validaDigData(event));'
function validaDigData(e)
{
   var keynum = '';
   if(window.event) // IE
   { keynum = e.keyCode; }
   else if(e.which) // Netscape/Firefox/Opera
   { keynum = e.which;}

   var s = String.fromCharCode(keynum);
   if ((s<"0" || s>"9") && s != "/" && keynum != 13 && keynum != 8)
   {
      alert("Digite somente numeros e / como separador ");
      return false;
   }
}
// rotina para formatar a data no padrao
function formataData(pData)
{
   var sVar = new String(pData);
   if (sVar.search("/") < 0)
   {
      sVar = sVar.substr(0, 2)+'/'+sVar.substr(2, 2)+'/'+sVar.substr(4, 4);
   }
   return sVar;
}
// Rotina para validar a data digita
//  a data deve ser informada no seguinte formato: dd/mm/yyyy
// sintaxe: onBlur = validaData(this);
function validaData(obj)
{
  var erro = "-1";
  var sVal = new String(obj.value);
  var bValido = false;

  if  (sVal.length > 0)
  {
     sVal = formataData(sVal);
     obj.value = sVal;
     var sSpl = sVal.split("/");

     var dia, mes, ano;

     dia = sSpl[0];
     mes = sSpl[1];
     ano = sSpl[2];

     if ((sVal.length < 6) ||
         (dia.length <  1) || (dia.length > 2) ||
         (mes.length <  1) || (mes.length > 2) ||
         (ano.length != 4)
        )
     { erro = "Data invalida ";}
     else
     {
        if ( ano < 1900)
        { erro = "Ano invalido. Deve ser maior que 1900"; }
        else
        {  if (mes < 1 || mes > 12)
           {  erro = "Mês invalido. Deve estar entre 1 e 12"; }
           else
           {  d = new Date();
              d.setFullYear(eval(ano), eval(mes), 1);
              d.setDate(d.getDate()-1);
              var ultDia = d.getDate();

              if (dia < 1 || dia > ultDia)
              { erro = "Dia invalido. Deve estar entre 1 e "+ultDia; }
              else
              { if (mes == 2)
                { if (dia < 1 || dia > ultDia)
                  { erro = "Dia invalido. Deve estar entre 1 e "+ultDia+" para o mês de fevereiro."; }
                }
              }
           }
        }
     }

     if ((erro != "-1") && (obj.value != ""))
     {  obj.value = "";
        alert (erro);
        obj.focus();
        bValido = false;
     }
     else
     {
        bValido = true;
     }
  }
  else
  { bValido = true; }
  
  return bValido;
}

function validaPeriodo(dt1, dt2)
{ var spl1 = new String(dt1.value);
  var spl2 = new String(dt2.value);
  spl1 = spl1.split("/");
  spl2 = spl2.split("/");
  var num1, num2;

  num1 = spl1[2]+spl1[1]+spl1[0];
  num2 = spl2[2]+spl2[1]+spl2[0];

  if (eval(num1) > eval(num2))
  {
     alert('Periodo de datas invalido');
     dt2.focus();
  }
}
// sintaxe: onBlur='verificaDataAtual(this);'
function verificaDataAtual(pData)
{
   var sVal = new String(pData.value);
   var bErro = false;

   if  (sVal.length > 0)
   {
      sVal = formataData(sVal);
      pData.value = sVal;
      var sSpl = sVal.split("/");
      var dData = new Date();
      var dia, mes, ano;
      dia = sSpl[0];
      mes = sSpl[1];
      ano = sSpl[2];
      var dDtDig = new Date();
      dDtDig.setFullYear(eval(ano), eval(mes)-1, dia);
      if (dDtDig > dData)
      {
         bErro = true;
      }
   }
   if (bErro)
   {
      alert('Data informada maior que a data atual.\nVerifique!!!');
      pData.focus();
   }
}

function verificarData(pDataVerif, pHoraVerif,
                       pbComDataAtual, pOperador,
                       pDataMin, pHoraMin, pDataMax, pHoraMax)
{
   var DtVerif = new Date();
   var DtMin = new Date();
   var DtMax = new Date();
   var aHrVerif = '';
   var aHrMin = '';
   var aHrMax = '';
   var aVar = '';
   var dData = new Date();

   if (pDataVerif.length > 0)
   {
      aVar = formataData(pDataVerif).split("/");
      DtVerif.setFullYear(eval(aVar[2]), eval(aVar[1])-1, eval(aVar[0]));
   }
   if (pDataMin.length > 0)
   {
      aVar = formataData(pDataMin).split("/");
      DtMin.setFullYear(eval(aVar[2]), eval(aVar[1])-1, eval(aVar[0]));
   }
   if (pDataMax.length > 0)
   {
      aVar = formataData(pDataMax).split("/");
      DtMax.setFullYear(eval(aVar[2]), eval(aVar[1])-1, eval(aVar[0]));
   }

   if (pHoraVerif.length > 0)
   { aHrVerif = pHoraVerif.split(":"); }
   if (pHoraMin.length > 0)
   { aHrMin = pHoraMin.split(":"); }
   if (pHoraMax.length > 0)
   { aHrMax = pHoraMax.split(":"); }

   var bValidaDtAtual  = (!( (pbComDataAtual) && (pOperador != '') ) );
   var bValidaDtMinimo = (!(pDataMin.length > 0));
   var bValidaDtMaximo = (!(pDataMax.length > 0));
   var sOperador = '';

   if (!bValidaDtAtual)
   { // se for para validar com a data atual
      switch (pOperador)
      {
        case '==': sOperador = 'diferente';
                   bValidaDtAtual = (DtVerif.getDate() == dData.getDate()) &&
                                    (DtVerif.getMonth() == dData.getMonth()) &&
                                    (DtVerif.getFullYear() == dData.getFullYear());
          break;
        case '!=': sOperador = 'igual';
                   bValidaDtAtual = (DtVerif.getDate() != dData.getDate()) ||
                                    (DtVerif.getMonth() != dData.getMonth()) ||
                                    (DtVerif.getFullYear() != dData.getFullYear());

          break;
        case  '>': sOperador = 'menor ou igual';
                   bValidaDtAtual = (DtVerif > dData);
          break;
        case '>=': sOperador = 'menor';
                   bValidaDtAtual = (DtVerif >= dData);
          break;
        case  '<': sOperador = 'maior ou igual';
                   bValidaDtAtual = (DtVerif < dData);
          break;
        case '<=': sOperador = 'maior';
                   bValidaDtAtual = (DtVerif <= dData);
          break;
      }
   }// fim da validação se tiver q verificar com a data atual

   if (!bValidaDtMinimo)
   {// foi informado a data minima entao devo verificar
      bValidaDtMinimo = (DtVerif > DtMin);
      if (!bValidaDtMinimo)
      {// a data de verificação não é maior que a data mínima informada
         bValidaDtMinimo = ( ((DtVerif.getDate() == DtMin.getDate()) && (DtVerif.getMonth() == DtMin.getMonth()) && (DtVerif.getFullYear() == DtMin.getFullYear()))
                             && (pHoraVerif.length > 0) && (pHoraMin.length > 0) );
         if (bValidaDtMinimo)
         {// as datas são iguais e as horas foram informadas entao devo verificar a hora
            bValidaDtMinimo = ( eval(aHrVerif[0]+aHrVerif[1]) > eval(aHrMin[0]+aHrMin[1]) );
         }
      }
   } // fim da verificação se a data minima se foi informado.

   if (!bValidaDtMaximo)
   {// foi informado a data máxima entao devo verificar
      bValidaDtMaximo = (DtVerif < DtMax);
      if (!bValidaDtMaximo)
      {// a data de verificação não é menor que a data máxima
         bValidaDtMaximo = ( ((DtVerif.getDate() == DtMax.getDate())&&(DtVerif.getMonth() == DtMax.getMonth())&&(DtVerif.getFullYear() == DtMax.getFullYear()))
                             && (pHoraVerif.length > 0) && (pHoraMax.length > 0) );
         if (bValidaDtMaximo)
         { // as data são igauis e as horas foram informadas entao verifico a hora.
            bValidaDtMaximo = ( eval(aHrVerif[0]+aHrVerif[1]) < eval(aHrMax[0]+aHrMax[1]) );
         }
      }
   } // fim da verificação da data máxima se foi informado.

   var sMsgError = '';
   
   var sMsgHora = ((pHoraVerif.length > 0)?'/hora':'')
   
   if (!bValidaDtAtual)
   { sMsgError = 'A data '+pDataVerif+' é '+sOperador+' que a data atual.'; }
   if (!bValidaDtMinimo)
   { sMsgError = 'A data'+sMsgHora+' informada é menor ou igual que a data'+sMsgHora+' mínima.'; }
   if (!bValidaDtMaximo)
   { sMsgError = 'A data'+sMsgHora+' informada é maior ou igual que a data'+sMsgHora+' máximo.'; }

   var aRetorno = new Array(2);

   aRetorno[0] = (bValidaDtAtual && bValidaDtMinimo && bValidaDtMaximo);
   aRetorno[1] = sMsgError;

   return aRetorno;
}
//-------------------------------

// ************ ROTINAS PARA VALIDAR HORAS ************
// rotina para validar digito da hora.
// sintaxe: onKeyPress='return (validaDigHora(event));'
function validaDigHora(e)
{
   var keynum = '';
   if(window.event) // IE
   { keynum = e.keyCode; }
   else if(e.which) // Netscape/Firefox/Opera
   { keynum = e.which;}

   var s = String.fromCharCode(keynum);
   if ((s<"0" || s>"9") && s != ":" && keynum != 13 && keynum != 8)
   {
      alert("Digite somente numeros e : como separador ");
      return false;
   }
}

function formataHora(pHora)
{
   var sVar = new String(pHora);
   if (sVar.search(":") < 0)
   {
      sVar = sVar.substr(0,2)+':'+sVar.substr(2,2);
   }
   return sVar;
}
// rotina para validar hora informada
// sintaxe: onBlur = validaHora(this);
function validaHora(obj)
{
   var erro = "-1";
   var sVal = new String(obj.value);

   if  (sVal.length > 0)
   {
      sVal = formataHora(sVal);
      obj.value = sVal;
      var sSpl = sVal.split(":");
  
      var hora, minuto;

      hora   = sSpl[0];
      minuto = sSpl[1];

      if (  (sVal.length < 5) ||
            (hora.length < 1) ||   (hora.length > 2) ||
          (minuto.length < 1) || (minuto.length > 2)
         )
      {
         erro = "Horario invalida ";
      }
      else
      {
         if ( (hora < 0) || (hora > 23) )
         { erro = 'Hora invalida'; }
         if ( (minuto < 0) || (minuto > 59) )
         { erro = 'Minuto invalido'; }
      }
      if ((erro != "-1") && (obj.value != ""))
      {  obj.value = "";
         alert (erro);
        obj.focus();
      }
   }
}
//-------------------------------
// ************ ROTINAS PARA VALIDAR DIGITO NUMERICO ************
// valida digitos numericos
// sintaxe: onKeyPress='return (validaDigNumerico(event));'
function validaDigNumerico(e)
{
   var keynum = '';
   if(window.event) // IE
   { keynum = e.keyCode; }
   else if(e.which) // Netscape/Firefox/Opera
   { keynum = e.which;}
      
   var s = String.fromCharCode(keynum);
   if ( (s < "0" || s > "9") && (keynum!= 13) && (keynum != 8)   )
   {
      return false;
   }
}
//-------------------------------

// ************ ROTINAS PARA VALIDAR DIGITO NUMERICO ************
// valida digitos numericos
// sintaxe: onKeyPress='return (validaDigNumFloat(event));'
function validaDigNumFloat(e)
{
   var keynum = '';
   if(window.event) // IE
   { keynum = e.keyCode; }
   else if(e.which) // Netscape/Firefox/Opera
   { keynum = e.which;}

   var s = String.fromCharCode(keynum);
   if ( ((s < "0") || (s > "9")) && (s != ',') && (keynum!= 13) && (keynum != 8)   )
   {
      return false;
   }
}
//-------------------------------
// ************ ROTINAS PARA trocar Ponto por virgula ou vice e versa ************
// rotina para validar digitos de valores
// rotina que troca do parametro pValue
//    o caracter comparado no paramento pComp pelo paramentro pTroca
function trocaVirgulaPorPonto(pValue, pComp, pTroca, pTrunc)
{
   var sValue = new String(pValue);
   var iTrunc = (pTrunc == undefined?2:pTrunc);
   sValue = sValue.split("");
   sSaida = "";
   var i=0;
   var count = 0
   bAchou = false;
//   while ((i < sValue.length) && (count < 3))
   while ((i < sValue.length) && (count <= iTrunc))
   {
      if ( (sValue[i] == pComp) && (!bAchou) )
      {
         sSaida += pTroca;
         bAchou = true;
      }
      else
      {
// Alterado por Thiago 06/05/2009
// não vi a necessidade da comparação com o valor da troca.
//         if ( (sValue[i] != ' ') &&
//              (sValue[i] != pComp) &&
//              (sValue[i] != pTroca) )

         if ( (sValue[i] != ' ') &&
              (sValue[i] != pComp)  )
         {
            sSaida += sValue[i];
         }
      }
      if (bAchou)
      { count++; }
      i++;
   }

   return sSaida;
}
//-------------------------------

// ************ ROTINAS PARA formatar valores monetarios 2 digitos ************
// rotina para validar digitos de valores
// sintaxe: onBlur='formatarFloat(this);'
function formatarFloat(pObj, pTrunc)
{
   if (validaCampo(pObj.name))
   {
      pObj.value =  formatarValorFloat(pObj.value, pTrunc);
   }
}

function formatarValorFloat(pValue, pTrunc)
{
   sNum = pValue;
   sNum = trocaVirgulaPorPonto(sNum, ',', '.', pTrunc);
   if ( sNum.indexOf('.') >= 0 )
   {
      sVar = sNum.split('.');
      if (sVar[0].length <= 0)
      { sVar[0] = '0';  }
      switch (sVar[1].length)
      {
         case 0: sVar[1] = '00';
           break;
         case 1: sVar[1] += '0';
           break;
      }
      sNum = sVar.join('.');
   }
   else
   { sNum += '.00'; }

   return trocaVirgulaPorPonto(sNum, '.', ',', pTrunc);
}
//-------------------------------

// ************ ROTINAS PARA VALORES TEXTO ************
// rotina para validar digitos de valores
// sintaxe: onKeyPress='return (validaDigTexto(event));'
function validaDigTexto(e)
{
   var keynum = '';
   if(window.event) // IE
   { keynum = e.keyCode; }
   else if(e.which) // Netscape/Firefox/Opera
   { keynum = e.which;}

   var s = String.fromCharCode(keynum);
   if ( ( (s == "'") || (s == '"') )  && (keynum != 13) && (keynum != 8))
   {
//      alert("Não é permitido digitar (')apóstrofo.  ");
      return false;
   }
   else
   {
      return true;
   }
}
//-------------------------------

// ************ ROTINAS PARA VALIDAR TELEFONE ************
//rotina para validar digitos de telefone.
// sintaxe: onKeyPress='return (validaDigTel(event));'
function validaDigTel(e)
{
   var bRetorno = true;
   var keynum = '';
   if(window.event) // IE
   { keynum = e.keyCode; }
   else if(e.which) // Netscape/Firefox/Opera
   { keynum = e.which;}

   var s = String.fromCharCode(keynum);
   if ( ( (s < "0") || (s > "9")) && (keynum != 13) && (keynum != 8))
   {
      alert("Digite somente números para informar o telefone.");
      bRetorno = false;
   }

   return bRetorno;
}

function validaDigTelComRamal(e)
{
   var bRetorno = true;
   var keynum = '';
   if(window.event) // IE
   { keynum = e.keyCode; }
   else if(e.which) // Netscape/Firefox/Opera
   { keynum = e.which;}

   var s = String.fromCharCode(keynum).toUpperCase();
   if ( ( (s < "0") ||(s > "9") ) && (s != ' ') && (s != 'R') && (keynum != 13) && (keynum != 8))
   {
      alert("Digite somente números para informar o telefone.");
      bRetorno = false;
   }
   return bRetorno;
}
//-------------------------------

// ************ ROTINAS PARA VALIDAR E-MAIL ************
// rotina de validação de E-Mail
// sintaxe: onBlur(frm.obj);
function validaEmail(pObjEmail)
{
   var sVar = new String(pObjEmail.value);
   var bValido = false;
   if (sVar != '')
   {
      if (sVar.indexOf('@') > 0)
      {// tem @
         sVar = sVar.substr(sVar.indexOf('@')+1);
         if (sVar.indexOf('.') > 0 )
         {// tem '.' entao pode ter dominio
            sVar = sVar.substr(sVar.indexOf('.')+1);
            if (sVar.length > 0)
            { // email está correto.
               bValido = true;
            }
         }
      }
      else
      { bValido = false; }
      if (!bValido)
      {
         alert('E-Mail invalido.');
         pObjEmail.value = '';
         pObjEmail.focus();
      }
      else
      {
         sVar = pObjEmail.value;
         pObjEmail.value = sVar.toLowerCase();
      }
   }
}
//-------------------------------

// ************ ROTINAS PARA VALORES COM VIRGULA ************
// rotina para validar digitos de valores
// sintaxe: onKeyPress='return (validaDigValor(event));'
function validaDigValor(e)
{
   var keynum = '';
   if(window.event) // IE
   { keynum = e.keyCode; }
   else if(e.which) // Netscape/Firefox/Opera
   { keynum = e.which;}

   var s = String.fromCharCode(keynum);
   if ( (s < "0" || s > "9") && (s != ",") && (keynum != 13) && (keynum != 8))
   {
      alert("Digite somente números e/ou separadores \",\"");
      return false;
   }
}
//-------------------------------

// ************ ROTINAS PARA VALORES TEXTO Hexadecimal************
// rotina para validar digitos de valores
// sintaxe: onKeyPress='return (validaDigTextoHexa(event));'
function validaDigTextoHexa(e)
{
   var keynum = '';
   if(window.event) // IE
   { keynum = e.keyCode; }
   else if(e.which) // Netscape/Firefox/Opera
   { keynum = e.which;}

   var s = String.fromCharCode(keynum);
   s = s.toUpperCase();
   if ( !((s == "A") || (s == "B") ||
          (s == "C") || (s == "D") ||
          (s == "E") || (s == "F") ||
          (s == "-"))  &&
         (s < "0" || s > "9") &&
         (keynum != 13) && (keynum != 8))
   {
      return false;
   }
   else
   {
      return true;
   }
}
//-------------------------------

// ************ ROTINAS PARA AJUSTAR CAMPOS MEMO ************
// rotina para trocar caracter ENTER #13 por \n

function ajustaTextoMemo(pTexto)
{
  var sTexto = new String(pTexto);
  var sReturn = new String();
  
  for (var i=0; i < sTexto.length; i++)
   {
      if (sTexto.charCodeAt(i) == 13)
      {
         sReturn += '\\n';
      }
      else
      {
         sReturn += sTexto.charAt(i);
      }
   }
   sReturn = sReturn;
   return sReturn;
}

function ajustaTextoMemoParaEnter(pTexto)
{
  var sTexto = new String(pTexto);
  var sReturn = new String();

  for (var i=0; i < sTexto.length; i++)
   {
      if (sTexto.charCodeAt(i) == 92)
      {
         sReturn += String.charCodeAt(13);
      }
      else
      {
         sReturn += sTexto.charAt(i);
      }
   }
   sReturn = sReturn;
   return sReturn;
}
//-------------------------------

// ************ ROTINAS PARA EXIBIR UM HINT FIXO ************
// no formulario deve existir uma TAG DIV com o id = dHint
// que será o componente que exibira o hint.
//
// colocar o evento onMouseMove chamando exibeHint(<texto html>)
// dentro do objeto que deseja exibir o hint.
// exemplo: onMouseMove="exibeHint('LINHA 1');"
//
// colocar o evento onMouseOut chamando OcultaHint()
// pode ser no objeto que está exibindo o hint ou no grupo que esta
// o objeto que exibe o hint
//
// rotina que exibe o hint
function exibeHint(pHint)
{
/*
   function ietruebody()
   {
      return (document.compatMode && document.compatMode!="BackCompat")?document.documentElement : document.body
   }
*/
   
   var oHint = getCampo('dHint');
   oHint.innerHTML = pHint;
/*
   var offsetxpoint=-10 //Customize x offset of tooltip
   var offsetypoint=20 //Customize y offset of tooltip
   var ie=document.all
   var ns6=document.getElementById && !document.all


   var curX=(ns6)?e.pageX : event.clientX+ietruebody().scrollLeft;
   var curY=(ns6)?e.pageY : event.clientY+ietruebody().scrollTop;
//Find out how close the mouse is to the corner of the window
   var rightedge=ie&&!window.opera? ietruebody().clientWidth-event.clientX-offsetxpoint : window.innerWidth-e.clientX-offsetxpoint-20;
   var bottomedge=ie&&!window.opera? ietruebody().clientHeight-event.clientY-offsetypoint : window.innerHeight-e.clientY-offsetypoint-20;

   var leftedge=(offsetxpoint<0)? offsetxpoint*(-1) : -1000

//if the horizontal distance isn't enough to accomodate the width of the context menu
   if (rightedge<oHint.offsetWidth) {
//move the horizontal position of the menu to the left by it's width
      oHint.style.left=ie? ietruebody().scrollLeft+event.clientX-oHint.offsetWidth+"px" : window.pageXOffset+e.clientX-oHint.offsetWidth+"px";
   }
   else if (curX<leftedge)
   { oHint.style.left="5px"; }
   else //position the horizontal position of the menu where the mouse is positioned
   { oHint.style.left=curX+offsetxpoint+"px"; }

//same concept with the vertical position
   if (bottomedge<oHint.offsetHeight)
   { oHint.style.top=ie? ietruebody().scrollTop+event.clientY-oHint.offsetHeight-offsetypoint+"px" : window.pageYOffset+e.clientY-oHint.offsetHeight-offsetypoint+"px"; }
   else
   { oHint.style.top=curY+offsetypoint+"px"; }
*/
   oHint.style.display = '';
   oHint.style.zIndex = 1;
   oHint.style.visibility = 'visible';
   oHint.style.position = 'absolute';
   oHint.style.backgroundColor  = 'FFFFCE';

   oHint.style.top = 20 +window.event.clientY;
   oHint.style.left = 10 + window.event.clientX;
   oHint.style.maxWidth = '100px';
   oHint.style.overflow = 'auto';

//   window.status = 'X=' + window.event.x +' Y=' + window.event.y;
   
}
// rotina para ocultar o hint
function OcultaHint()
{
   var oHint = getCampo('dHint');
   oHint.innerHTML = '';
   oHint.style.zIndex = -1;
   oHint.style.visibility = 'hidden';
   oHint.style.position = 'static';
   oHint.style.backgroundColor  = 'FFF';
}

function ajustaTextoParaHint(pObjMemo)
{
   var sVar = encodeURI(pObjMemo.value);
   sVar = decodeURI(sVar.replace(/%0d%0A/gi, '<br>'));
   return sVar;
}
//-------------------------------
// ************ ROTINA PARA verificar campos nulos ************
function validaCampo(pObj)
{
   var vObj = getCampo(pObj);
   var bValido = (vObj != null);
   if (bValido)
   {
      var sVar = new String(vObj.value);
      sVar = sVar.replace(/ /gi, "");
      bValido = (sVar.length > 0);
   }
   return bValido;
}
//-------------------------------
// ************ ROTINA PARA pegar um campo do form ************

function getCampo(pNameORId)
{
   var vObj = document.getElementById(pNameORId);
   if (vObj == null)
   {
      vObj = document.getElementsByName(pNameORId);
      vObj = vObj[0];
   }
   return vObj;
}
//-------------------------------

// ************ ROTINA PARA carregar um COMBO (SELECT) atráves de uma vetor (array) ************
// Essa função faz a carga de um objeto SELECT com um vetor qualque.
// para utilizar é necessário ter um vetor de que tamanho quiser.
// Paramentros:
//    pNmCboOBJ = nome do objeto SELECT
//    aArray = vetor que tem os dados a serem carregados
//    indValue = informa o indice, dentro do vetor, que contém o valor
//               que será colocado na propriedade value de cada option
//    indTexto = informa o indice, dentro do vetor, que contém o valor que será exibido no SELECT
//    indTextoIgual = pode ser um vetor ou não indicando o indice do vetor que será utilizado para
//                    fazer comparação com o parametro pTextoIgual
//    pTextoIgual = pode ser um vetor ou não indicando com o texto que deseja comparar no vetor.
//    bTodos = informa se vai colcar o primeira opção do select TODOS com value ''
//
// Sintaxe:
//
//   // definindo o array
//   var aInfoEquip = new Array( new Array('BALUN 75/120 OHMS', 'FTD', 'BALUN'),
//                               new Array('DIALER', 'MITEL', 'A01-2P'),
//                               new Array('DIALER', 'MITEL', 'A01-4P'),
//                               new Array('DIALER', 'MITEL', 'D11-4P'),
//                               new Array('GATEWAY VOIP', 'QUINTUM', 'ASG400'),
//                               new Array('GATEWAY VOIP', 'QUINTUM', 'ASM400'),
//                               new Array('GATEWAY VOIP', 'QUINTUM', 'AXG1600'));
//   // chamando a funcao
//   carregaCombo('cboMarca', aInfoEquip, 1, 1, '', '');
//       ou
//   carregaCombo('cboMarca', aInfoEquip, 1, 1, new Array(0, 2), new Array('DIALER', 'A01-4P') );
//       ou
//   carregaCombo('cboMarca', aInfoEquip, 1, 1, 0, 'GATEWAY VOIP');
function carregaCombo(pNmCboOBJ, aArray, indValue, indTexto, indTextoIgual, pTextoIgual, bTodos)
{
   function verificaSeItemJaEstaIncluso(pNmCboOBJ, pTexto)
   {
      var aOptions = getCampo(pNmCboOBJ).options;
      var bTextoNaLista = false;
      var iIndice = 0;
      while ( (iIndice < aOptions.length ) && (!bTextoNaLista) )
      {
         bTextoNaLista = (aOptions[iIndice].text.toUpperCase() == pTexto.toUpperCase());
         iIndice++;
      }
      return bTextoNaLista;
   }

   function verificaTextoIgual(aArray, iIndice, indTextoIgual, pTextoIgual)
   {
      var bTextoIgual = true;
      if ( (indTextoIgual.length != undefined) &&
           (pTextoIgual.length != undefined)       )
      {
         var indCont = 0;
         while ( (indCont < indTextoIgual.length) && (bTextoIgual) )
         {
            bTextoIgual = (aArray[iIndice][indTextoIgual[indCont]] == pTextoIgual[indCont]);
            indCont++;
         }
      }
      else
      { bTextoIgual = ( aArray[iIndice][indTextoIgual] == pTextoIgual ); }
      return bTextoIgual;
   }

   var combo = getCampo(pNmCboOBJ);

   while (combo.options[0] != null)
   { combo.options[0] = null; }
   if (bTodos)
   {combo.options[0] = new Option('Todos', ''); }
   for (var iIndice =0; iIndice < aArray.length; iIndice++)
   {
      if ( !verificaSeItemJaEstaIncluso(pNmCboOBJ, aArray[iIndice][indTexto]) )
      {
         if (pTextoIgual != '')
         {
            if (verificaTextoIgual(aArray, iIndice, indTextoIgual, pTextoIgual))
            { combo.options[combo.options.length] = new Option(aArray[iIndice][indTexto], aArray[iIndice][indValue]); }
         }
         else
         { combo.options[combo.options.length] = new Option(aArray[iIndice][indTexto], aArray[iIndice][indValue]); }
      }
   }
}
//-------------------------------
// ************ ROTINA PARA pegar o valor de um objeto radio do form ************
function getRadioValue(pNameORId)
{
   var i = 0;
   var sValue = '';
   var rdb = document.getElementsByName(pNameORId);
   while ( (sValue == '') && (i <= (rdb.length -1)) )
   {
      if ( rdb[i].checked == true )
      { sValue = rdb[i].value;  }
      i++;
   }
   
   return sValue;
}
//-------------------------------

// ************ ROTINA PARA selecionar um radio com o valor informado ************
function selecionaRadio(pNameORId, pValue)
{
   var i = 0;
   var bSelecionou = false;
   var rdb = document.getElementsByName(pNameORId);
   while ( (!bSelecionou) && (i <= (rdb.length -1)) )
   {
      if ( rdb[i].value == pValue )
      { rdb[i].checked = true;  bSelecionou = true; }
      i++;
   }

   return bSelecionou;
}
//-------------------------------
// ************ ROTINA PARA controle de habilitado ou desabilitado os radio ************
function controleStatusRadio(pNameORId, pStatus)
{
   var i = 0;
   var rdb = document.getElementsByName(pNameORId);
   for (i=0; i < rdb.length; i++)
   {
      rdb[i].disabled = !pStatus;
   }
}
//-------------------------------

// ************ ROTINA PARA validar valor numerico entre um range de valor ************
function validaRange(pNmObj, pMinimo, pMaximo)
{
   var obj = getCampo(pNmObj);
   var iValue = obj.value;
   var bValMinimo = true;
   var bValMaximo = true;
   if (iValue != '')
   {
      if (pMinimo != '')
      { bValMinimo = (eval(iValue) >= eval(pMinimo)); }
      if (pMaximo != '')
      { bValMaximo = (eval(iValue) <= eval(pMaximo)); }
   }
   var sMsg = '';
   if (!bValMinimo)
   { sMsg += 'Valor informado é menor que '+pMinimo+', o valor minimo permitido.\n'; }
   if (!bValMaximo)
   { sMsg += 'Valor informa é maior que '+pMaximo+', o valor máximo permitido.\n'; }
   
   if (sMsg != '')
   {
      alert(sMsg+'Verifique.');
      obj.value='';
      obj.focus();
      
   }
   
   return (bValMinimo && bValMaximo);
}
//-------------------------------

/*
   Objeto para controle de Acesso do usuario
   
Deve ser passado o valor do acesso para o objeto na criação
Sintaxe:
   controle = new TControleAcesso();
   controle.setAcesso(24);
   
para saber se o o usuario tem permissão a alguma operação basta fazer a comparação.
Sintaxe:

   if (controle.status_INCLUIR)
   {
   ... liberado
   }
   else
   {
   ... bloqueado
   }

function TControleAcesso(pAcesso)
{
   acesso = pAcesso;
   this.status_INCLUIR = (acesso & 1);
   this.status_ALTERAR = (acesso & 2);
   this.status_EXCLUIR = (acesso & 4);
   this.status_IMPRDOC = (acesso & 8);
   this.status_IMPRESSAO = (acesso & 16);
   this.status_GERAR = (acesso & 32);
   this.status_CONSULTAR = (acesso & 64);
   this.status_CONFIDENCIAL = (acesso & 128);
}

*/

function TControleAcesso()
{
   this.acesso;
   this.status_INCLUIR;
   this.status_ALTERAR;
   this.status_EXCLUIR;
   this.status_IMPRDOC;
   this.status_IMPRESSAO;
   this.status_GERAR;
   this.status_CONSULTAR;
   this.status_CONFIDENCIAL;

   this.setAcesso = setAcesso;

   function setAcesso(pNum)
   {
      this.acesso = pNum;
      this.status_INCLUIR = (this.acesso & 1);
      this.status_ALTERAR = (this.acesso & 2);
      this.status_EXCLUIR = (this.acesso & 4);
      this.status_IMPRDOC = (this.acesso & 8);
      this.status_IMPRESSAO = (this.acesso & 16);
      this.status_GERAR = (this.acesso & 32);
      this.status_CONSULTAR = (this.acesso & 64);
      this.status_CONFIDENCIAL = (this.acesso & 128);
   }
}

function retiraMascara(cgc_cpf)
{
   var s = '';
   for (var i=0; i < cgc_cpf.length; i++)
   {
      if ( (cgc_cpf.charAt(i) != '/') &&
           (cgc_cpf.charAt(i) != '.') &&
           (cgc_cpf.charAt(i) != '-') &&
           (cgc_cpf.charAt(i) != ' ')    )
      {
         s = cgc_cpf.charAt(i) + s;
      }
   }
   return s;
}

function valida_CNPJ_CPF(pValue)
{
   var _dig1     = '';
   var _dig2     = '';
   var _digV1    = '';
   var _digV2    = '';
   var _doc      = '';
   var _multiAte = 0;

//   function retiraMascara(cgc_cpf)
//   {
//      var s = '';
//      for (var i=0; i < cgc_cpf.length; i++)
//      {
//         if ( (cgc_cpf.charAt(i) != '/') &&
//              (cgc_cpf.charAt(i) != '.') &&
//              (cgc_cpf.charAt(i) != '-') &&
//              (cgc_cpf.charAt(i) != ' ')    )
//         {
//            s = cgc_cpf.charAt(i) + s;
//         }
//      }
//      return s;
//   }

   function devolveDigito(pcgc_cpf)
   {
      var total = 0;
      var x     = 2;
      var y     = 0;
      for (var i = 0; i < pcgc_cpf.length; i++)
      {
         total = total + (parseInt(pcgc_cpf.charAt(i)) * x);
         x++;
         if (x == (_multiAte+1))
         { x = 2; }
      }
      y = 11 - (total % 11);
      if (y > 9)
      {  y = 0;}
      return y;
   }

   _doc = retiraMascara(pValue);

   _dig1 = _doc.substr(1,1);
   _dig2 = _doc.substr(0,1);

   if ( _doc.length > 11)
   { _multiAte = 9; }
   else { _multiAte = 11; }

   _digV1 = devolveDigito(_doc.substr(2));
   _digV2 = devolveDigito(_digV1 + _doc.substr(2));

   return ( (_dig1 == _digV1) && (_dig2 == _digV2) );
}

//formata de forma generica os campos
function formataCampo(campo, Mascara, evento)
{
    var boleanoMascara;

    var Digitato = evento.keyCode;
    exp = /\-|\.|\/|\(|\)| /g
    campoSoNumeros = campo.value.toString().replace( exp, "" );

    var posicaoCampo = 0;
    var NovoValorCampo="";
    var TamanhoMascara = campoSoNumeros.length;

    if (Digitato != 8) { // backspace
        for(i=0; i<= TamanhoMascara; i++) {
            boleanoMascara  = ((Mascara.charAt(i) == "-") || (Mascara.charAt(i) == ".")
                                || (Mascara.charAt(i) == "/"))
            boleanoMascara  = boleanoMascara || ((Mascara.charAt(i) == "(")
                                || (Mascara.charAt(i) == ")") || (Mascara.charAt(i) == " "))
            if (boleanoMascara) {
                NovoValorCampo += Mascara.charAt(i);
                  TamanhoMascara++;
            }else {
                NovoValorCampo += campoSoNumeros.charAt(posicaoCampo);
                posicaoCampo++;
              }
          }
        campo.value = NovoValorCampo;
          return true;
    }else {
        return true;
    }
}

//valida numero inteiro com mascara
function mascaraInteiro(){
    if (event.keyCode < 48 || event.keyCode > 57){
        event.returnValue = false;
        return false;
    }
    return true;
}

//adiciona mascara ao CPF
function MascaraCPF(txtCPF)
{
    if(mascaraInteiro(txtCPF)==false)
	{
        event.returnValue = false;
    }
    return formataCampo(txtCPF, '000.000.000-00', event);
}

//adiciona mascara ao CEP
function MascaraCep(txtCep)
{
    if(mascaraInteiro(txtCep)==false)
	{
        event.returnValue = false;
    }
    return formataCampo(txtCep, '00000-000', event);
}

// adiciona mascara aos telefones
function MascaraTel(txtTel)
{
    if(mascaraInteiro(txtTel)==false)
	{
        event.returnValue = false;
    }
    return formataCampo(txtTel, '(00)0000-0000', event);
}

//adiciona mascara de cnpj
function MascaraCNPJ(txtCNPJ){
    if(mascaraInteiro(txtCNPJ)==false){
        event.returnValue = false;
    }
    return formataCampo(txtCNPJ, '00.000.000/0000-00', event);
}

//Criptografia de string

function base64_encode( data )
{
    var b64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
    var o1, o2, o3, h1, h2, h3, h4, bits, i = ac = 0, enc="", tmp_arr = [];
    data = utf8_encode(data);

    do { // pack three octets into four hexets
        o1 = data.charCodeAt(i++);
        o2 = data.charCodeAt(i++);
        o3 = data.charCodeAt(i++);

        bits = o1<<16 | o2<<8 | o3;

        h1 = bits>>18 & 0x3f;
        h2 = bits>>12 & 0x3f;
        h3 = bits>>6 & 0x3f;
        h4 = bits & 0x3f;

        // use hexets to index into b64, and append result to encoded string
        tmp_arr[ac++] = b64.charAt(h1) + b64.charAt(h2) + b64.charAt(h3) + b64.charAt(h4);
    } while (i < data.length);

    enc = tmp_arr.join('');

    switch( data.length % 3 ){
        case 1:
            enc = enc.slice(0, -2) + '==';
        break;
        case 2:
            enc = enc.slice(0, -1) + '=';
        break;
    }

    return enc;
}

function base64_decode( data )
{
    var b64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
    var o1, o2, o3, h1, h2, h3, h4, bits, i = ac = 0, dec = "", tmp_arr = [];

    do {  // unpack four hexets into three octets using index points in b64
        h1 = b64.indexOf(data.charAt(i++));
        h2 = b64.indexOf(data.charAt(i++));
        h3 = b64.indexOf(data.charAt(i++));
        h4 = b64.indexOf(data.charAt(i++));

        bits = h1<<18 | h2<<12 | h3<<6 | h4;

        o1 = bits>>16 & 0xff;
        o2 = bits>>8 & 0xff;
        o3 = bits & 0xff;

        if (h3 == 64) {
            tmp_arr[ac++] = String.fromCharCode(o1);
        } else if (h4 == 64) {
            tmp_arr[ac++] = String.fromCharCode(o1, o2);
        } else {
            tmp_arr[ac++] = String.fromCharCode(o1, o2, o3);
        }
    } while (i < data.length);

    dec = tmp_arr.join('');
    dec = utf8_decode(dec);

    return dec;
}

function utf8_encode ( str_data )
{
    str_data = str_data.replace(/\r\n/g,"\n");
    var tmp_arr = [], ac = 0;

    for (var n = 0; n < str_data.length; n++) {
        var c = str_data.charCodeAt(n);
        if (c < 128) {
            tmp_arr[ac++] = String.fromCharCode(c);
        } else if((c > 127) && (c < 2048)) {
            tmp_arr[ac++] = String.fromCharCode((c >> 6) | 192);
            tmp_arr[ac++] = String.fromCharCode((c & 63) | 128);
        } else {
            tmp_arr[ac++] = String.fromCharCode((c >> 12) | 224);
            tmp_arr[ac++] = String.fromCharCode(((c >> 6) & 63) | 128);
            tmp_arr[ac++] = String.fromCharCode((c & 63) | 128);
        }
    }

    return tmp_arr.join('');
}

function utf8_decode ( str_data )
{
    var tmp_arr = [], i = ac = c = c1 = c2 = 0;

    while ( i < str_data.length ) {
        c = str_data.charCodeAt(i);
        if (c < 128) {
            tmp_arr[ac++] = String.fromCharCode(c);
            i++;
        } else if ((c > 191) && (c < 224)) {
            c2 = str_data.charCodeAt(i+1);
            tmp_arr[ac++] = String.fromCharCode(((c & 31) << 6) | (c2 & 63));
            i += 2;
        } else {
            c2 = str_data.charCodeAt(i+1);
            c3 = str_data.charCodeAt(i+2);
            tmp_arr[ac++] = String.fromCharCode(((c & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63));
            i += 3;
        }
    }

    return tmp_arr.join('');
}

//##################################################################################################

//Função para verificar Carecteres proibidos na paágina, retorna booleano

function verificaCarecteresProibidosNoForm(pForm,pACaracteres)
{
   var meuForm        = getCampo(pForm);
   var aNomesObj      = new Array();
   var aCaracteres    = new Array();
   var iCountObj      = 0;
   var i              = 0;

//Caracteres Proíbidos pré-definidos
   aCaracteres[0]     = "'";
//Fim dos caracteres proibidos

   if (pACaracteres != undefined)
   {
      aCaracteres = pACaracteres;
   }

   while (i < meuForm.length)
   {
      if( (meuForm.elements[i].type == 'text') || (meuForm.elements[i].type == 'textarea') )
      {
         aNomesObj[iCountObj] = meuForm.elements[i].name;
         iCountObj++;
      }
      i++;
   }

   for(j = 0; j < aCaracteres.length; j++)
   {
      for(k = 0; k < aNomesObj.length; k++ )
      {
         if(getCampo(aNomesObj[k]).value.indexOf(aCaracteres[j]) >= 0)
         {  return true;   }
      }
   }
   return false;
}

//##################################################################################################

//###############Rotina para Pegar a posicão TOP e LEFT de um elemento qualquer#####################
//Como usar :

//getPosicaoElemento('txtElemento').left   -- Retorna o left
//getPosicaoElemento('txtElemento').top    -- Retorna o top
//getPosicaoElemento('txtElemento').width  -- Retorna o width
//getPosicaoElemento('txtElemento').heigth -- Retorna o left

function getPosicaoElemento(elemID){
    var offsetTrail  = getCampo(elemID);
    var offsetLeft   = 0;
    var offsetTop    = 0;
    while (offsetTrail) {
        offsetLeft   += offsetTrail.offsetLeft;
        offsetTop    += offsetTrail.offsetTop;
        offsetTrail  = offsetTrail.offsetParent;
    }
    if (navigator.userAgent.indexOf("Mac") != -1 &&
        typeof document.body.leftMargin != "undefined") {
        offsetLeft   += document.body.leftMargin;
        offsetTop    += document.body.topMargin;
    }
    return {left:offsetLeft, top:offsetTop};
}


// Rotina para temporizar uma tela
// Para utilizar a rotina incluia o seguinte o código na tag BODY
// onLoad = "inicializaTemporizador('valida.php',600000);"
// Onde o primeiro paremetro é o local onde será redirecionado.
// Segundo parametro é o tempo que a tela deve ficar disponível.

var idTmp;
var tmpLocal;
var tmpTempo;

function inicializaTemporizador(pLocal, pTempo)
{
   tmpLocal = pLocal;
   tmpTempo = pTempo;
   resetTemporizador();
   setFuncTexto();
}

function direciona()
{
   alert('O tempo se esgotou.');
   window.location = tmpLocal;
}

function resetTemporizador()
{
   clearTimeout(idTmp);
   idTmp = setTimeout(" direciona(); ", tmpTempo);
}

function setFuncTexto(pLocal, pTempo)
{
   var textos  = document.getElementsByTagName('input');
   var nCampos = textos.length;
   var i;

   for(i = 0; i < nCampos; i++)
   {  textos[i].onfocus = new Function(" resetTemporizador(); ");   }

}

function incluirArquivoJs(pArquivoJS)
{
   var novo = document.createElement('script');
   novo.setAttribute('type', 'text/javascript');
   novo.setAttribute('src', pArquivoJS);
   document.getElementsByTagName('head')[0].appendChild(novo);
}

function trataRetAjaxPortal(pValueRetorno, pObjeto)
{
   var texto = pValueRetorno
   var aRetorno = texto.split('#!@');
   var aArqJS = new String(aRetorno[0])
   aArqJS = aArqJS.split('#@');
   iTotArqs = aArqJS.length;
   for (var i=0; i < iTotArqs; i++)
   {
      if (aArqJS[i] != '')
      { incluirArquivoJs(aArqJS[i]); }
   }

   getCampo(pObjeto).innerHTML = aRetorno[2];

   if(aRetorno[1] != '')
   {
      window.setTimeout(" "+aRetorno[1]+" ", 500);
   }
}