//////////////////////////////////////////////////////////////////////////////////////////
// funcao do menu do topo da pagina (outras edicoes)
//////////////////////////////////////////////////////////////////////////////////////////
/*sfHover = function()
{
	var sfEls = document.getElementById('nav').getElementsByTagName('li');
    for (var i=0; i<sfEls.length; i++)
	{
		sfEls[i].onmouseover=function()
		{
			this.className+=' sfhover';
		}
		sfEls[i].onmouseout=function()
		{
			this.className=this.className.replace(new RegExp('sfhover\\b'), '');
		}
    }
}
*/
sfHover = function() 
	{
		if (document.all&&document.getElementById) 
		{
			navRoot = document.getElementById("nav");
			for (i=0; i<navRoot.childNodes.length; i++) 
			{
				node = navRoot.childNodes[i];
				if (node.nodeName=="LI") 
				{
					node.onmouseover=function() 
					{
						this.className+=" sfhover";
					}
					node.onmouseout=function() 
					{
						this.className=this.className.replace(" sfhover", "");
					}
				}
			}
		}
	}	


function ValidarBusca(strBusca)
{
	var strBuscaAux = Trim(strBusca);
	
	if (strBuscaAux.length == 0)
	{
	    alert('Informe o texto para a pesquisa.');
	    return false;
	}
	else
	{
		return true;
	}
}

//--------------------------------------------------------------------------------------------------------
function Trim(s){

	s = Ltrim(s); s = Rtrim(s);
	
	return (s)
}

//--------------------------------------------------------------------------------------------------------
function Ltrim(s){

	// Left Spaces
	while (s.indexOf(" ") == 0){s=s.replace(" ","")};

	return (s)
}

//--------------------------------------------------------------------------------------------------------
function Rtrim(s){

	// Right Spaces
	while (s.lastIndexOf(" ") == (s.length-1) && s.length > 0){s=s.slice(0,-1)};

	return (s)
}

/*----------------------------------------------------------------------*
 '                  Regra de composição do CMC7                    '
 '                                                                 '
 '                                                                 '
 ' Número composto por 30 dígitos, descritos da seguinte forma :   '
 '                                                                 '
 '   |341|0004|8|018|000001|5|0|5000000004|7|                      '
 '     1    2  3  4    5    6 7      8     9                       '
 '                                                                 '
 ' 1 = código compensação do banco (3 dígitos)                     '
 ' 2 = número da agência (4 dígitos)                               '
 ' 3 = dígito módulo 10 dos seguintes campos :                     '
 '     cód.câmara compensação (3 dígitos)                          '
 '     núm.do cheque (6 dígitos)                                   '
 '     cód.tipificação do documento (1 dígito)                     '
 ' 4 = código da câmara compensação (3 dígitos)                    '
 ' 5 = número do cheque (6 dígitos)                                '
 ' 6 = código tipificação do documento (1 dígito)                  '
 '     5 : cheque comum                                            '
 '     6 : cheque ordem de pagamento                               '
 '     7 : cheque viagem                                           '
 '     8 : cheque administrativo                                   '
 ' 7 = dígito módulo 10 dos seguintes campos :                     '
 '     cód.banco (3 dígitos)                                       '
 '     cód.agência (4 dígitos)                                     '
 ' 8 = número da conta corrente (com dígito da conta) (10 dígitos) '
 ' 9 = dígito módulo 10 do campo número da cta.corrente            '
 '-----------------------------------------------------------------'*/

/*-----------------------------------------------------------------*
 | ValidarCMC7DotNet                                               |
 |                                                                 |
 | Objetivo: Validar o número do CMC7   )   			           |
 |           no padrão .NET                                        |
 *-----------------------------------------------------------------*/
function ValidarCMC7DotNet(objSource,objArgs)
	{
		var lc_numero = PassaDominio(objArgs.Value, "0123456789");
		var lc_Tam    = lc_numero.length;
		var lc_NumCalc;
		var lc_DigRec1;
		var lc_DigRec2;
		var lc_DigRec3;
		var lc_DigCalc1;
		var lc_DigCalc2;
		var lc_DigCalc3;
		var lc_Cmc7Calc;

		if (lc_Tam != 30) 
		{
  			objArgs.IsValid = false; 
			return false;
		}

		lc_NumCalc = lc_numero.substring( 8,18 ); 
		lc_DigRec1 = lc_numero.substring( 7,8 ); 
		lc_DigCalc1 = DvModulo10(lc_NumCalc);

		lc_NumCalc = "000" +  lc_numero.substring( 0,7 );
		lc_DigRec2 = lc_numero.substring(18,19);  
		lc_DigCalc2 = DvModulo10(lc_NumCalc);

		lc_NumCalc = lc_numero.substring(19,29);
		lc_DigRec3 = lc_numero.substring( 29,30 ); 
		lc_DigCalc3 = DvModulo10(lc_NumCalc);

		lc_Cmc7Calc = lc_numero.substring( 0,7 ) + lc_DigCalc1 + lc_numero.substring( 8,18 ) + lc_DigCalc2 + lc_numero.substring( 19,29 ) + lc_DigCalc3;
		if (lc_numero != lc_Cmc7Calc )
		{
  			objArgs.IsValid = false; 
			return false;
		}

		objArgs.IsValid = true; 
		return true;
	}

/*-----------------------------------------------------------------*
 | DvModulo10                                                      |
 |                                                                 |
 | Objetivo: Calcular o DV no módulo 10                            |
 *-----------------------------------------------------------------*/
