/*******************************************************************
 *                                                                 *
 *    Funções Básicas em JavaScript para manipulação de strings    *
 *                                                                 *
 *******************************************************************/
// Limpa o conteúdo de um campo
function LimpaCampo( ind )
{
	document.forms[0].elements[ind].value="";
}

// Coloca todas as letras de um campo em maiúsculo
function Maiusculo( ind )
{
  document.forms[0].elements[ind].value.toUpperCase();
}

function MostraMensagem(pNumber,pField)
{
    var sMsg='';	
    if (pNumber=='P001') {
      	sMsg='Por favor, informe um valor para o campo ' + pField;	
	alert(sMsg);
	return false;
    }
}


// Coloca todas as letras em minúsculo
function Minusculo( ind )
{
  document.forms[0].elements[ind].value.toLowerCase();
}

// Retorna todos os caracteres especiais
function RetCaracEspeciais(sParam)
{
  var sCaracEspeciais = '<>,;:?/}]^~[{`´!@#$%¨&*"_+=çÇ\|';
  var sCaracEspeciais = sCaracEspeciais + "'";
  
  var sCaracEspeciais2 = '<>,;:?/}]^~[{`´!@#$%¨&*"_+=\|';
  var sCaracEspeciais2 = sCaracEspeciais2 + "'";
  
  if( sParam == '2' )
  {
    sCaracEspeciais = sCaracEspeciais2;
  }
  
  return sCaracEspeciais;
  
}

function TiraPontos( ind )
{
  var sNumero;  
  var sAux = document.forms[0].elements[ind].value;  
  
  sNumero = sAux.split (".");
  return sNumero.join("");
}

function TiraVirgula( sAux )
{
  var sNumero;
  
  sNumero = sAux.split (",");
  return sNumero.join("");
}

function TiraBarraData( sAux )
{
  var sData;
  
  sData = sAux.split ("/");
  return sData.join("");
}

/*-----------------------------------------------------------------*
 | ContidoNoDominio    Retorna True se a String dada só contiver   |
 |                     caracteres do domínio dado                  |
 *-----------------------------------------------------------------*/
function ContidoNoDominio( sCaracteres, Dominio )
{
  var iCount, iCountAux;

  if( sCaracteres == "" )
    return false;

  for( iCount=0; iCount<sCaracteres.length; iCount++ )
	{
	  for( iCountAux=0; iCountAux<Dominio.length; iCountAux++ )
		{
		  if( sCaracteres.substr(iCount,1) == Dominio.substr(iCountAux,1) )
		    break;
		}
		
	  if( iCountAux >= Dominio.length )
	    return false;
	}
	
  return true;
  
}

/*-----------------------------------------------------------------*
 | ContemDominio    Retorna True se a String dada contiver algum   |
 |                  caractere do domínio dado                      |
 *-----------------------------------------------------------------*/
function ContemDominio( sCaracteres, Dominio )
{
  var iCount, iCountAux;

  if( sCaracteres != "")
	{
	  for( iCount=0; iCount<sCaracteres.length; iCount++ )
		{
		  for( iCountAux=0; iCountAux<Dominio.length; iCountAux++ )
			{
			  if( sCaracteres.substr(iCount,1) == Dominio.substr(iCountAux,1) )
			    return true;
			}
		}
	}
	
  return false;
  
}

/*
 Nome: fSoCaracter
 Descricao: Verifica na string passada, se existe somente o caracter informado
*/
function fSoCaracter(_string,carac)
{
for(i=0;i<_string.length;i++)
{
	if(_string.charAt(i)!=carac)
		return false;	
}

	if ( _string.length )
	  return true;
	else
	  return false;

}


/*-----------------------------------------------------------------*
 | IsNumber        Retorna True se a String dada contiver          |
 |                 somente números                                 |
 *-----------------------------------------------------------------*/
function IsNumber( sValor )
{
  
  return ContidoNoDominio( sValor, "0123456789" );
}

/*-----------------------------------------------------------------*
 | IsInt	         Retorna True se a String dada só contiver       |
 |                 caracteres para Número inteiro                  |
 *-----------------------------------------------------------------*/
function IsInt( sValor )
{
	
  return ContidoNoDominio( sValor, " +-0123456789" );
}