function DvModulo10(numero) 
   {
		var lc_Tam    = numero.length;
		var lc_Soma   = 0;
		var lc_Pos    = true;
		var lc_Resto;
		var lc_Cont;
		var lc_Aux;
		var Dv;

		for( lc_Cont =0 ; lc_Cont < lc_Tam ; lc_Cont++){
			lc_Aux = numero.substring( lc_Cont, lc_Cont+1);
			if( lc_Pos == true ){
				lc_Pos = false;
				lc_Soma = new Number(lc_Soma) + new Number(lc_Aux);
			}else{
				lc_Pos = true;
				if( lc_Aux > 4 ){
					lc_Soma = lc_Soma + (lc_Aux * 2) - 9;
				}else{
					lc_Soma = lc_Soma + (lc_Aux * 2);
				}
			}   
		}
		lc_Resto = lc_Soma % 10;
		if( lc_Resto == 0 ){
			Dv = 0;
		}else{
			Dv = 10 - lc_Resto;
		}
		return Dv;
	}


/*-----------------------------------------------------------------*
 | DvModulo11                                                      |
 |                                                                 |
 | Objetivo: Calcular o DV no módulo 11                            |
 *-----------------------------------------------------------------*/
function DvModulo11(numero) 
	{
		var xTamanho = numero.length;
		var xValor   = 0;
		var xProduto = 0;
		var xPeso    = "23456789234567892345678923456789";
		var xYpeso   = 0;
		var xConta   = 0;
		var xDv;
		
		for(xConta=xTamanho-1;xConta>=0 ;xConta--) 
			{
				xProduto = (numero.charAt(xConta)) * (xPeso.charAt(xYpeso));
				xYpeso++;
				xValor = xValor + xProduto;
			}
		xDv = xValor % 11;
		xDv = 11 - xDv;
		if(xDv == 10 || xDv == 11) xDv = 0;
		
		return(xDv);
	}

/*-----------------------------------------------------------------*
 | ValidarChequeDotNet                                             |
 |                                                                 |
 | Objetivo: Validar o número do cheque (DV)   			           |
 |           no padrão .NET                                        |
 *-----------------------------------------------------------------*/

function ValidarChequeDotNet(objSource,objArgs)
	{
		var NuCheque = PassaDominio(objArgs.Value, "0123456789");
		var Tamanho  = NuCheque.length;
		var Dv1;
		var Dv2;

		if (isNaN(NuCheque)) 
			{
			  objArgs.IsValid = false; 
			}
		else if (Tamanho > 7) 
			{
			  objArgs.IsValid = false; 
			}
		else if (NuCheque == 0) 
			{
			  objArgs.IsValid = false; 
			}
		else
		    {
		      Dv1 = NuCheque.substr(Tamanho-1,1);	      
		      Dv2 = DvModulo11(NuCheque.substr(0,Tamanho-1));
		      
		      if (Dv1 == Dv2)
				{
					objArgs.IsValid = true;
				}
			  else
			    {
					objArgs.IsValid = false;
			    }
		    }
	}
	
/*-----------------------------------------------------------------*
 | ValidarCPFParcialDotNet                                         |
 |                                                                 |
 | Objetivo: Validar o CPF apenas se ele estiver sido informado    |
 |           por completo (.NET).                                  |
 *-----------------------------------------------------------------*/

function ValidarCPFParcialDotNet(objSource,objArgs)
	{
		var CPF = PassaDominio(objArgs.Value, "0123456789");
		
		if (isNaN(CPF)) 
			{
			  objArgs.IsValid = false; 
			}
		else if (CPF.length < 11) 
			{
			  objArgs.IsValid = true; 
			}
		else
		    {
		      objArgs.IsValid = ValidarCPF(objArgs.Value);
		    }
	}

/*-----------------------------------------------------------------*
 | ValidarCPF                                                      |
 |                                                                 |
 | Objetivo: Validar o CPF                                         |
 *-----------------------------------------------------------------*/

function ValidarCPF(Numero)
	{
		var CPF = PassaDominio(Numero, "0123456789");
		
		if (isNaN(CPF)) 
			{
			  return false;
			}
			
		var i;
		var NumCPF = CPF.substr(0,9);
		var dv = CPF.substr(9,2);
		var d1 = 0;
		for (i = 0; i < 9; i++) 
			{
			  d1 += NumCPF.charAt(i)*(10-i);
			}
		if (d1 == 0)
			{
			  return false;
			}         
		d1 = 11 - (d1 % 11);
		if (d1 > 9) d1 = 0;         
		if (dv.charAt(0) != d1) 
			{
			  return false;         
			}
		d1 *= 2;
		for (i = 0; i < 9; i++) 
			{
			  d1 += NumCPF.charAt(i)*(11-i);
			}
		d1 = 11 - (d1 % 11);
		if (d1 > 9) d1 = 0;
		if (dv.charAt(1) != d1) 
			{
			  return false;
			}
		return true;
	} 

/*-----------------------------------------------------------------*
 | ValidarCPFDotNet                                                |
 |                                                                 |
 | Objetivo: Validar o CPF no padrão .NET                          |
 *-----------------------------------------------------------------*/

function ValidarCPFDotNet(objSource,objArgs)
	{
		objArgs.IsValid = ValidarCPF( objArgs.Value );
	} 
	
/*-----------------------------------------------------------------*
 | ValidarCNPJ                                                     |
 |                                                                 |
 | Objetivo: Validar o CNPJ                                        |
 *-----------------------------------------------------------------*/

function ValidarCNPJ(Numero)
	{
		var CNPJ = PassaDominio(Numero, "0123456789");
		
		if (isNaN(CNPJ)) 
			{
			  return false;
			}
			
		var i;
		var NumCNPJ = CNPJ.substr(0,12);
		var dv = CNPJ.substr(12,2);
		var d1 = 0;
		for (i = 0; i <12; i++)
			{
			  d1 += NumCNPJ.charAt(11-i)*(2+(i % 8));
			}
		if (d1 == 0) 
			{
			  return false;
			}
		d1 = 11 - (d1 % 11);
		if (d1 > 9) d1 = 0;
		if (dv.charAt(0) != d1)
			{
			  return false;
			}
		d1 *= 2;
		for (i = 0; i < 12; i++)
			{
			  d1 += NumCNPJ.charAt(11-i)*(2+((i+1) % 8));
			}
		d1 = 11 - (d1 % 11);
		if (d1 > 9) d1 = 0;
		if (dv.charAt(1) != d1)
			{
			  return false;
			}
		return true;
	} 

/*-----------------------------------------------------------------*
 | ValidarCNPJDotNet                                               |
 |                                                                 |
 | Objetivo: Validar o CNPJ no padrão .NET                         |
 *-----------------------------------------------------------------*/

function ValidarCNPJDotNet(objSource,objArgs)
	{
	    objArgs.IsValid = ValidarCNPJ(objArgs.Value); 
	}

/*-----------------------------------------------------------------*
 | ValidarCartaoCreditoExt                                         |
 |                                                                 |
 | Objetivo: Validar o número do cartão de crédito externo         |
 *-----------------------------------------------------------------*/

function ValidarCartaoCreditoExt(Numero)
	{
		var NumCartao = PassaDominio(Numero, "0123456789");
		
		if (isNaN(NumCartao)) 
			{
			  return false;
			}
		else if (NumCartao.length < 14)
			{
			  return false;
			}
			
		var i;
		var Valor;
		var Tamanho = NumCartao.length;
		var Soma = 0;
		
		for (i = 0; i <Tamanho; i++)
			{
			  if (((16 - Tamanho + i) % 2) == 0)
				{
				  Valor = parseInt(NumCartao.substr(i,1) * 2);
				  if (Valor > 9) Valor -= 9;
				}
			  else
			    {
				  Valor = parseInt(NumCartao.substr(i,1));
			    }
			  Soma += Valor;
			}
		return (((Soma % 10) == 0) && (Soma < 150));
	} 

/*-----------------------------------------------------------------*
 | ValidarCartaoExtDotNet                                          |
 |                                                                 |
 | Objetivo: Validar o número do cartão de crédito no padrão .NET  |
 *-----------------------------------------------------------------*/

function ValidarCartaoExtDotNet(objSource,objArgs)
	{	
		objArgs.IsValid = ValidarCartaoCreditoExt(objArgs.Value); 
	}

/*-----------------------------------------------------------------*
 | ValidarAltCartaoExtDotNet                                          |
 |                                                                 |
 | Objetivo: Validar o número do cartão de crédito no padrão .NET  |
 |           Esta versão é para pular a critica quando o cartão    |
 |           tiver 8 asteriscos.                                   | 
 *-----------------------------------------------------------------*/

function ValidarAltCartaoExtDotNet(objSource,objArgs)
	{		
		var Asterisco = PassaDominio(objArgs.Value,'*');

        if (Asterisco.length == 8)
			{
			  objArgs.IsValid = true;
			}		
		else
			{				
			  objArgs.IsValid = ValidarCartaoCreditoExt(objArgs.Value); 
			}			
	}

/*-----------------------------------------------------------------*
 | ValidarCartaoDotNet                                             |
 |                                                                 |
 | Objetivo: Validar o nosso cartão de crédito no padrão .NET      |
 *-----------------------------------------------------------------*/

function ValidarCartaoDotNet(objSource,objArgs)
	{	
		objArgs.IsValid = ValidarCartaoCredito(objArgs.Value); 
	}

/*-----------------------------------------------------------------*
 | ValidarCartao                                                   |
 |                                                                 |
 | Objetivo: Validar Nosso Cartao                                  |
 *-----------------------------------------------------------------*/

function ValidarCartaoCredito(Numero)
	{
		var NumCartaoCompleto = PassaDominio(Numero, "0123456789");
		
		if (isNaN(NumCartaoCompleto)) 
			{
			  return false;
			}
		else if (NumCartaoCompleto.length != 16)
			{
			  return false;
			}
	
		var NumBin = parseInt(NumCartaoCompleto.substr(0,6),10);
		if (NumBin == 0) 
			{
			  return false;
			}
	
		var NumCliente = parseInt(NumCartaoCompleto.substr(6,7),10);
		if (NumCliente == 0) 
			{
			  return false;
			}
				 
		/* Calculo do DV */
		var NumCartao = NumCartaoCompleto.substr(0,15);
		dv = NumCartaoCompleto.substr(15,1);
		multi = '654329876543298';
		d1 = 0;
		for (i = 0; i <15; i++)
			{
			  d1 += NumCartao.charAt(i) * multi.charAt(i);
			}
		d1 = (d1 * 10) % 11;
		if (d1 > 9) d1 = 0;
		if (dv != d1)
			{
			  return false;
			}
		return true;
	} 

/*-----------------------------------------------------------------*
 | ValidarCertificadoDotNet                                        |
 |                                                                 |
 | Objetivo: Validar o numero do certificadoo no padrão .NET       |
 *-----------------------------------------------------------------*/

function ValidarCertificadoDotNet(objSource,objArgs)
	{	
		objArgs.IsValid = ValidarCertificado(objArgs.Value); 
	}

/*-----------------------------------------------------------------*
 | ValidarCartao                                                   |
 |                                                                 |
 | Objetivo: Validar Nosso Cartao                                  |
 *-----------------------------------------------------------------*/

function ValidarCertificado(Numero)
	{
		var NuCertificadoCompleto = PassaDominio(Numero, "0123456789");
		
		if (isNaN(NuCertificadoCompleto)) 
			{
			  return false;
			}
		else if (NuCertificadoCompleto.length != 14)
			{
			  return false;
			}
			
		var IntNuCertificadoCompleto = parseInt(NuCertificadoCompleto);

		if (IntNuCertificadoCompleto == 0) 
			{
			  return false;
			}
		 
		return true;
	} 