/*-----------------------------------------------------------------*
 | IsChar          Retorna True se a String dada contiver          |
 |                 somente caracteres válidos (letras e números)   |
 *-----------------------------------------------------------------*/
function isValidChar(valor)
{
  var aCode = new Array();
  var iCt=0;
  aCode[0]=48;
  aCode[1]=49;
  aCode[2]=50;
  aCode[3]=51;
  aCode[4]=52;
  aCode[5]=53;
  aCode[6]=54;
  aCode[7]=55;
  aCode[8]=56;
  aCode[9]=57;
  aCode[10]=113;
  aCode[11]=119;
  aCode[12]=101;
  aCode[13]=114;
  aCode[14]=116;
  aCode[15]=121;
  aCode[16]=117;
  aCode[17]=105;
  aCode[18]=111;
  aCode[19]=112;
  aCode[20]=97;
  aCode[21]=115;
  aCode[22]=100;
  aCode[23]=102;
  aCode[24]=103;
  aCode[25]=104;
  aCode[26]=106;
  aCode[27]=107;
  aCode[28]=108;
  aCode[29]=231;
  aCode[30]=122;
  aCode[31]=120;
  aCode[32]=99;
  aCode[33]=118;
  aCode[34]=110;
  aCode[35]=109;
  aCode[36]=81;
  aCode[37]=87;
  aCode[38]=69;
  aCode[39]=82;
  aCode[40]=84;
  aCode[41]=89;
  aCode[42]=85;
  aCode[43]=73;
  aCode[44]=79;
  aCode[45]=80;
  aCode[46]=65;
  aCode[47]=83;
  aCode[48]=68;
  aCode[49]=70;
  aCode[50]=71;
  aCode[51]=72;
  aCode[52]=74;
  aCode[53]=75;
  aCode[54]=76;
  aCode[55]=199;
  aCode[56]=90;
  aCode[57]=88;
  aCode[58]=67;
  aCode[59]=86;
  aCode[60]=66;
  aCode[61]=78;
  aCode[62]=77;
  aCode[63]=98;
//
  if(document.all)
  var Tecla = event.keyCode;    
  for (iCt=0; iCt<aCode.length; iCt++) {
     if (Tecla==aCode[iCt]) {
         return true;
         break;
     }
  }	
 return false;  
}

			
/*-----------------------------------------------------------------*
 | IsFloat         Retorna True se a String dada só contiver       |
 |                 caracteres para Número em Ponto-Flutuante       |
 *-----------------------------------------------------------------*/
function IsFloat( ind )
{
  var sCampo = document.forms[0].elements[ind].value;
  
  return ContidoNoDominio( sCampo, " +-0123456789Ee,." );
}

/*-----------------------------------------------------------------*
 | IsCurr       Retorna True se a String dada só contiver          |
 |              Caracteres para Número Currency                    |
 *-----------------------------------------------------------------*/
function IsCurr( ind )
{
  var sCampo = document.forms[0].elements[ind].value;
  
  return ContidoNoDominio( sCampo, " +-0123456789,." );
}

/*-----------------------------------------------------------------*
 | AlignLeft     Acerta a string no tamanho correto com            |
 |               alinhamento à esquerda                            |
 *-----------------------------------------------------------------*/
function AlignLeft( ind, Tamanho )
{    
  var sRet, iCount;
  var sCaracteres = document.forms[0].elements[ind].value;

  if( sCaracteres.length >= Tamanho )
    sRet = sCaracteres.substr(0,Tamanho);             
  else
	{
	  sRet = sCaracteres;
	  
	  for( iCount=Tamanho-sCaracteres.length; iCount>0; iCount-- )
		  sRet = sRet + " ";
	}
	
  return sRet;
  
}

/*-----------------------------------------------------------------*
 | ComplZeros    Retorna o valor Numérico completada com zeros     |
 |               até o tamanho especificado.                       |
 |  strDirEsq se for  ´d´ => Direita ´e´ => Esquerda               |
 *-----------------------------------------------------------------*/