/*-----------------------------------------------------------------*
 | ValidarIdVendedorDotNet                                         |
 |                                                                 |
 | Objetivo: Validar o o ID do vendedor no padrão .NET             |
 *-----------------------------------------------------------------*/

function ValidarIdVendedorDotNet(objSource,objArgs)
	{	
		objArgs.IsValid = ValidarIdVendedor(objArgs.Value); 
	}	
	
/*-----------------------------------------------------------------*
 | ValidarIdVendedor                                               |
 |                                                                 |
 | Objetivo: Validar Matrícula do Vendedor                         |
 *-----------------------------------------------------------------*/

function ValidarIdVendedor(Numero)
	{
		var NumVendedorCompleto = PassaDominio(Numero, "0123456789");
		
		if (isNaN(NumVendedorCompleto)) 
			{
			  return false;
			}
		else if (NumVendedorCompleto.length > 6)
			{
			  return false;
			}
			
		else if (NumVendedorCompleto <= 9) 
			{
			  return false;
			}
		 
		/* Calculo do DV */
		var Tam = NumVendedorCompleto.length
		NumVendedorCompleto = ('000000' + NumVendedorCompleto).substr(Tam,6)
		var NumVendedor = NumVendedorCompleto.substr(0,5);
		dv = NumVendedorCompleto.substr(5,1);
		multi = '65432';
		d1 = 0;
		for (i = 0; i <5; i++)
			{
			  d1 += NumVendedor.charAt(i) * multi.charAt(i);
			}
		d1 = 11 - (d1 % 11);
		if (d1 == 10) 
		   {
		     d1 = 0;
		   }
		else if (d1 == 11)
		   {
		     d1 = 1;
		   }
		
		if (dv != d1)
			{
			  return false;
			}
		return true;
	} 
		
/*-----------------------------------------------------------------*
 | ValidarSenhaDotNet                                              |
 |                                                                 |
 | Objetivo: Validar a senha no padrão .NET                        |
 *-----------------------------------------------------------------*/

function ValidarSenhaDotNet(objSource,objArgs)
	{
		if ((objArgs.Value.length < 6) || (objArgs.Value.length > 10))
			{
			   objArgs.IsValid = false;
			}
	    else
	        {
			   objArgs.IsValid = true;
	        }
	} 
	
/*-----------------------------------------------------------------*
 | MaxTamCampo                                                     | 
 |                                                                 |
 | Objetivo: Limitar o tamanho do textarea                         |
 *-----------------------------------------------------------------*/
 
function MaxTamCampo(Campo,TamMax)
{	
	var ValCampo = Campo.value;
	var TamanhoCampo = ValCampo.length;
	
	if (TamanhoCampo > TamMax)
		{ 	
		   Campo.value = ValCampo.substring(0,TamMax)	
		   alert("O limite maximo desse campo e de " + TamMax + " caracteres.")
	    }	
}

/*-----------------------------------------------------------------*
 | PassaDominio        Retorna a String dada, somente com os       |
 |                     caracteres do domínio dado                  |
 *-----------------------------------------------------------------*/
function PassaDominio(StrDado, Dominio)
	{
	var i, j, c;
	var Result;
	
	Result = "";
	for (i=0; i<StrDado.length; i++)
		{
		c = StrDado.substr(i,1);
		for (j=0; j<Dominio.length; j++)
			{
			if (c == Dominio.substr(j,1)) break;
			}
		if (j < Dominio.length)
			{
			Result = Result + c;
			}
		}
	return Result;
}
/*
  Formatação de campo numérico
*/

function formatCurrency(num,currencySymbol,sepMilhar,sepDecimal) 
{
   num = num.toString().replace(/\$|\,/g,'');
   
   if(isNaN(num))
      {
      num = "0";
      }
      
   sign = (num == (num = Math.abs(num)));
   num = Math.floor(num*100+0.50000000001);
   cents = num%100;
   num = Math.floor(num/100).toString();
   
   if(cents<10)
      {
      cents = "0" + cents;
      }
      
   for (var i = 0; i < Math.floor((num.length-(1+i))/3); i++)
      {
      num = num.substring(0,num.length-(4*i+3))+ sepMilhar + num.substring(num.length-(4*i+3));
      }
      
   return (((sign)?'':'-') + currencySymbol + " " + num + sepDecimal + cents);
}


/*
 Nome........: Filtro
 Descricao...: Insere a máscara e filtra o campos especificado
 Paramentros.: Objeto,tpCampo
 Retorno.....: Retorna o conteúdo formatado dependendo do tipo (tpCampo) e não
			   permite caracteres inválidos
*/

function Filtro(Objeto,tpCampo)
{

if (navigator.appName.substr(0,9) == "Microsoft") {

   if(window.event.keyCode == 37 ||
      window.event.keyCode == 8  ||
      window.event.keyCode == 36 ||
	  window.event.keyCode == 46 ||
	  window.event.keyCode == 16 ||
	  window.event.keyCode == 9 )
	  return;

	if (window.event.keyCode == 111 || window.event.keyCode == 191) {
		if (tpCampo == "data") {
			if (Objeto.value.length == 3 || Objeto.value.length == 6) {
				return
			}
			if (Objeto.value.length == 4 || Objeto.value.length == 7) {
				var newpos = Objeto.value.length - 1
				Objeto.value = Objeto.value.substring(0,newpos)
				return
			}
		}
	}

	if (window.event.keyCode == 39) {
		if (tpCampo == "data") {
			if (Objeto.value.length == 2 || Objeto.value.length == 5)
				Objeto.value = Objeto.value + "/"
		}
		return
	}

}

//if (navigator.appName.substr(0,9) == "Microsoft")
//  {
	Objeto.value = PassaDominio(Objeto.value, "0123456789");

	if (tpCampo == "data")
	{
		Objeto.value = FmtData(Objeto.value);
	}	
	if (tpCampo == "DataMesAno")
	{
		Objeto.value = FmtDataMesAno(Objeto.value);
	}
	if (tpCampo == "valor")
	{	
		Objeto.value = FmtCurr(Objeto.value);
	}
	if (tpCampo == "hora")
	{	
		Objeto.value = FmtHora(Objeto.value);
	}
	if (tpCampo == "telefone")
	{	
		Objeto.value = FmtTelefone(Objeto.value);
	}
	if (tpCampo == "CEP")
	{	
		Objeto.value = FmtCEP(Objeto.value);
	}
	if (tpCampo == "CPF")
	{	
		Objeto.value = FmtCPF(Objeto.value);
	}
	if (tpCampo == "CNPJ")
	{	
		Objeto.value = FmtCNPJ(Objeto.value);
	}
	if (tpCampo == "cartao")
	{	
		Objeto.value = FmtCartao(Objeto.value);
	}
		if (tpCampo == "certificado")
	{	
		Objeto.value = FmtCertificado(Objeto.value);
	}

	if (tpCampo == "dv")
	{	
		Objeto.value = FmtDv(Objeto.value);
	}

//  }
}

/*
 Nome........: FmtData
 Descricao...: Insere a máscara de data no campo
 Paramentros.: Dado
 Retorno.....: Retorna o conteúdo formatado em dd/mm/yyyy, não permitindo a digitação
               de caracteres alfa 
*/

function FmtData(Dado)
  {
  var Result = Dado;
  var l = Dado.length;

  if((l > 2) && (l < 5))
    {
	Result = Dado.substr(0, 2) + "/" + Dado.substr(2, 2);
    }
  if(l >= 5)
    {
	Result = Dado.substr(0, 2) + "/" + Dado.substr(2, 2) + "/" + Dado.substr(4, 4);
	}
  return Result;
  }

/*
 Nome........: FmtDataMesAno
 Descricao...: Insere a máscara de data no campo
 Paramentros.: Dado
 Retorno.....: Retorna o conteúdo formatado em mm/yyyy, não permitindo a digitação
               de caracteres alfa 
*/
function FmtDataMesAno(Dado)
  {
   	var Result = Dado;

	 	for (i=1; i<=Dado.length; i++)
		{			
			if (i == 2)
			{	
				Result = Dado.substr(0, 2) + "/" + Dado.substr(2, i);
			}
			if (i > 2)
			{
				Result = Dado.substr(0, 2) + "/" + Dado.substr(2, 4);
			}
		}
   return Result;
  }
  
  /*
 Nome........: FmtHora
 Descricao...: Insere a máscara de hora no campo
 Paramentros.: Dado
 Retorno.....: Retorna o conteúdo formatado em hh:mm, não permitindo a digitação
               de caracteres alfa 
*/

function FmtHora(Dado)
  {
   	var Result = Dado;

	 	for (i = 1; i <= Dado.length; i++)
		{

			if (i >= 3)
			{
				Result = Dado.substr(0, 2) + ":" + Dado.substr(2, 2);
			}
		}
   return Result;
  }

 /*
 Nome........: FmtCurr
 Descricao...: Insere a máscara de valor no campo
 Paramentros.: Dado
 Retorno.....: Retorna o conteúdo formatado em 999.999.999,99, não permitindo a digitação
               de caracteres alfa 
*/  
  function FmtCurr(Dado)
  {
  var Result = Dado;
  var i;
  
  if (Dado.length > 2)
    {
    Result = "," + Dado.substr(Dado.length-2, 2);
    for (i=5; i<=Dado.length; i+=3)
      {
      Result = Dado.substr(Dado.length-i, 3) + Result;
      if (Dado.length > i) Result = "." + Result;
      }
    Result = Dado.substr(0, Dado.length-i+3) + Result;
    }
  return Result;
}

/*
 Nome........: FmtTelefone
 Descricao...: Insere a máscara de telefone no campo
 Paramentros.: Dado
 Retorno.....: Retorna o conteúdo formatado em (99)9999-9999, não permitindo a digitação
               de caracteres alfa 
*/  
  function FmtTelefone(Dado)
  {
  var Result = Dado;
  var l = Dado.length;
  
  if (l == 1)
    {
	Result = "(" + Dado;
    } 
  if ((l >= 2) && (l <= 6))
    {
    Result = "(" + Dado.substr(0, 2) + ")" + Dado.substr(2, l-2);
    }
  if (l > 6) 
    {
    Result = "(" + Dado.substr(0, 2) + ")" + Dado.substr(2, l-6) + "-" + Dado.substr(l-4, 4);
    }
  return Result;
}

/*
 Nome........: FmtCEP
 Descricao...: Insere a máscara de CEP no campo
 Paramentros.: Dado
 Retorno.....: Retorna o conteúdo formatado em 99999-999 não permitindo a digitação
               de caracteres alfa 
*/
function FmtCEP(Dado)
  {
   	var Result = Dado;
   	var i=Dado.length

	if (i >= 5)
	{	
		Result = Dado.substr(0, 5) + "-" + Dado.substr(5, 3);
	}
   return Result;
  }

/*
 Nome........: FmtDv
 Descricao...: Insere a máscara de DV no campo
 Paramentros.: Dado
 Retorno.....: Retorna o conteúdo formatado em 9999999-9 não permitindo a digitação
               de caracteres alfa 
*/
function FmtDv(Dado)
  {
   	var Result = Dado;
   	var i = Dado.length;
   	var tam = i;

	if (i >= 2)
	{	
		Result = Dado.substr(0, i - 1) + "-" + Dado.substr(i - 1, 1);
	}
   return Result;
  }