function ComplZeros( sCaracteres , Tamanho , strDirEsq ) 
{
  var iCount;
  var sRet = "";
  //var sCaracteres = document.forms[0].elements[ind].value;

  strDirEsq = strDirEsq.toUpperCase();
  
  if( sCaracteres.length >= Tamanho )
      sRet = sCaracteres.substr(sCaracteres.length - Tamanho,Tamanho);             
  else
	{	
	  for( iCount=Tamanho-sCaracteres.length; iCount>0; iCount-- )
	  { 
		  sRet = sRet + "0" ;	  
    }
    
	    if ( strDirEsq == 'D' )
	    {
        sRet = sCaracteres + sRet;
		  }
		  else
		  {
        sRet = sRet + sCaracteres;
		  }

	}
	
  return sRet;
  
}

/*-----------------------------------------------------------------*
 | ComplSpaces    Retorna o valor Numérico completada com zeros    |
 |               até o tamanho especificado.                       |
 *-----------------------------------------------------------------*/
function ComplSpaces( ind, Tamanho )
{
  var iCount;
  var sRet = "";
  var sCaracteres = document.forms[0].elements[ind].value;

  if( sCaracteres.length >= Tamanho )
      sRet = sCaracteres.substr(sCaracteres.length - Tamanho,Tamanho);             
  else
	{	
	  for( iCount=Tamanho-sCaracteres.length; iCount>0; iCount-- )
		  sRet = sRet + " ";

    sRet = sRet + sCaracteres;
	}
	
  return sRet;
  
}

/*-----------------------------------------------------------------*
 | RetornaDominio      Retorna a String dada, somente com os       |
 |                     caracteres do domínio dado                  |
 *-----------------------------------------------------------------*/
function RetornaDominio( ind, Dominio )
{  
  var sRet = "";
  var iCount, iCountAux, sCarac;
  var sCaracteres = document.forms[0].elements[ind].value;
  
  for( iCount=0; iCount<sCaracteres.length; iCount++ )
	{
	  sCarac = sCaracteres.substr(iCount,1);
	
	  for( iCountAux=0; iCountAux<Dominio.length; iCountAux++ )
		{
		  if( sCarac == Dominio.substr(iCountAux,1) )
		    break;
		}
	
	  if( iCountAux < Dominio.length )
		  sRet = sRet + sCarac;
	}
	
  return sRet;
  
}
			
/*-----------------------------------------------------------------*
 | RetiraDominio       Retorna a String dada retirando os          |
 |                     caracteres do domínio dado                  |
 *-----------------------------------------------------------------*/
function RetiraDominio( valor, Dominio )
{
  var sRet = "";
  var iCount, iCountAux, sCarac;
  var sCaracteres = valor;

  for( iCount=0; iCount<sCaracteres.length; iCount++ )
	{
	  sCarac = sCaracteres.substr(iCount,1);
	
	  for( iCountAux=0; iCountAux<Dominio.length; iCountAux++ )
		{
		  if( sCarac == Dominio.substr(iCountAux,1) )
		    break;
		}
	
	  if( iCountAux >= Dominio.length )
		  sRet = sRet + sCarac;
	}
	
  return sRet;
  
}

/*-----------------------------------------------------------------*
 | IsValue		  Retorna True se o String dada for um número      |
 |              com casas decimais dadas.                        |
 *-----------------------------------------------------------------*/
function IsValue( ind, iDecimais )
{
  var iCount = 0;
  var sNumero = document.forms[0].elements[ind].value;

  if( iDecimais > 0 )
  {
    if( sNumero.length < iDecimais + 2 || (sNumero.indexOf(".", 0) == -1 && sNumero.indexOf(",", 0) == -1) )
      return false;
  }
  else
    return false;
 
  while( iCount < sNumero.length )
  {
    if( iCount == sNumero.length - (iDecimais + 1) )
    {
      if( sNumero.charAt(iCount) != "." && sNumero.charAt(iCount) != "," )
        return false;
    }
    else
    {
      if( sNumero.charAt(iCount) < "0" || sNumero.charAt(iCount) > "9" )
        return false;
    }
    
  iCount++
    
  }

  return true;
  
}


/* Retira os espaços à esquerda e à direita da string */
function Trim( sString )
{
  if( sString != '' )
  {
    //  Retira espaços à direita da string
    while(sString.charAt(sString.length-1)== ' ')
      sString = sString.substring(0,sString.length-1);
    
    //  Retira espaços à esquerda da string
    while(sString.charAt(0)== ' ')
      sString = sString.substring(1,sString.length);
   }
   
   return sString;
}


/* Retira os espaços à direita da string */
function RTrim( sString )
{
  if( sString != '' )
  {
    //  Retira espaços à direita da string
    while(sString.charAt(sString.length-1)== ' ')
      sString = sString.substring(0, sString.length-1);
  }
   
  return sString;
}

/* Retira os espaços à esquerda da string */
function LTrim( sString )
{
  if( sString != '' )
  {    
    //  Retira espaços à esquerda da string
    while(sString.charAt(0)== ' ')
      sString = sString.substring(1, sString.length);
   }
   
   return sString;
}

/* Consistência que não permite ao usuário selecionar o combo de Posição.
   Esta função é utilizada somente nas páginas de filtro que possuam os campos
   de Posição, Data de Referência e Situação  */
function Consiste_Posicao__Situacao_Data( strFormulario, strCampoText, strCampoSltSituacao, strCampoSltPosicao, strConsistencia, bLoadPage )
{
  var strDataReferencia = eval('document.' + strFormulario + '.' + strCampoText + '.value');
  var strSltSituacao    = eval('document.' + strFormulario + '.' + strCampoSltSituacao + '.options[document.' + strFormulario + '.' + strCampoSltSituacao + '.selectedIndex].value;');
  var strSltPosicao     = eval('document.' + strFormulario + '.' + strCampoSltPosicao + '.options[document.' + strFormulario + '.' + strCampoSltPosicao + '.selectedIndex].value;');
      
  strSltSituacao = strSltSituacao.toUpperCase();
  strSltPosicao  = strSltPosicao.toUpperCase();
  
  //  Verifica qual o tipo de consistência a ser realizada
  if( strConsistencia == 'P' )
  {
    //  Consistência baseada no campo Posição
    if( strSltPosicao != 'NENHUM' )
    {
      if( !bLoadPage ) //Leo
        alert('A pesquisa por Posição só é permitida a partir da data atual e considerando todas as situações. Pressione Consultar para continuar o processo de consulta, ou defina novo filtro, retirando seleção do campo Posição.');
      
      eval('document.' + strFormulario + '.' + strCampoText + '.disabled = true');
      eval('document.' + strFormulario + '.' + strCampoSltSituacao + '.options[0].selected = true'); //Leo
      eval('document.' + strFormulario + '.' + strCampoSltSituacao + '.disabled = true');
    }
    else
    {
      if( !bLoadPage ) //Leo
      {
        eval('document.' + strFormulario + '.' + strCampoText + '.disabled = false');
        eval('document.' + strFormulario + '.' + strCampoSltSituacao + '.disabled = false');
      }
    }
  }
  else
  {
    //  Consistência baseada no campo Data de Referência ou Situação
    
    //  Recupera a data atual
    var strDataAtual    = RetornaDataAtual();    
    var strTempSituacao = strSltSituacao.charAt(0);
  
    if( ( strDataReferencia != strDataAtual ) || ( strTempSituacao != 'T' ) )
    {
      if( !bLoadPage ) //Leo
        alert('A pesquisa por Data Referência e/ou Situação não permite a definição da Posição. Pressione Consultar para continuar o processo de consulta, ou defina novo filtro por Posição, informando na Data de Referência a data atual, e na Situação a opção Todos.');
        
      eval('document.' + strFormulario + '.' + strCampoSltPosicao + '.disabled = true');
      eval('document.' + strFormulario + '.' + strCampoSltPosicao + '.options[0].selected = true'); //Leo
    }
    else
      eval('document.' + strFormulario + '.' + strCampoSltPosicao + '.disabled = false');
  }
}