/*
 Nome........: FmtCPF
 Descricao...: Insere a máscara de CPF no campo
 Paramentros.: Dado
 Retorno.....: Retorna o conteúdo formatado em 999.999.999-99, não permitindo a digitação
               de caracteres alfa 
*/  
  function FmtCPF(Dado)
  {
   	var Result = "";

	 	for (i=1; i<=Dado.length; i++)
		{	
			Result += Dado.substr(i-1,1);
					
			if ((i == 4) || (i == 7))
			{	
				Result = Result.substr(0,Result.length-1) + "." + Result.substr(Result.length-1,1)
			}
			if (i == 10)
			{
				Result = Result.substr(0,Result.length-1) + "-" + Result.substr(Result.length-1,1)
			}
		}
   return Result;
  }

/*
 Nome........: FmtCNPJ
 Descricao...: Insere a máscara de CNPJ no campo
 Paramentros.: Dado
 Retorno.....: Retorna o conteúdo formatado em 99.999.999/9999-99, não permitindo a digitação
               de caracteres alfa 
*/  
  function FmtCNPJ(Dado)
  {
   	var Result = "";

	 	for (i=1; i<=Dado.length; i++)
		{	
			Result += Dado.substr(i-1,1);
					
			if ((i == 3) || (i == 6))
			{	
				Result = Result.substr(0,Result.length-1) + "." + Result.substr(Result.length-1,1)
			}
			if (i == 9)
			{
				Result = Result.substr(0,Result.length-1) + "/" + Result.substr(Result.length-1,1)
			}
			if (i == 13)
			{
				Result = Result.substr(0,Result.length-1) + "-" + Result.substr(Result.length-1,1)
			}
		}
   return Result;
  }

/*
 Nome........: FmtCartao
 Descricao...: Insere a máscara do nosso cartao no campo
 Paramentros.: Dado
 Retorno.....: Retorna o conteúdo formatado em 9999.9999.9999.9999, não permitindo a digitação
               de caracteres alfa 
*/  
  function FmtCartao(Dado)
  {
   	var Result = "";

	 	for (i=1; i<=Dado.length; i++)
		{	
			Result += Dado.substr(i-1,1);
					
			if ((i == 5) || (i == 9) || (i == 13)) 
			{	
				Result = Result.substr(0,Result.length-1) + "." + Result.substr(Result.length-1,1)
			}
		}
   return Result;
  }
  
  /*
 Nome........: FmtCERTIFICADO
 Descricao...: Insere a máscara de CERTIFICADO no campo
 Paramentros.: Dado
 Retorno.....: Retorna o conteúdo formatado em 99999.999.9999-9, não permitindo a digitação
               de caracteres alfa 
*/  
  function FmtCertificado(Dado)
  {
   	var Result = "";

	 	for (i=1; i<=Dado.length; i++)
		{	
			Result += Dado.substr(i-1,1);
					
			if ((i == 7) || (i == 10))
			{	
				Result = Result.substr(0,Result.length-1) + "." + Result.substr(Result.length-1,1)
			}
			if (i == 14)
			{
				Result = Result.substr(0,Result.length-1) + "-" + Result.substr(Result.length-1,1)
			}
		}
   return Result;
  }

/*******************************************************************
 *  Funções de Filtro para uso com Text-Boxes:                     *
 *  Utilize-as sob os eventos OnKeyUp e OnChange simultaneamente.  *
 *******************************************************************/

function FiltroNum(Objeto)
	{
	Objeto.value = PassaDominio(Objeto.value, "0123456789");
	}
	
function FiltroInt(Objeto)
	{
	Objeto.value = PassaDominio(Objeto.value, "0123456789+-");
	}

function FiltroDec(Objeto)
	{
	Objeto.value = PassaDominio(Objeto.value, "0123456789,");
	}
				
function FiltroCurr(Objeto)
	{
	Objeto.value = PassaDominio(Objeto.value, "0123456789+-,.");
	}

function FiltroFloat(Objeto)
	{
	Objeto.value = PassaDominio(Objeto.value, "0123456789+-Ee,.");
	}

function FiltroData(Objeto)
	{
	Objeto.value = PassaDominio(Objeto.value, "0123456789/");
	}

function FiltroHora(Objeto)
	{
	Objeto.value = PassaDominio(Objeto.value, "0123456789:");
	}

function FiltroUp(Objeto)
	{
	Objeto.value = Objeto.value.toUpperCase();
	}

/********************************************************************************
 *  Funçõos de salto automático para próximo campo                              *
 *  Utilize-as sob o evento OnKeyUp (fPulaCampo), OnKeyPress (fAtuPulaKeyPress) *
 *                          OnBlur (fAtuPulaBlur) ????                          *   
 *******************************************************************************/
 
var bPula = true; 
  
function fAtuPulaBlur()
{
	bPula = false;	
}
function fAtuPulaKeyPress()
{
	bPula = true;
	return;
}
 
function fPulaCampo(campo1,campo2,iTam,tpcampo)
	{
		if(bPula)
		{
			
			if (tpcampo == "data")
				{
			    	Filtro(campo1,'data');
				}
				if (tpcampo == "hora")
				{
			    	Filtro(campo1,'hora');
				}
			if (campo1.value.length >= iTam)
			{ 
				campo2.focus(); 
			}
				
		}
		
		return;
		
	}


/********************************************************************************
 *  Função para esconder ou mostrar um elemento. É usado para esconder o menu   *
 *******************************************************************************/
function EscondeMostraElemento(id)
	{	
		if(document.getElementById)
			{
			  var el = document.getElementById(id);
	
			  if(el.style.display != "none")
				{			
				  el.style.display = "none";
				}
		      else
		        {
			     el.style.display = "block";
		        }
			 // SetCookie('menu',el.style.display);
	        }
	
   }
    