/*  Consiste o valor passado de acordo com as casas decimais e o tamanho 
da string do valor , e preenche o valor completado com zeros a esquerda da virgula
*/
function Consiste_Porcentagem ( strNomeControle , strMensagemErro , strMensagemAlerta , iTamInteiros , iTamDecimais ) 
{

 var strMatrixConfere;
 var strDecimais;
 var strInteiros;
 var strTempDecimais;
 var strTempInteiros;
 
 var strValor = eval ( strNomeControle +  '.value' ) ; // Guarda em Temp para não bagunçar a variável
 var strTempValor = strValor ;
 
   
 // Verifica se está no formato de um número não inteiro que indica a porcentagem ... 
 if ( ! ContidoNoDominio( strValor, ',0123456789' ) )
 {
    if ( strMensagemErro != '' ) 
    {
      alert ( strMensagemErro ) ;
      eval ( strNomeControle + '.focus()' );
      return false ;
    }
 }

 // Separa os inteiros das decimais para uma validação e formatação...
 if ( ContemDominio( strTempValor , "," ) )
 {
 
    strMatrixConfere = strTempValor.split(",");

    strInteiros = strMatrixConfere[0] ;
    strDecimais = strMatrixConfere[1] ; 
    
 }
 else // o split se não tiver "," dá erro então...
 {
 
    strInteiros = strTempValor;
    strDecimais = '0' ; 
 }
 
 
 // Verifica o tamanho dos inteiros...
 if ( (parseFloat(strInteiros.length) > parseFloat(iTamInteiros)) || (parseFloat(strInteiros.length) < 1) || (parseFloat(strInteiros) > 100) )
 {

   if ( strMensagemAlerta != '' )
   {
    alert ( strMensagemAlerta );
    eval ( strNomeControle + '.focus()' );
    return false ;    
   }    
 }
 
 // se o valor informado for == a 100% então não deveremos processar casas decimais...
 if ( parseFloat(strInteiros) == 100 )
 {
    strDecimais = ComplZeros ( "" , 8 , 'd' ) ;
 }
 else if( parseFloat(strInteiros) < 100 )
 {

    // Formata o tamanho das decimais...
     if ( strDecimais.length > iTamDecimais ) 
     {
       strDecimais = strDecimais.substr(0,8) ;
     }
     else
     {
       strDecimais = ComplZeros( strDecimais , 8 , 'd' ) ;
     }
 }
 else
 {
     strTempInteiros = strInteiros.substr(0,3);

     if( strDecimais != '' )
     	  strDecimais = strInteiros.substr(3,strInteiros.length);
     	  
     if( strDecimais.length > 8 )
        strDecimais = strDecimais.substr(0,8);
     else if( strDecimais.length < 8 )
        strDecimais = ComplZeros( strDecimais , 8 , 'd' );

     strInteiros = strTempInteiros;
     
 }

  
  // Atribuiu o valor ao controle html.
  eval ( strNomeControle + '.value = ' + '"' + strInteiros + ',' + strDecimais + '"');
  
  //Retornou sucesso.
  return true ;
}

function CheckKey(d)
{
	if(document.all)
	var Tecla = event.keyCode;

	if(Tecla > 47 && Tecla <58)
		return true;
	if(Tecla == 44||Tecla == 8)
		return true;
	return false;

}

function FormataHora(stxt) 
{  
    var sAux  = stxt.value;
    if (Trim(sAux)=="")
      return true;
      
    var sAux = RetiraDominio(sAux,":");  
    if (!IsInt(sAux)) {
        alert ('Hora inválida. Por favor, informe a hora no formato HHMM.');
       stxt.focus();
       return false;  
    }       
    var sHora ='';
    var sMinuto='';
    var sSegundo='';
    var sTime = sAux
    sTime = RetiraDominio(sTime,"-");
    sTime = RetiraDominio(sTime,"/");
    sTime = RetiraDominio(sTime," ");
    sTime = RetiraDominio(sTime,".");
    sTime = RetiraDominio(sTime,",");
    sTime = RetiraDominio(sTime,";");
    sTime = RetiraDominio(sTime,"|");
    
    if (sTime.length < 4){
       alert ('Hora com dígitos insuficientes.');
       stxt.focus();
       return false;
    }       
    if (sTime.length == 5){
       alert ('Hora inválida. Por favor, informe a hora no formato HHMM.');
       stxt.focus();
       return false;
    }       
    sHora=sTime.substr(0,2);
    sMinuto = sTime.substr(2,2);
    if (sTime.length = 6)
        sSegundo = sTime.substr(4,2);
                
    if (sHora > 23) {   
       alert ('Hora inválida. Por favor, informe valores entre 00 e 23');
       stxt.focus();
       return false;
    }
    if (sMinuto > 59) {   
       alert ('Minutos inválidos. Por favor, informe valores entre 00 e 59');
       stxt.focus();
       return false;
    }   
    if (sSegundo != "" && sSegundo > 59) {   
       alert ('Segundos inválidos. Por favor, informe valores entre 00 e 59');
       stxt.focus();
       return false;
    }   
    if (sSegundo != "")
       stxt.value=sHora + ":" + sMinuto + ":" + sSegundo
    else
       stxt.value=sHora + ":" + sMinuto 
      
    
    
    return true;   
    
}    
 
function formatavalor(valor) {
    
    var sInt     = '';
    var sDec     = '';
    var sNumero  = '';
    var sValor   = valor.value;
    sValor  = Trim(sValor);   
    if (sValor=='')
      return true;    
      
    sValor = RetiraDominio(sValor, ".");  
    if (sValor.indexOf(",") > 0)   
    { 
        if(!hasVirgula(sValor)) 
        {    
            alert ('Valor inválido. Por favor, informe um valor válido para a proposta.');
            valor.focus();
            return false;
        }
        else 
        {
            sDec   = sValor.substr(sValor.indexOf(",") + 1,2);
            sInt   = sValor.substr(0,sValor.indexOf(","));                        
            if (sInt.length <= 3)
            {
                sNumero = sInt + ',' + sDec;
                valor.value=sNumero;
                return true;
            }
            else
            {
                switch(sInt.length) 
                {
                  case 4:
                    sNumero = sInt.substr(0,1) + "." + sInt.substr(1,4) + "," + sDec;
                    break;
                  case 5:
                    sNumero = sInt.substr(0,2) + "." + sInt.substr(2,5) + "," + sDec;
                    break;
                  case 6:
                    sNumero = sInt.substr(0,3) + "." + sInt.substr(3,6) + "," + sDec;
                    break;  
                  case 7:
                    sNumero = sInt.substr(0,1) + "." + sInt.substr(1,3) +  "." + sInt.substr(4,3) + "," + sDec;
                    break;    
                  case 8:
                    sNumero = sInt.substr(0,2) + "." + sInt.substr(2,3) +  "." + sInt.substr(5,3) + "," + sDec;
                    break;      
                }   
                valor.value=sNumero;
            }              
        }   
    }
    else
    {
      switch(sValor.length) 
      {
          case 1:
            sNumero = sValor + ",00";
            break;
          case 2:
            sNumero = sValor + ",00";
            break;  
          case 3:
            sNumero = sValor + ",00";
            break;  
          case 4:
            sNumero = sValor.substr(0,1) + "." + sValor.substr(1,4) + ",00";
            break;
          case 5:
            sNumero = sValor.substr(0,2) + "." + sValor.substr(2,5) + ",00";
            break;
          case 6:
            sNumero = sValor.substr(0,3) + "." + sValor.substr(3,6) + ",00";
            break;  
          case 7:
            sNumero = sValor.substr(0,1) + "." + sValor.substr(1,3) +  "." + sValor.substr(4,3) + ",00";
            break;    
          case 8:
            sNumero = sValor.substr(0,2) + "." + sValor.substr(2,3) +  "." + sValor.substr(5,3) + ",00";
            break;      
      } 
      if (sNumero.substr(0,1)==","){
          alert ('Valor inválido. Por favor, informe um valor válido para a proposta.');
          valor.focus();
          return false;
      } 
      valor.value=sNumero;
    }
}  
function hasVirgula(sVirg) {    

    var iPos = sVirg.indexOf(",");
    var sPos = sVirg.substr(iPos+1,20);
    sPos=Trim(sPos);
    if (sPos.length == 2)
      return true;
    else
      return false;      
}   

function validasite(site) {
 
	var sSite  = Trim(site.value);
	var sPonto ='';
	if (sSite=='')
	   return true;
		
	sSite = sSite.toUpperCase();
	if (sSite.substr(0,4)!="WWW.") {
		alert ('Endereço eletrônico inválido.');
		site.focus();
		return false;
	}
	sPonto=sSite.substr(4,40);
	if (sPonto.indexOf(".") < 0 ) {
		alert ('Endereço eletrônico inválido.');
		site.focus();
		return false;
	}	
	return true; 
}      

function validaeMail(email)
{
  var sEmail = email.value;
  sEmail  = Trim(sEmail);
  if (sEmail=='')
     return true;
  
  if( sEmail.indexOf("@") < 0 ){
     alert ('E-mail inválido.');
     email.focus();
     return false;
  }
  if( sEmail.indexOf(".") < 0 ) {
      alert ('E-mail inválido.');
      email.focus();
      return false;
  }   
  if( ContemDominio( sEmail, " ;,:/$!#%^&*()+[]{}|\\~`'\"" ) ) {
      alert ('E-mail inválido.');
      email.focus();
      return false;
  }       
  return true;
}