/********************************************************************************
 *  Função para esconder um elemento.
 *******************************************************************************/
function EscondeElemento(id)
	{	
		if(document.getElementById)
			{
			  var el = document.getElementById(id);
			  el.style.display = "none";
	        }
	
   }    
        
/********************************************************************************
 *  Função para mostrar um elemento.
 *******************************************************************************/
function MostraElemento(id)
	{	
		if(document.getElementById)
			{
			  var el = document.getElementById(id);
			  el.style.display = "block";
	        }
	
   }            
        
// -------------------------------------------------------------------
// hasOptions(obj)
//  Utility function to determine if a select object has an options array
// -------------------------------------------------------------------
function hasOptions(obj) {
	if (obj!=null && obj.options!=null) { return true; }
	return false;
	}

// -------------------------------------------------------------------
// selectUnselectMatchingOptions(select_object,regex,select/unselect,true/false)
//  This is a general function used by the select functions below, to
//  avoid code duplication
// -------------------------------------------------------------------
function selectUnselectMatchingOptions(obj,regex,which,only) {
	if (window.RegExp) {
		if (which == "select") {
			var selected1=true;
			var selected2=false;
			}
		else if (which == "unselect") {
			var selected1=false;
			var selected2=true;
			}
		else {
			return;
			}
		var re = new RegExp(regex);
		if (!hasOptions(obj)) { return; }
		for (var i=0; i<obj.options.length; i++) {
			if (re.test(obj.options[i].text)) {
				obj.options[i].selected = selected1;
				}
			else {
				if (only == true) {
					obj.options[i].selected = selected2;
					}
				}
			}
		}
	}
		
// -------------------------------------------------------------------
// selectMatchingOptions(select_object,regex)
//  This function selects all options that match the regular expression
//  passed in. Currently-selected options will not be changed.
// -------------------------------------------------------------------
function selectMatchingOptions(obj,regex) {
	selectUnselectMatchingOptions(obj,regex,"select",false);
	}
// -------------------------------------------------------------------
// selectOnlyMatchingOptions(select_object,regex)
//  This function selects all options that match the regular expression
//  passed in. Selected options that don't match will be un-selected.
// -------------------------------------------------------------------
function selectOnlyMatchingOptions(obj,regex) {
	selectUnselectMatchingOptions(obj,regex,"select",true);
	}
// -------------------------------------------------------------------
// unSelectMatchingOptions(select_object,regex)
//  This function Unselects all options that match the regular expression
//  passed in. 
// -------------------------------------------------------------------
function unSelectMatchingOptions(obj,regex) {
	selectUnselectMatchingOptions(obj,regex,"unselect",false);
	}
	
// -------------------------------------------------------------------
// sortSelect(select_object)
//   Pass this function a SELECT object and the options will be sorted
//   by their text (display) values
// -------------------------------------------------------------------
function sortSelect(obj) {
	var o = new Array();
	if (!hasOptions(obj)) { return; }
	for (var i=0; i<obj.options.length; i++) {
		o[o.length] = new Option( obj.options[i].text, obj.options[i].value, obj.options[i].defaultSelected, obj.options[i].selected) ;
		}
	if (o.length==0) { return; }
	o = o.sort( 
		function(a,b) { 
			if ((a.text+"") < (b.text+"")) { return -1; }
			if ((a.text+"") > (b.text+"")) { return 1; }
			return 0;
			} 
		);

	for (var i=0; i<o.length; i++) {
		obj.options[i] = new Option(o[i].text, o[i].value, o[i].defaultSelected, o[i].selected);
		}
	}

// -------------------------------------------------------------------
// selectAllOptions(select_object)
//  This function takes a select box and selects all options (in a 
//  multiple select object). This is used when passing values between
//  two select boxes. Select all options in the right box before 
//  submitting the form so the values will be sent to the server.
// -------------------------------------------------------------------
function selectAllOptions(obj) {
	if (!hasOptions(obj)) { return; }
	for (var i=0; i<obj.options.length; i++) {
		obj.options[i].selected = true;
		}
	}
	
// -------------------------------------------------------------------
// moveSelectedOptions(select_object,select_object[,autosort(true/false)[,regex]])
//  This function moves options between select boxes. Works best with
//  multi-select boxes to create the common Windows control effect.
//  Passes all selected values from the first object to the second
//  object and re-sorts each box.
//  If a third argument of 'false' is passed, then the lists are not
//  sorted after the move.
//  If a fourth string argument is passed, this will function as a
//  Regular Expression to match against the TEXT or the options. If 
//  the text of an option matches the pattern, it will NOT be moved.
//  It will be treated as an unmoveable option.
//  You can also put this into the <SELECT> object as follows:
//    onDblClick="moveSelectedOptions(this,this.form.target)
//  This way, when the user double-clicks on a value in one box, it
//  will be transferred to the other (in browsers that support the 
//  onDblClick() event handler).
// -------------------------------------------------------------------
function moveSelectedOptions(from,to) {
	// Unselect matching options, if required
	if (arguments.length>3) {
		var regex = arguments[3];
		if (regex != "") {
			unSelectMatchingOptions(from,regex);
			}
		}
	// Move them over
	if (!hasOptions(from)) { return; }
	for (var i=0; i<from.options.length; i++) {
		var o = from.options[i];
		if (o.selected) {
			if (!hasOptions(to)) { var index = 0; } else { var index=to.options.length; }
			to.options[index] = new Option( o.text, o.value, false, false);
			}
		}
	// Delete them from original
	for (var i=(from.options.length-1); i>=0; i--) {
		var o = from.options[i];
		if (o.selected) {
			from.options[i] = null;
			}
		}
	if ((arguments.length<3) || (arguments[2]==true)) {
		sortSelect(from);
		sortSelect(to);
		}
	from.selectedIndex = -1;
	to.selectedIndex = -1;
	}