function formataFone(fone) { 
  
      var sFone   = fone.value;
      var sFormat = '';
      
      if (Trim(sFone)=='')
          return true;
      
      sFone = RetiraDominio(sFone,"-");
      
      if (sFone.length < 7) {
          alert ('Número do telefone com dígitos insuficientes.');
          fone.focus();
          return false;
      }
      if (sFone.length == 7) {
          sFormat = sFone.substr(0,3) + '-' + sFone.substr(3,4);
          fone.value = sFormat;          
      }
      if (sFone.length == 8) {
          sFormat = sFone.substr(0,4) + '-' + sFone.substr(4,4);
          fone.value = sFormat;
      }
      return true;     
}
/*-----------------------------------------------------------------*
 | makeUpper:    Coloca o texto recebido em caixa alta
 | 
 *-----------------------------------------------------------------*/
function makeUpper(valor) {
    
    var valorRecebido	= valor.value;    
    var caixaAlta	= '';
    //
    valorRecebido=Trim(valorRecebido);
    if (valorRecebido!= '') {    
    	caixaAlta = valorRecebido.toUpperCase();    	    	
    	valor.value = caixaAlta;
    }   
}
/*-----------------------------------------------------------------*
 | makeLower:    Coloca o texto recebido em caixa baixa
 | 
 *-----------------------------------------------------------------*/
function makeLower(valor) {
    
    var valorRecebido	= valor.value;    
    var caixaBaixa	= '';
    //
    valorRecebido=Trim(valorRecebido);
    if (valorRecebido!= '') {    
    	caixaBaixa = valorRecebido.toLowerCase();    	    	
    	valor.value = caixaBaixa;
    }   
}
/*-----------------------------------------------------------------*
 | intNumber:    Permite apenas entrada de números inteiros
 *-----------------------------------------------------------------*/
function intNumber(d)
{
	if(document.all)
	var Tecla = event.keyCode;
	if(Tecla > 47 && Tecla <58)
		return true;
	if(Tecla == 8)
		return true;
	return false;
}

function redirSite(sLink) {	
	var site=sLink.value;
	site=Trim(site);	
	if (site=='') 	
		return;
	site = "window.open('http://" + site + "','Cliente','menubar=yes,resizable=yes,addressbar=yes,scrollbars=yes,status=yes,toolbar=yes,width=800,height=500,top= 50,left=50')";	
	eval(site);	
}

// INICIO parseNum
function parseNum(x) {
   var n = x;
   if(n.length == 0) n = '0';
   for(var i=0;i<n.length;i++) {
	  if(n.charAt(i)==",") {
	 	 n = n.substr(0,i) + "." + n.substr(i+1);
	  }
   }	
   return(parseFloat(n));
}

/*-----------------------------------------------------------------*
 | fEncode2:    função para pré-criptografar o valor recebido
 *-----------------------------------------------------------------*/

function fEncode2(sPwd) {
	var sTmp = ""; 
	for(var i = 0; i < sPwd.length; i++) {
		sTmp = sTmp + String.fromCharCode(sPwd.charCodeAt(i) + 9);
	}
	return sTmp;
}

/*-----------------------------------------------------------------*
 | fDecode2:    função para pré-descriptografar o valor recebido
 *-----------------------------------------------------------------*/

function fDecode2(sSenha) {
	var sTmp = ""; 
	for(var i = 0; i < sSenha.length; i++) {
		sTmp = sTmp + String.fromCharCode(sSenha.charCodeAt(i) - 9);
	}
	return sTmp;
}

/*-----------------------------------------------------------------*
 | validaTextoArea:    Consiste tamanho do campo informado.        |
 | 								                                   |                 
 *-----------------------------------------------------------------*/
function validaTextoArea(cCampo, cTam)  {
	sValor = Trim(cCampo.value); 		
	if (parseInt(sValor.length) <= parseInt(cTam) )  
    	   return true; 	
    else {         
         alert('Tamanho máximo para preenchimento é de ' + cTam + ' caracteres');
          sValor = sValor.substring(0,sValor.length-1);
          cCampo.value=sValor;
		 return false;    
    }		 
 }
 
 /*-----------------------------------------------------------------*
 | validaTamanhoArea:    Consiste tamanho do campo informado.       |
 | 								                                    |
 *-----------------------------------------------------------------*/