// -------------------------------------------------------------------
// copySelectedOptions(select_object,select_object[,autosort(true/false)])
//  This function copies options between select boxes instead of 
//  moving items. Duplicates in the target list are not allowed.
// -------------------------------------------------------------------
function copySelectedOptions(from,to) {
	var options = new Object();
	if (hasOptions(to)) {
		for (var i=0; i<to.options.length; i++) {
			options[to.options[i].value] = to.options[i].text;
			}
		}
	if (!hasOptions(from)) { return; }
	for (var i=0; i<from.options.length; i++) {
		var o = from.options[i];
		if (o.selected) {
			if (options[o.value] == null || options[o.value] == "undefined" || options[o.value]!=o.text) {
				if (!hasOptions(to)) { var index = 0; } else { var index=to.options.length; }
				to.options[index] = new Option( o.text, o.value, false, false);
				}
			}
		}
	if ((arguments.length<3) || (arguments[2]==true)) {
		sortSelect(to);
		}
	from.selectedIndex = -1;
	to.selectedIndex = -1;
	}

// -------------------------------------------------------------------
// moveAllOptions(select_object,select_object[,autosort(true/false)[,regex]])
//  Move all options from one select box to another.
// -------------------------------------------------------------------
function moveAllOptions(from,to) {
	selectAllOptions(from);
	if (arguments.length==2) {
		moveSelectedOptions(from,to);
		}
	else if (arguments.length==3) {
		moveSelectedOptions(from,to,arguments[2]);
		}
	else if (arguments.length==4) {
		moveSelectedOptions(from,to,arguments[2],arguments[3]);
		}
	}

// -------------------------------------------------------------------
// copyAllOptions(select_object,select_object[,autosort(true/false)])
//  Copy all options from one select box to another, instead of
//  removing items. Duplicates in the target list are not allowed.
// -------------------------------------------------------------------
function copyAllOptions(from,to) {
	selectAllOptions(from);
	if (arguments.length==2) {
		copySelectedOptions(from,to);
		}
	else if (arguments.length==3) {
		copySelectedOptions(from,to,arguments[2]);
		}
	}

// -------------------------------------------------------------------
// swapOptions(select_object,option1,option2)
//  Swap positions of two options in a select list
// -------------------------------------------------------------------
function swapOptions(obj,i,j) {
	var o = obj.options;
	var i_selected = o[i].selected;
	var j_selected = o[j].selected;
	var temp = new Option(o[i].text, o[i].value, o[i].defaultSelected, o[i].selected);
	var temp2= new Option(o[j].text, o[j].value, o[j].defaultSelected, o[j].selected);
	o[i] = temp2;
	o[j] = temp;
	o[i].selected = j_selected;
	o[j].selected = i_selected;
	}
	
// -------------------------------------------------------------------
// moveOptionUp(select_object)
//  Move selected option in a select list up one
// -------------------------------------------------------------------
function moveOptionUp(obj) {
	if (!hasOptions(obj)) { return; }
	for (i=0; i<obj.options.length; i++) {
		if (obj.options[i].selected) {
			if (i != 0 && !obj.options[i-1].selected) {
				swapOptions(obj,i,i-1);
				obj.options[i-1].selected = true;
				}
			}
		}
	}

// -------------------------------------------------------------------
// moveOptionDown(select_object)
//  Move selected option in a select list down one
// -------------------------------------------------------------------
function moveOptionDown(obj) {
	if (!hasOptions(obj)) { return; }
	for (i=obj.options.length-1; i>=0; i--) {
		if (obj.options[i].selected) {
			if (i != (obj.options.length-1) && ! obj.options[i+1].selected) {
				swapOptions(obj,i,i+1);
				obj.options[i+1].selected = true;
				}
			}
		}
	}

// -------------------------------------------------------------------
// removeSelectedOptions(select_object)
//  Remove all selected options from a list
//  (Thanks to Gene Ninestein)
// -------------------------------------------------------------------
function removeSelectedOptions(from) { 
	if (!hasOptions(from)) { return; }
	if (from.type=="select-one") {
		from.options[from.selectedIndex] = null;
		}
	else {
		for (var i=(from.options.length-1); i>=0; i--) { 
			var o=from.options[i]; 
			if (o.selected) { 
				from.options[i] = null; 
				} 
			}
		}
	from.selectedIndex = -1; 
	} 

// -------------------------------------------------------------------
// removeAllOptions(select_object)
//  Remove all options from a list
// -------------------------------------------------------------------
function removeAllOptions(from) { 
	if (!hasOptions(from)) { return; }
	for (var i=(from.options.length-1); i>=0; i--) { 
		from.options[i] = null; 
		} 
	from.selectedIndex = -1; 
	} 

// -------------------------------------------------------------------
// addOption(select_object,display_text,value,selected)
//  Add an option to a list
// -------------------------------------------------------------------
function addOption(obj,text,value,selected) {
	if (obj!=null && obj.options!=null) {
		obj.options[obj.options.length] = new Option(text, value, false, selected);
		}
	}
	
// -------------------------------------------------------------------
// Salva estado do ListBox em campo hidden para recuperar 
// no lado servidor	
// -------------------------------------------------------------------
function saveAllOptions(lstName,hiddenName){

	var objLst=document.getElementById(lstName);
	var objHidden=document.getElementsByName(hiddenName).item(0);
	
	var iters = objLst.length;
	var i;
	
	objHidden.value='';

	for (i=0; i<iters; i++)
		{
		if(i==0)
			{
			objHidden.value = objLst.options[i].text + '=' + objLst.options[i].value
			}
		else{
			objHidden.value = objHidden.value + '^' + objLst.options[i].text + '=' + objLst.options[i].value
			}
		};
	return true;

	}