function validaTamanhoArea(cCampo, cTam)  {
	var sValor = Trim(cCampo.value); 	
	var cMsg='Tamanho máximo para preenchimento é de ' + cTam + ' caracteres' ;	
	if (parseInt(sValor.length) > parseInt(cTam) ) {
	   alert(cMsg);
	   cCampo.focus();
	   return false;
	} 
	return true;    
 }
 
 
 /*-------------------------------------------------------------------*
 | changeAccent    Troca as vogais acentuadas por números da tabela   |
 |                 de codificação. esta função evita o uso do recurso |
 |                 Server.URLEncoder                                  |
 *-------------------------------------------------------------------*/
function changeAccent(valor) {

	var aCode = new Array();
	var aNumber = new Array();
	var iCt=0;
	var cLetra='';
	var cText='';
	var bExiste=false;
		
	aCode[0]="à";
	aCode[1]="á"
	aCode[2]="â";
	aCode[3]="ã";
	aCode[4]="ä";
	aCode[5]="è";
	aCode[6]="é";
	aCode[7]="ê";
	aCode[8]="í";
	aCode[9]="í";
	aCode[10]="î";
	aCode[11]="ï";
	aCode[12]="ó";
	aCode[13]="ò";
	aCode[14]="ô";
	aCode[15]="õ";
	aCode[16]="ö";
	aCode[17]="ú";
	aCode[18]="ù";
	aCode[19]="ü";
	aCode[20]="û";
	aCode[21]="Á";
	aCode[22]="À";
	aCode[23]="Â";
	aCode[24]="Ã";
	aCode[25]="Ä";
	aCode[26]="É";
	aCode[27]="È";
	aCode[28]="Ê";
	aCode[29]="Ë";
	aCode[30]="Í";
	aCode[31]="Ì";
	aCode[32]="Î";
	aCode[33]="Ï";
	aCode[34]="Ó";
	aCode[35]="Ò";
	aCode[36]="Ô";
	aCode[37]="Õ";
	aCode[38]="Ö";
	aCode[39]="Ú";
	aCode[40]="Ù";
	aCode[41]="Û";
	aCode[42]="Ü";
	aCode[43]="ç";
	aCode[44]="Ç";
	//
	aNumber[0]="$00";
	aNumber[1]="$01";
	aNumber[2]="$02";
	aNumber[3]="$03";
	aNumber[4]="$04";
	aNumber[5]="$05";
	aNumber[6]="$06";
	aNumber[7]="$07";
	aNumber[8]="$08";
	aNumber[9]="$09";
	aNumber[10]="$10";
	aNumber[11]="$11";
	aNumber[12]="$12";
	aNumber[13]="$13";
	aNumber[14]="$14";
	aNumber[15]="$15";
	aNumber[16]="$16";
	aNumber[17]="$17";
	aNumber[18]="$18";
	aNumber[19]="$19";
	aNumber[20]="$20";
	aNumber[21]="$21";
	aNumber[22]="$22";
	aNumber[23]="$23";
	aNumber[24]="$24";
	aNumber[25]="$25";
	aNumber[26]="$26";
	aNumber[27]="$27";
	aNumber[28]="$28";
	aNumber[29]="$29";
	aNumber[30]="$30";
	aNumber[31]="$31";
	aNumber[32]="$32";
	aNumber[33]="$33";
	aNumber[34]="$34";
	aNumber[35]="$35";
	aNumber[36]="$36";
	aNumber[37]="$37";
	aNumber[38]="$38";
	aNumber[39]="$39";
	aNumber[40]="$40";
	aNumber[41]="$41";
	aNumber[42]="$42";
	aNumber[43]="$43";
	aNumber[44]="$44";
		
	for( iCt = 0; iCt < valor.length;iCt++) {
		
		cLetra = valor.charAt(iCt);	
		
		bExiste=false;			    
		for (var iCtL = 0 ; iCtL < aCode.length; iCtL++) {
			if ( cLetra == aCode[iCtL] ) {			    								
				bExiste=true;
				break;
			}
		}
		if (!bExiste) 
			cText=cText + cLetra;					
		else
			cText=cText + aNumber[iCtL];			
	}		
	return cText;
	
 }