/********************************************************************
*                                                                   *
*       Titulo:     Utilidade.JS                                    *
*                                                                   *
*       Criacao:    2000/08/02                                      *
*       Autor:      Marcelo Sequeiros                               *
*                                                                   *
*       Assunto:    Arquivo de Rotinas utilizadas para validacao    *
*                   de formularios.                                 *
*                                                                   *
*   HEADER (Funcoes que estam dentro deste arquivo                  *
*       -> validaTexto(textField) as boolean                        *
*       -> validaTextoComTamanho(strVal, strLen) as boolean         *
*       -> validaCampoNumerico(numField) as boolean                 *
*       -> validaLetraAlfabeto(strField) as boolean                 *
*		-> validaMascara(MascField) as boolean						*	
*		-> validaMascara2(MascField,strField) as boolean						*	
*       -> possuiCaracterAlfa(strVar) as boolean                    *
*       -> validaMail(mailField) as boolean                         *
*       -> validaRadio(radioField) as variant                       *
*       -> formataValor(num) as string                              *
*       -> formataData(dateField) as string                         *
*       -> formataCodProcedimento(CPField) as string                *
*       -> validaData(dateField) as variant                         *
*       -> validaDataIngles(dateField) as variant                   *
*       -> validaDataString(strData) as variant                     *
*       -> criaDgVerificadorCPF(strCPF) as integer                  *
*       -> validaCPF(cgcField) as boolean                           *
*       -> criaDgVerificadorCGC(strCGC) as integer                  *
*       -> validaCGC(cgcField) as boolean                           *
*       -> validaDataNascimento(dateField) as boolean               *
*       -> validaDataCasamento(dateField) as boolean               *
*       -> validaDataNascimentoIngles(dateField) as boolean         *
*       -> validaMoney(moneyField) as integer                       *
*       -> formataFloat(strNum, cod) as float                       *
*       -> validaCEP (cepField) as boolean                          *
*       -> validaSenha (txt) as boolean                             *
*       -> validaTelefone (txt) as boolean                          *
*       -> retornaSelect(selectField) as string                     *
*		-> validaHoraString (strHora) as boolean					*
*		-> comparaDatas(StrData1,StrData2) as boolean			    *
*       -> retornaBrowser() as string                               *
*       -> showVideo(URL) as boolean                                *
*       -> showVideoMac(URL) as boolean                             *
*       -> validaTextoCaracterEspecial(textField) as boolean                        *
*                                                                   *
********************************************************************/

// *******************
// *** validaTexto ***
// *******************
//
// Esta rotina verifica se a String passada por parametro
// possui tamanho superior a zero (0)
// Se ok, retorna true
// Se ñ ok, retorna false
//
// Parametros -> Campo a ser verificado
// Retorno    -> true/false
// 
// DataCriacao: 2000/08/02
// Autor:       Marcelo Sequeiros
//
function validaTexto(textField)
{
    var strVal = textField.value;
	
	if(strVal.length > 0)
	{
	    return true;
	} else {
	    return false;
	}
}

// *****************************
// *** validaTextoComTamanho ***
// *****************************
//
// Esta rotina verifica se a String strVal passada
// por parametro possui tamanho igual a strLen
// Se ok, retorna true
// Se ñ ok, retorna false
//
// Parametros -> Campo a ser verificado
// Retorno    -> true/false
// 
// DataCriacao: 2000/08/02
// Autor:       Marcelo Sequeiros
//
function validaTextoComTamanho(strVal, strLen)
{
	if(strVal.length == (strLen * 1))
	{
	    return true;
	} else {
	    return false;
	}
}

// ***************************
// *** validaCampoNumerico ***
// ***************************
//
// Esta rotina verifica se a String passada por parametro
// possui algum caracter naum numerico
// Se possuir valor 100% numerico, retorna true
// Se possuir algum caracter alfa, retorna false
//
// Parametros -> Campo a ser verificado
// Retorno    -> true/false
// 
function validaCampoNumerico(numField)
{
    var strVar = numField.value;
	
	for (var i = 0; i < strVar.length; i++)
	{
	    if (strVar.substring(i,i+1) < "0" || strVar.substring(i,i+1) > "9")
		{
	        return false;
		}
	}
	return true;
}



// ***************************
// *** validaLetraAlfabeto ***
// ***************************
//
// Esta rotina verifica se a String passada por parametro
// possui algum caracter naum numerico
// Se possuir valor 100% numerico, retorna true
// Se possuir algum caracter alfa, retorna false
//
// Parametros -> Campo a ser verificado
// Retorno    -> true/false
// 
function validaLetraAlfabeto(strField)
{
    var strVar = strField.value;
	
	for (var i = 0; i < strVar.length; i++)
	{
	    if (strVar.substring(i,i+1) < "a" || strVar.substring(i,i+1) > "Z")
		{
	        return false;
		}
	}
	return true;
}

// ***************************
// *** validaMascara (mascField) ***
// ***************************
//
// Esta rotina verifica se a String passada por parametro
// tem caracteres só do tipo '.', '-', '9', '@', 'A'
//
// Parametros -> Campo a ser verificado
// Retorno    -> true/false
// 
function validaMascara(strField)
{
    var strVar = strField.value;
	

	if(strVar.length == 0)
	{
	    return false;
	}


	for (var i = 0; i < strVar.length; i++)
	{
	    
	    if (strVar.substring(i,i+1) != "." && strVar.substring(i,i+1) != "-" && strVar.substring(i,i+1) != "9" && strVar.substring(i,i+1) != "A" && strVar.substring(i,i+1) != "@")
		{
			return false;
		}
	}

	return true;

}



// ***************************
// *** validaMascara (mascField,strField) ***
// ***************************
//
// Valida um campo de acordo com uma mascara
//
//   9 - Numérico.						
//   A - Letra do alfabeto.              
//   @ - Numérico ou Letra do alfabeto.  
//   Caracteres especiais: "." e "-"     
//   ex: 99.9AA.A@@-AA
//
//
// Parametros -> Mascara, Campo a ser verificado
// Retorno    -> true/false
// 
function validaMascara2(varMasc,strField)
{
    
	var varField = strField.value;

	if (varField.length != varMasc.length )
	{
		//alert('tam diferente!');
	    return false;
	}

	var charF = '';
	var charM = '';

	var iField = 0
	for (var iMasc = 0; iMasc < varMasc.length; iMasc++)
	{
		
		charF = varField.substring(iField,iField+1)
	    charM = varMasc.substring(iMasc,iMasc+1);

		//alert('Field:' + charF + ' Masc:' + charM );

		    if (charM== ".") 
		    {
			    if (charF != ".")
			    {
					//alert('.');
			    	return false;	
			    }	
			}

		    if (charM== "-") 
		    {
			    if (charF != "-")
			    {
					//alert('-');
			    	return false;	
			    }	
			}


			// valida número
		    if (charM== "9") 
		    {
			    if (charF < "0" || charF > "9")
			    {
					//alert('9-err');
			    	return false;	
			    }	
			}

			// Valida Letra
		    if (charM== "A") 
		    {
			    
			    if (charF < "a" || charF > "z") 
			    {
				    if (charF < "A" || charF > "Z") 
				    {
						//alert('A-errsdf');
				    	return false;	
				    }	
			    }	
			}

			// Valida Letra ou número
		    if (charM== "@") 
		    {


		    if (charF < "0" || charF > "9")
		    {
			    if (charF < "a" || charF > "z") 
			    {
				    if (charF < "A" || charF > "Z") 
				    {
						//alert('@-errsdf');
				    	return false;	
				    }	
			    }	
		    }	



			}

	iField++;

	} // fim for

	return true;

}



// ***************************
// *** formataMascara (mascField,strField) ***
// ***************************
//
// Valida um campo de acordo com uma mascara
//
//   9 - Numérico.						
//   A - Letra do alfabeto.              
//   @ - Numérico ou Letra do alfabeto.  
//   Caracteres especiais: "." e "-"     
//   ex: 99.9AA.A@@-AA
//
//
// Parametros -> Mascara, Campo a ser verificado
// Retorno    -> true/false
// 
function formataMascara(varMasc,strField)
{
    
	var varField = strField.value;

	var aux = varMasc
    myRE1     = /\./g;
    myRE2     = /\-/g;
    aux  = aux.replace(myRE1, "");
    aux  = aux.replace(myRE2, "");
    


	var aux2 = varField
    aux2  = aux2.replace(myRE1, "");
    aux2  = aux2.replace(myRE2, "");

    

	var novaStr = '';

	if ((varField.length == aux.length ) && (aux2.length  == varField.length ))
	{

		var charF = '';
		var charM = '';
		var iField = 0;
	
		for (var iMasc = 0; iMasc < varMasc.length; iMasc++)
		{
			
			charF = varField.substring(iField,iField+1);
		    charM = varMasc.substring(iMasc,iMasc+1);
	
			//alert('Field:' + charF + ' Masc:' + charM );
	
			    if ( (charM != ".") && (charM != "-") )
			    {
					novaStr = novaStr + charF;
					iField++;
				}
				else
			    {
					novaStr = novaStr + charM;
				}
				
				
	
		} // fim for
	
		strField.value = novaStr; 

	}


}





// ***************************
// *** possuiCaracterAlfa ***
// ***************************
//
// Esta rotina verifica se a String passada por parametro
// possui algum caracter alfa
// Se possuir algum abc..., retorna true
// Se possuir somente numeros, retorna false
//
// Parametros -> string a ser verificada
// Retorno    -> true/false
// 
// DataCriacao: 2000/08/03
// Autor:       Marcelo Sequeiros
//
function possuiCaracterAlfa(strVar)
{
	var retval = false;
	for (var i = 0; i < strVar.length; i++)
	{
	    if (strVar.substring(i,i+1) < "0" || strVar.substring(i,i+1) > "9")
		{
	        retval = true;
	    	break;
		}
	}
	return retval;
}	

// ******************
// *** validaMail ***
// ******************
//
// Esta rotina verifica o formato do mail fornecido
// ela naum verifica se o email estah correto,
// mas evita que valores absurdos sejam passados
// false significa que naum eh valido, true que eh valido
//
// Parametros -> Campo a ser verificado
// Retorno    -> true/false
//
// DataCriacao: 2000/08/02
// Autor:       Marcelo Sequeiros
//
function validaMail(mailField)
{
    var strMail = mailField.value;
	var Parte;
	var Partes;
	var Contador;
	var Temp;
	
	if(strMail.indexOf(" ") >= 0)
	{
		return false;
	} else {
		Contador = 0;
		Partes = strMail.split("@");
		for(var i=0; i<Partes.length; i++)
		{
			if(Partes[i] == "")
			{
			    return false;
			} else {
                Contador++;
			}
		}
		if (Contador != 2)
		{
			return false;
		}

		Contador = 0;
		Temp = Partes[1];
		if((Temp.charAt(0) == ".") || (Temp.charAt(Temp.length) == "."))
		{
			return false;
	    } else {
			Partes = Temp.split(".");
			for(var j=0; j<Partes.length; j++)
			{
				if(Partes[j] == "")
				{
					return false;
				} else {
					Contador++;
				}
			}
			if (Contador < 2)
			{
				return false;
			}
			return true;
		}
	}
}

// *******************
// *** validaRadio ***
// *******************
//
// Esta rotina verifica se ao menos um dos radios
// do grupo esta selecionado. Caso sim, ela
// retorna o valor do radio selecionado, caso 
// nao, retorna false
//
// Parametros -> Grupo de Radios a ser verificado
// Retorno    -> value/false
//
// DataCriacao: 2000/08/02
// Autor:       Marcelo Sequeiros
//
// Modificação: 2001/08/30
// Autor:       Marcelo Sequeiros
function validaRadio(radioField) 
{
    var checkedButton = false;
    if(radioField)
    {
        var varRadio = radioField;
        if(varRadio.length)
        {
            for (i=0; i < varRadio.length; i++)
            {
                if (varRadio[i].checked == "1")
                {
                    checkedButton = varRadio[i].value;
                }
            }
        } else {
            if(varRadio.checked)
            {
                checkedButton = varRadio.value;
            }
        }
    }
    return checkedButton;
}

// ********************
// *** formataValor ***
// ********************
//
// Esta rotina recebe um numero por parametro
// e retorna ele formatado como 999.999.999,99
//
// Parametros -> float
// Retorno    -> string
//
// DataCriacao: 2000/08/02
// Autor:       Marcelo Sequeiros
//
function formataValor(num)
{
 
 

    // transforma o numero numa string e verifica se tem casas decimais
    
    var strNum = num.toString();
    
    
    for   (var i = (strNum.length-1); i >= 0; i--)
   
    {
    	if (strNum[i] == ".")
    		{var decimal=true}
    	else
        	{var decima=false}
    }   	
 
     
    // se tiver casas decimais, deixa só com dois digitos decimais e sem o ponto em strValor
    // se nao tiver casas decimais, adiciona dois digitos decimais ("00") sem o ponto strValor
    
    if (decimal==true)
    {
	    strAux = strNum.split(".");
    
    	if (strAux.length > 0)
    	    { 
    			strAux[0]=strAux[0]+ strAux[1].substring(0,2);
    		    strValor = strAux[0];
    		}
    }
   
    else    
   
   {
   		strValor = strNum + "00";   
   }  
     
    
    
    // insere a virgula antes dos dois ultimos numeros
    
    
    //Retira toda a pontuacao
    myRE1     = /\./g;
    myRE2     = /\,/g;
    strValor  = strValor.replace(myRE1, "");
    strValor  = strValor.replace(myRE2, "");
    
    //Adiciona a pontuacao brasileira
    var j     = 1;
    var Valor = "";
    for (var i = (strValor.length-1); i >= 0; i--)
    {
        if((((j - 3) % 3) == 0) && ((j - 3) != 0)) Valor = '.' + Valor;
        
        Valor = strValor.charAt(i) + Valor;
        if(j == 2)      Valor = ',' + Valor;
        j++;
    }
   
    // se o numero começar com vírgula, insere o "0" antes
    
    if (Valor[0] == ",")
    {
    	Valor =  "0" + Valor  ;
    }	
    
    return Valor
}






// ********************
// *** formataCodProcedimento ***
// ********************
//
// Esta rotina recebe uma string de data ex: '31021999' e formata para '31/02/1999'
//
// uso: onKeyUp="formataCodProcedimento(CPField)"  
//
function formataCodProcedimento(CPField) 
{
	if ((CPField.value.length == 8) && (!possuiCaracterAlfa(CPField.value)) )
	{
		CPField.value= CPField.value.substring(0,2) + '.' + CPField.value.substring(2,4) + '.' +  CPField.value.substring(4,7) + '-' + CPField.value.substring(7,8);   
	} 
}


// ********************
// *** formataData ***
// ********************
//
// Esta rotina recebe uma string de data ex: '31021999' e formata para '31/02/1999'
//
// uso: onKeyUp="formataData(this)"  
//
function formataData(dataField)
{
	if ((dataField.value.length == 8) && (!possuiCaracterAlfa(dataField.value)) )
	{
		dataField.value= dataField.value.substring(0,2) + '/' + dataField.value.substring(2,4) + '/' +  dataField.value.substring(4,8);   
	} 
}

// ********************
// *** formataData ***
// ********************
//
// Esta rotina recebe uma string de data ex: '31021999' e formata para '31/02/1999'
//
// uso: onKeyUp="formataData(this)"  
//
function formataHora(HoraField)
{
	if ((HoraField.value.length == 4) && (!possuiCaracterAlfa(HoraField.value)) )
	{
		HoraField.value= HoraField.value.substring(0,2) + ':' + HoraField.value.substring(2,4) ;   
	} 
}







// ******************
// *** validaData ***
// ******************
//
// Esta rotina recebe uma string representando uma data
// e retorna true caso a data esteja formatada corretamente
// (dd/mm/aaaa) e false caso a data seja inválida.
//
// Parametros -> data
// Retorno    -> true/msg de erro
//
// DataCriacao: 2000/08/02
// Autor:       Marcelo Sequeiros
//
function validaData(dateField)
{
    var strData = dateField.value;
	var mes, dia, ano, bissexto;
	var retval = false;
	var msg;
	if (strData != "")
	{
		if (strData.length != 10 || strData.substring(2,3)!="/" || strData.substring(5,6)!="/")
		{
			msg = "  Formato incorreto. Corrija para dd/mm/aaaa";
		} else {
			//guarda o mes em uma variavel
			mes = strData.substring(3,5);



			if ((!possuiCaracterAlfa(mes)) && parseInt(mes,10) > 0 && parseInt(mes,10) <= 12)
			{
				mes = parseInt(mes,10);
				ano=strData.substring(6,10);

				
				if ((!possuiCaracterAlfa(ano)) && parseInt(ano,10) >= 0000 && parseInt(ano,10) < 2200 ) 
				{
					if ((parseInt(ano,10) % 4) == 0) 
					{
						bissexto = 1;
					} else {
		            	bissexto = 0;
					}
					dia = strData.substring(0,2);
					if (!possuiCaracterAlfa(dia))
					{
		            	dia = parseInt(dia,10);
		            	if (((mes==1 || mes==3 || mes==5 || mes==7 || mes==8 || mes==10 || mes==12) && (dia >= 1 && dia <= 31)) ||
				               ((mes==4 || mes==6 || mes==9 || mes==11) && (dia >= 1 && dia <= 30)) ||
				               (mes==2 && dia >= 1 && dia <= (28 + bissexto))) 
						{
			               	retval = true;
		            	} else {
							msg = "  O dia fornecido para este mês e ano não é válido.";
						}
					} else {
						msg = "  O dia fornecido não é válido. Ele não pode conter valores não numéricos.";
					}
				} else {
					msg = "  O ano fornecido não é válido. Ele não pode conter valores alfa não numéricos ou ser >=2200.";
				}
			} else {
				msg = "  O mês fornecido não é válido. Ele deve estar entre 1 e 12.";
			}
		}
	} else {
		msg = "  O campo data está vazio."
	}
    
	


     if (retval==true)
      { return true; }
     else
      { return msg;  }
}



// ************************
// *** validaDataIngles ***
// ************************
//
// Esta rotina recebe uma string representando uma data
// e retorna true caso a data esteja formatada corretamente
// (dd/mm/aaaa) e false caso a data seja inválida.
//
// Parametros -> data
// Retorno    -> true/msg de erro
//
// DataCriacao: 2000/08/02
// Autor:       Marcelo Sequeiros
//
function validaDataIngles(dateField)
{
    var strData = dateField.value;
	var mes, dia, ano, bissexto;
	var retval = false;
	var msg;
	if (strData != "")
	{
		if (strData.length != 10 || strData.substring(2,3)!="/" || strData.substring(5,6)!="/")
		{
			msg = "Date with incorrect format. Please fill out as the example (dd/mm/yyyy)";
		} else {
			//guarda o mes em uma variavel
			mes = strData.substring(3,5);
			if ((!possuiCaracterAlfa(mes)) && parseInt(mes,10) > 0 && parseInt(mes,10) <= 12)
			{
				mes = parseInt(mes,10);
				ano=strData.substring(6,10);
				if ((!possuiCaracterAlfa(ano)) && parseInt(ano,10) >= 0000) 
				{
					if ((parseInt(ano,10) % 4) == 0) 
					{
						bissexto = 1;
					} else {
		            	bissexto = 0;
					}
					dia = strData.substring(0,2);
					if (!possuiCaracterAlfa(dia))
					{
		            	dia = parseInt(dia,10);
		            	if (((mes==1 || mes==3 || mes==5 || mes==7 || mes==8 || mes==10 || mes==12) && (dia >= 1 && dia <= 31)) ||
				               ((mes==4 || mes==6 || mes==9 || mes==11) && (dia >= 1 && dia <= 30)) ||
				               (mes==2 && dia >= 1 && dia <= (28 + bissexto))) 
						{
			               	retval = true;
		            	} else {
							msg = "The day you´ve given is not valid.";
						}
					} else {
						msg = "The day you´ve given is not valid. It must have only numbers.";
					}
				} else {
					msg = "The year you´ve given is not valid. It must have only numbers.";
				}
			} else {
				msg = "The year you´ve given is not valid. It must be between 01 and 12.";
			}
		}
	} else {
		msg = "You must fill out the date field."
	}
    
     if (retval==true)
      { return true; }
     else
      { return msg;  }
}



// ************************
// *** validaDataString ***
// ************************
//
// Esta rotina recebe uma string representando uma data
// e retorna true caso a data esteja formatada corretamente
// (dd/mm/aaaa) e false caso a data seja inválida.
//
// Parametros -> data
// Retorno    -> true/msg de erro
//
// DataCriacao: 2000/08/02
// Autor:       Marcelo Sequeiros
//
// Alterado por Roger Paixão em 2000/11/10
//
function validaDataString(strData)
{
	var mes, dia, ano, bissexto;
	var retval = false;
	var msg;
	if (strData != "")
	{
		if (strData.length != 10 || strData.substring(2,3)!="/" || strData.substring(5,6)!="/")
		{
			msg = "  Formato incorreto. Corrija para dd/mm/aaaa";
		} else {
			//guarda o mes em uma variavel
			mes = strData.substring(3,5);
			if ((!possuiCaracterAlfa(mes)) && parseInt(mes,10) > 0 && parseInt(mes,10) <= 12)
			{
				mes = parseInt(mes,10);
				ano=strData.substring(6,10);
				if ((!possuiCaracterAlfa(ano)) && parseInt(ano,10) >= 0000) 
				{
					if ((parseInt(ano,10) % 4) == 0) 
					{
						bissexto = 1;
					} else {
		            	bissexto = 0;
					}
					dia = strData.substring(0,2);
					if (!possuiCaracterAlfa(dia))
					{
		            	dia = parseInt(dia,10);
		            	if (((mes==1 || mes==3 || mes==5 || mes==7 || mes==8 || mes==10 || mes==12) && (dia >= 1 && dia <= 31)) ||
				               ((mes==4 || mes==6 || mes==9 || mes==11) && (dia >= 1 && dia <= 30)) ||
				               (mes==2 && dia >= 1 && dia <= (28 + bissexto))) 
						{
			               	retval = true;
		            	} else {
							msg = "  O dia fornecido para este mês e ano não é válido.";
						}
					} else {
						msg = "  O dia fornecido não é válido. Ele não pode conter valores não numéricos.";
					}
				} else {
					msg = "  O ano fornecido não é válido. Ele não pode conter valores alfa não numéricos.";
				}
			} else {
				msg = "  O mês fornecido não é válido. Ele deve estar entre 1 e 12.";
			}
		}
	} else {
		msg = "  O campo data está vazio."
	}
    
     if (retval==true)
      { return true; }
     else
      { return msg;  }
}
// ****************************
// *** criaDgVerificadorCPF ***
// ****************************
//
// Esta rotina recebe um CPF sem dg 
// calcula o dg e retorna
// Se o numero passado naum atender aos
// requisitos retorna false
//
// Parametros -> Campo a ser verificado
// Retorno    -> dg (99)/false
// 
// DataCriacao: 2000/08/02
// Autor:       Marcelo Sequeiros
//
function criaDgVerificadorCPF(strCPF)
{
    var dig_1 = 0;
    var dig_2 = 0;
    
    var controle_1  = 10;
    var controle_2  = 11;
    var lsucesso    = 1;
    
    var numero = strCPF;
    
    if(numero.length != 9)
    {
        return false;
    } else {
        for ( i=0 ; i < 9 ; i++) 
        {
            dig_1 = dig_1 + parseInt(numero.substring(i, i+1) * controle_1);
            controle_1 = controle_1 - 1;
        }

        resto = dig_1 % 11;
        dig_1 = 11 - resto;
        if ((resto == 0) || (resto == 1)) 
        {
            dig_1 = 0;
        }
        for ( i=0 ; i < 9 ; i++) 
        {
            dig_2 = dig_2 + parseInt(numero.substring(i, i + 1) * controle_2);
            controle_2 = controle_2 - 1;
        }
        dig_2 = dig_2 + 2 * dig_1;
        resto = dig_2 % 11;
        dig_2 = 11 - resto;
        if ((resto == 0) || (resto == 1)) 
        {
            dig_2 = 0;
        }
        dig_ver = dig_1 + "" + dig_2;
        
        return dig_ver;
    }
}

// *****************
// *** validaCPF ***
// *****************
//
// Esta rotina recebe um CPF
// e verifica atraves do dg 
// se ele eh valido.
// O CPF deve estar no formato 
// 999.999.999-99
//
// Parametros -> Campo a ser verificado
// Retorno    -> true/false
// 
// DataCriacao: 2000/08/02
// Autor:       Marcelo Sequeiros
//
function validaCPF(cpfField)
{
    var strCPF = cpfField.value;
    
    if (strCPF.length < 14)
    {
        //Naum estah corretamente pontuado, ou esta incompleto
        return false;
    }

    //Retira os pontos
    myRE   = /\./g;
    strCPF = strCPF.replace(myRE, "");
    
    if (strCPF.charAt(9) != '-')
    {
        //Naum estah corretamente pontuado, ou esta incompleto
        return false;
    }
    
    if (strCPF.length != 12)
    {
        //Naum estah completo
        return false;
    }
    
    var dg      = criaDgVerificadorCPF(strCPF.substring(0,9));
    var myDg    = strCPF.substring(10,12);
    if (dg == myDg)
    {
        return true;
    } else {
        return false;
    }
    //if ((criaDgVerificadorCPF(strCPF.substring(0,9)) == false) || 
    //    (criaDgVerificadorCPF(strCPF.substring(0,9)) != strCPF.substring(10,12)))
    //{
    //    return false;
    //} else {
    //    return true;
    //}
}

// ****************************
// *** criaDgVerificadorCGC ***
// ****************************
//
// Esta rotina recebe um CGC sem dg 
// calcula o dg e retorna
// Se o numero passado naum atender aos
// requisitos retorna false
//
// Parametros -> Campo a ser verificado
// Retorno    -> dg (99)/false
// 
// DataCriacao: 2000/08/04
// Autor:       Marcelo Sequeiros
//
function criaDgVerificadorCGC(strCGC) 
{
    numero = strCGC;
    dig_1  = 0;
    dig_2  = 0;
    controle_1 = 5;
    controle_2 = 6;

    if (numero.length != 12)
    {
        return false;
    } else {
        for ( i=0 ; i < 12 ; i++) 
        {
            dig_1       = dig_1 + parseFloat(numero.substring(i, i+1) * controle_1);
	        controle_1  = controle_1 - 1;
            if (i == 3) 
            {
                controle_1 = 9;
            }
        }
        resto = dig_1 % 11;
        dig_1 = 11 - resto;

        if ((resto == 0) || (resto == 1))
        {
 	        dig_1 = 0;
        }
        
        for ( i=0 ; i < 12 ; i++) 
        {
            dig_2 = dig_2 + parseInt(numero.substring(i, i+1) * controle_2);
	        controle_2 = controle_2 - 1;
            if (i == 4) 
            {
                controle_2 = 9;
            }
        }
        dig_2 = dig_2 + (2 * dig_1);
        resto = dig_2 %11;
        dig_2 = 11 - resto;
        
        if ((resto == 0) || (resto == 1))
        {
 	        dig_2 = 0;
        }
        
        dig_ver = dig_1 + "" + dig_2;
        
        return dig_ver;
    }
}

// *****************
// *** validaCGC ***
// *****************
//
// Esta rotina recebe um CGC
// e verifica atraves do dg 
// se ele eh valido.
// O CPF deve estar no formato 
// 99.999.999/9999-99
//
// Parametros -> Campo a ser verificado
// Retorno    -> true/false
// 
// DataCriacao: 2000/08/04
// Autor:       Marcelo Sequeiros
//
function validaCGC(cgcField)
{
    var strCGC = cgcField.value;
    
    if (strCGC.length < 18)
    {
        //Naum estah corretamente pontuado, ou esta incompleto
        return false;
    }

    //Retira os pontos
    myRE1   = /\./g;
    myRE2   = /\//g;
    strCGC  = strCGC.replace(myRE1, "");
    strCGC  = strCGC.replace(myRE2, "");
    
    if (strCGC.charAt(12) != '-')
    {
        //Naum estah corretamente pontuado, ou esta incompleto
        return false;
    }
    
    if (strCGC.length != 15)
    {
        //Naum estah completo
        return false;
    }
    
    if ((criaDgVerificadorCGC(strCGC.substring(0,12)) == false) || 
        (criaDgVerificadorCGC(strCGC.substring(0,12)) != strCGC.substring(13,15)))
    {
        return false;
    } else {
        return true;
    }
}

// ****************************
// *** validaDataNascimento ***
// ****************************
//
// Esta rotina recebe uma data de nascimento
// e compara com a data de hoje. 
// Se a data de nascimento for anterior a de hoje
// retorna true, caso contrario retorna false.
//
// Parametros -> Campo a ser verificado
// Retorno    -> true/false
// 
// DataCriacao: 2000/08/07
// Autor:       Marcelo Sequeiros
//
function validaDataNascimento(dateField)
{ 
    //transforma para o formato JP sem formatacao
    var dataNasc    = new Date();
    var today       = new Date();
	
	
    dataNasc.setYear(dateField.value.substring(6,10));
    dataNasc.setMonth(dateField.value.substring(3,5)-1);
    dataNasc.setDate(dateField.value.substring(0,2));

	var msg = validaData(dateField)
	
	
    if(msg == true)
    {
        
        if(dataNasc > today)
        {
            return "  Data digitada superior a data atual.";
        } else {
            return true;
        }            
    } else {
        return msg;
    }
}



// ****************************
// *** validaDataCasamento ***
// ****************************
//
// Esta rotina recebe uma data de nascimento
// e compara com a data de hoje. 
// Se a data de nascimento for anterior a de hoje
// retorna true, caso contrario retorna false.
//
// Parametros -> Campo a ser verificado
// Retorno    -> true/false
// 
// DataCriacao: 2000/08/07
//
function validaDataCasamento(dateField)
{ 
    //transforma para o formato JP sem formatacao
    var dataCasam    = new Date();
    var today       = new Date();
	
	
    dataCasam.setYear(dateField.value.substring(6,10));
    dataCasam.setMonth(dateField.value.substring(3,5)-1);
    dataCasam.setDate(dateField.value.substring(0,2));

	var msg = validaData(dateField)
	
	
    if(msg == true)
    {
        
        if(dataCasam < today)
        {
            return "  Data digitada anterior a data atual.";
        } else {
            return true;
        }            
    } else {
        return msg;
    }
}





// **********************************
// *** validaDataNascimentoIngles ***
// **********************************
//
// Esta rotina recebe uma data de nascimento
// e compara com a data de hoje. 
// Se a data de nascimento for anterior a de hoje
// retorna true, caso contrario retorna false.
//
// Parametros -> Campo a ser verificado
// Retorno    -> true/false
// 
// DataCriacao: 2000/08/07
// Autor:       Marcelo Sequeiros
//
function validaDataNascimentoIngles(dateField)
{ 
    //transforma para o formato JP sem formatacao
    var dataNasc    = new Date();
    var today       = new Date();
	
	
    dataNasc.setYear(dateField.value.substring(6,10));
    dataNasc.setMonth(dateField.value.substring(3,5)-1);
    dataNasc.setDate(dateField.value.substring(0,2));

	var msg = validaDataIngles(dateField)
	
	
    if(msg == true)
    {
        
        if(dataNasc > today)
        {
            return "The date you´ve given is not correct.";
        } else {
            return true;
        }            
    } else {
        return msg;
    }
}


// *******************
// *** validaMoney ***
// *******************
//
// Esta rotina recebe um campo 
// numerico e verificasua formatacao. 
//  a) 999.999.999,99   retorna 1
//  b) 99999999999,99   retorna 2
//  c) 999,999,999.99   retorna 3
//  d) 99999999999.99   retorna 4
//  e) 99999999999999   retorna 5
//  f) 9..9999,99,9.9   retorna 0
//  g) asdfa3432rasff   retorna 0
//
// Parametros -> Campo a ser verificado
// Retorno    -> integer
// 
// DataCriacao: 2000/08/07
// Autor:       Marcelo Sequeiros
//
function validaMoney(moneyField)
{
    var strMoney = moneyField.value;
    //identifica formatacao
    if(strMoney.lastIndexOf(",") == (strMoney.length - 3))
    {
        if(strMoney.indexOf(".") >= 0)
        {
            //valida caso a)
            for(var i = (strMoney.length - 1); i >= 0; i--)
            {
                if((((((strMoney.length-1) - i) - 6) % 4) == 0) && ((((strMoney.length-1) - i) - 6) >= 0))
                {
                    if(strMoney.charAt(i) != '.')
                        return 0;
                } else {
                    if(strMoney.charAt(i) == '.')
                        return 0;
                }
            }
            return 1;
        } else {
            //caso b)
            return 2;
        }
    } else if (strMoney.lastIndexOf(".") == (strMoney.length - 3)) {
        if(strMoney.indexOf(",") >= 0)
        {
            //valida caso c)
            for(var i = (strMoney.length - 1); i >= 0; i--)
            {
                if((((((strMoney.length-1) - i) - 6) % 4) == 0) && ((((strMoney.length-1) - i) - 6) >= 0))
                {
                    if(strMoney.charAt(i) != ',')
                        return 0;
                } else {
                    if(strMoney.charAt(i) == ',')
                        return 0;
                }
            }
            return 3;
        } else {
            //caso d)
            return 4;
        }
    } else if(possuiCaracterAlfa(strMoney) == false) {
        //caso e
        return 5;
    } else {
        return 0;
    }
}

// *******************
// *** formataFloat ***
// *******************
//
// Esta rotina recebe uma string
// e o codigo de formatacao do money
// olhar tb validaMoney
//
// Parametros -> string, integer
// Retorno    -> float/false
// 
// DataCriacao: 2000/08/08
// Autor:       Marcelo Sequeiros
//
function formataFloat(strNum, cod)
{
    var myRE1 = /\./g;
    var myRE2 = /\,/g;
    switch(cod)
    {
        case 1:
            //999.999.999,99
            strNum = strNum.replace(myRE1, "");
            strNum = strNum.replace(myRE2, ".");
            break;
        case 2:
            //99999999999,99
            strNum = strNum.replace(myRE2, ".");
            break;
        case 3:
            //999,999,999.99
            strNum = strNum.replace(myRE2, "");
            break;
        case 4:
            //99999999999.99
            break;
        case 5:
            //99999999999999
            strNum = strNum + ".00";
            break;
        default:
            return false;
    }
    return parseFloat(strNum);
}

// *****************
// *** validaCEP ***
// *****************
//
// Esta rotina recebe um campo de CEP
// e verifica se a formatacao esta
// correta. 99999-999
//
// Parametros -> campo a ser verificado
// Retorno    -> true/false
// 
// DataCriacao: 2000/08/14
// Autor:       Alan Warszawski
//
function validaCEP(cepField)
{
    var strCEP = cepField.value;

    if (strCEP.length != 9)
    {
        //Naum estah corretamente pontuado, ou esta incompleto
        return false;
    }

   if (strCEP.charAt(5) != '-')
    {
        //Naum estah corretamente pontuado, ou esta incompleto
        return false;
    }
 
	var NumPrincipal = strCEP.substring(0,5);
	var Digitos = strCEP.substring(6,9);

	if ((possuiCaracterAlfa(NumPrincipal))  || (possuiCaracterAlfa(Digitos)) )
	{
		return false;
	}	

    return true;
}

// ********************
// *** validaSenha  ***
// ********************
//
// Esta rotina recebe um campo TEXTO
// e verifica se o mesmo é composto por até 8 dígitos
// sem espaços nem acentos.
//
// Parametros -> campo a ser verificado
// Retorno    -> true/false
// 
// DataCriacao: 2000/09/18
// Autor:       Roger Paixão
//
function validaSenha (txt)
{
	var verificador = false;
	
	for (var i=0;i<txt.length;i++)
		
		 if (isNaN(txt.substring(i,i+1)))
			if (((txt.substring(i,i+1) >= 'A') && (txt.substring(i,i+1) <= 'Z')) ||
    			((txt.substring(i,i+1) >= 'a') && (txt.substring(i,i+1) <= 'z')))
				
				verificador = true;
				 
			    
			else
			   {	
				verificador = false;
				break;
				}
		else
			verificador = true;
	
	return verificador;
}

// **********************
// *** validaTelefone ***
// **********************
//
// Esta rotina recebe um campo TEXTO
// e verifica se o mesmo é composto por 6 a 18 dígitos,
// somente aceitando os caracteres numéricos, (, ), -, espaço e a letra X.
// Os caracteres (, ), e - só podem ocorrer uma vez cada um.
// O caracter X e espaço só podem ocorrer 2 vezes cada um.
// O caracter (, caso exista deve obrigatoriamente vir com um ) posterior correspondente
//
// Ex.: 55 021 2233-3333 (Internacional)
//      55 (021) 2233-3333 (Internacional) --> PIOR EXEMPLO
//      0XX21 2233-3333 (Regional)
//      2233-3333 (Local)
//
// Parametros -> campo a ser verificado
// Retorno    -> true/false
// 
// DataCriacao: 2000/10/06
// Autor:       Roger Paixão
//
function validaTelefone (txt)
{
	// Constantes p/ Veriguação
	var minChar = 6;
	var maxChar = 18;
	var maxUnusual = 1;
	var maxX = 2;
	var maxSpace = 2;
	var minNum = 6;
	var maxNum = 13;

	// Inicialização de Variáveis de Controle
	var iNum=0, iSpace=0, iOpenBrackets=0, iposOpenBrackets=0, iCloseBrackets=0, iposCloseBrackets=0, iMinus=0, iX=0;
	var ch;
	var LEN = txt.length;

	// Checa tamanho mínimo e máximo
	if (LEN < minChar || LEN > maxChar)
		return false;
	
	// Varre toda a string
	for (var i = 0; i < LEN; i++)
	{
		ch = txt.substring(i,i+1);
		if (ch >= "0" && ch <= "9")
			iNum++
		else
			if (ch == " ")
				iSpace++
			else
				if (ch == "X")
					iX++
				else
					if (ch == "(")
					{
						iposOpenBrackets = i;
						iOpenBrackets++;
					}
					else
						if (ch == ")")
						{
							iposCloseBrackets = i;
							iCloseBrackets++;
						}
						else
							if (ch == "-")
								iMinus++
							else
								return false;
	}
	
	if (iOpenBrackets > maxUnusual ||
		iCloseBrackets  > maxUnusual ||
		iMinus  > maxUnusual ||
		iposOpenBrackets > iposCloseBrackets ||
		iNum < minNum ||
		iNum > maxNum ||
		iX > maxX ||
		iSpace > maxSpace)
		return false
	else
		return true;
}

// ****************************
// *** possuiCaracterEspaco ***
// ****************************
//
// Esta rotina verifica se a String passada por parametro
// possui algum caracter alfa
// Se possuir algum caracter de espaço, retorna true
// caso contrário retorna false
//
// Parametros -> string a ser verificada
// Retorno    -> true/false
// 
// DataCriacao: 2000/10/24
// Autor:       Alan Warszawski
//
function possuiCaracterEspaco(strVar)
{
	var retval = false;
	for (var i = 0; i < strVar.length; i++)
	{
	    if (strVar.substring(i,i+1) == " ")
		{
	        retval = true;
	    	break;
		}
	}
	return retval;
}	

// *********************
// *** retornaSelect ***
// *********************
//
// Esta funcao retorna o valor selecionado
// em um select box fornecido como 
// parametro
//
// Parametros -> campo select
// Retorno    -> valor
// 
// DataCriacao: 2000/11/06
// Autor:       Marcelo Sequeiros
//
function retornaSelect(selectField)
{
    if(retornaBrowser() == "IE")
    {
        return selectField.value;
    } else {
        return selectField.options[selectField.selectedIndex].value;
    }
}	

// ************************
// *** validaHoraString ***
// ************************
//
// Esta rotina recebe uma string representando uma hora
// e retorna true caso a hora esteja formatada corretamente
// (hh:mm) e false caso a data seja inválida.
//
// Parametros -> data
// Retorno    -> true/false
//
// DataCriacao: 2000/12/04
// Autor:       Roger Paixão
//
function validaHoraString(strHora) {
	var hora, minuto;
	var retval = false;
	hora = strHora.substring(0,2);
	minuto = strHora.substring(3,5);

	if (strHora.length == 5 && strHora.substring(2,3) == ":")
		if (!possuiCaracterAlfa(hora) && parseInt(hora,10) >= 0 && parseInt(hora,10) <= 23)
			if (!possuiCaracterAlfa(minuto) && parseInt(minuto,10) >= 0 && parseInt(minuto,10) <= 59)
				return true;
	return false;
}


// *********************
// *** compradaDatas ***
// *********************
//
// Esta rotina recebe 2 datas no formato "DD/MM/AAAA" tipo string
// e compara se a primeira é maior do que a segunda
// Caso positivo retorna true.
// Caso negativo retorna false.

// Parametros -> String da primeira data
// 				 String da segunda data
// Retorno    -> true/false
// 
// DataCriacao: 2001/01/12
// Autor: Alan Warszawski
//
function comparaDatas(strData1,strData2)
{ 
	
    //Transforma as datas do tipo String para o tipo data
    var data1    = new Date();
    var data2    = new Date();
    
    data1.setYear(strData1.substring(6,10));
    data1.setMonth(strData1.substring(3,5)-1);
    data1.setDate(strData1.substring(0,2));
    
    data2.setYear(strData2.substring(6,10));
    data2.setMonth(strData2.substring(3,5)-1);
    data2.setDate(strData2.substring(0,2));

	
    //Compra as datas
    if(data1 > data2)
    {
        return true;
    } else {
        return false;
    }            
}

// **********************
// *** retornaBrowser ***
// **********************
//
// Esta rotina retorna o browser onde esta rodando.
// caso o Browser seja o Internet Explorer, ela retornará
// a string IE, caso seja Netscape, retornará a string
// NETSCAPE, caso seja algum outro, retornará NA.
//
// Retorno    -> string (IE, NETSCAPE, NA)
// 
// DataCriacao: 2001/02/07
// Autor: Marcelo Sequeiros
//
function retornaBrowser()
{
    var browser = navigator.appName;
    if(browser.indexOf("Internet Explorer") >= 0)
    {
        return "IE";
    } else if (browser.indexOf("Netscape") >= 0) {
        return "NETSCAPE";
    } else {
        return "NA";
    }
}

// ******************************
// *** retornaBrowserPlatform ***
// ******************************
//
// Esta rotina retorna a plataforma do browser 
// onde esta rodando. Com esta rotina é possível
// identificar se a plataforma é Win32, Win16, 
// MAC, Linux, etc...
//
// Retorno    -> string 
// 
// DataCriacao: 2001/06/26
// Autor: Marcelo Sequeiros
//
function retornaBrowserPlatform()
{
    var plat = navigator.platform;
    if(plat.indexOf("Win") >= 0) 
    {
        return "Win";
    } else if(plat.indexOf("PPC") >= 0) {
        return "Mac";
    }
    return navigator.platform;
}

// **********************
// *** retornaWindows ***
// **********************
//
// Esta rotina retorna a versão do Windows onde o 
// browser esta rodando. Com esta rotina é possível
// identificar o SO se é Win95, Win98, WinNT.
//
// Retorno    -> string 
// 
// DataCriacao: 2001/06/26
// Autor: Marcelo Sequeiros
//
function retornaWindows()
{
    var win = navigator.appVersion;
    if(win.indexOf("NT") >= 0)
    {
        return "WinNT";
    } else if(win.indexOf("98") >= 0) {
        return "Win98";
    } else if(win.indexOf("95") >= 0) {
        return "Win95";
    } else {
        return "NA";
    }
}

// *****************
// *** showVideo ***
// *****************
//
// Esta rotina carrega o ActiveX da Real com o 
// vídeo recebido por parâmetro. Retorna TRUE.
// esta rotina deve ser usada em NETSCAPE
//
// DataCriacao: 2001/02/19
// Autor: Marcelo Sequeiros
//
function showVideo(URL)
{
    if(retornaBrowser() == "NETSCAPE")
    {
        var RealMode     = 0;
        var RealPlayer5  = 0;
        var RealPlayer4  = 0;
        var RealPlayerG2 = 0;
    
        var RealMode = 0;
    	numPlugins = navigator.plugins.length;
    	for (i = 0; i < numPlugins; i++) {
    		plugin = navigator.plugins[i];
    		if (plugin.name.substring(0,10) == "RealPlayer") {
    			RealMode = 1;
    		}
    	}
    	
    	var num = Math.random() + "";
    	var re  = /\./g;
    	num = num.replace(re, "");
        re = /\,/g;
        num = num.replace(re, "");    	
    	
        if (RealMode || RealPlayerG2 || RealPlayer5 || RealPlayer4) {
            document.write('<table border="0" cellspacing="0" cellpadding="0" bgcolor="#CCCCCC" width=190 height=158>');
            document.write('<tr>'); 
            document.write('<td><object id="RVOCX" classid="clsid:CFCDAA03-8BE4-11cf-B84B-0020AFBBCCFA" width=190 height=136>');
            document.write('<param name="SRC" value="' + URL + '">');
            document.write('<param name="CONTROLS" value="ImageWindow">');
            document.write('<param name="center" value="true">');
            document.write('<param name="backgroundcolor" value="#808080">');
            document.write('<param name="CONSOLE" value="video' + num + '">');
            document.write('<embed height=136 width=190 src="' + URL + '" type=audio/x-pn-realaudio-plugin nojava="true" center="true" backgroundcolor="#808080" console="' + num + '" controls="ImageWindow" pluginspage="http://www.real.com"></embed><embed height=26 width=44 type=audio/x-pn-realaudio-plugin nojava="true" console="' + num + '" controls="PlayButton"></embed><embed height=26 width=26 type=audio/x-pn-realaudio-plugin nojava="true" console="' + num + '" controls="StopButton"></embed><embed height=26 width=120 type=audio/x-pn-realaudio-plugin nojava="true" console="' + num + '" controls="PositionSlider"></embed> ');
            document.write('</object></td>');
            document.write('</tr>');
            document.write('<tr>');
            document.write('<td><object id="RVOCX" classid="clsid:CFCDAA03-8BE4-11cf-B84B-0020AFBBCCFA" width=44 height=26>');
            document.write('<param name="CONTROLS" value="PlayButton">');
            document.write('<param name="CONSOLE" value="video' + num + '">');
            document.write('</object><object id="RVOCX" classid="clsid:CFCDAA03-8BE4-11cf-B84B-0020AFBBCCFA" width=26 height=26>');
            document.write('<param name="CONTROLS" value="StopButton">');
            document.write('<param name="CONSOLE" value="video' + num + '">');
            document.write('</object><object id="RVOCX" classid="clsid:CFCDAA03-8BE4-11cf-B84B-0020AFBBCCFA" width=120 height=26>');
            document.write('<param name="CONTROLS" value="positionslider">');
            document.write('<param name="CONSOLE" value="video' + num + '">');
            document.write('</object></td>');
            document.write('</tr>');
            document.write('</table>');
        } else {
        	document.write('<table cellpadding="10" bgcolor="#eaeaea">');
        	document.write('<tr valign="middle" align="center">');
            document.write('<td><br>');
            document.write('<font face="Verdana, Arial, Helvetica, sans-serif" size="1" color="#666666"><b>Foi detectado que o plugin do Real Player n&atilde;o foi instalado em sua m&aacute;quina.<br>');
            document.write('Clique <a class="a" href="../plugins/lrginst.exe">aqui</a> para instalar a versão para PC e <a class="a" href="../plugins/playinst.sea">aqui</a> para instalar a versão para Mac.<br>');
            document.write('</b></font><br>');
            document.write('</td>');
            document.write('</tr></table>');
        }
    }
    
    return true;
}

// *****************
// *** showAudio ***
// *****************
//
// Esta rotina carrega o ActiveX da Real com o 
// audio recebido por parâmetro. Retorna TRUE.
// esta rotina deve ser usada em NETSCAPE
//
// DataCriacao: 2001/02/19
// Autor: Marcelo Sequeiros
//
function showAudio(URL)
{
    if(retornaBrowser() == "NETSCAPE")
    {
        var RealMode     = 0;
        var RealPlayer5  = 0;
        var RealPlayer4  = 0;
        var RealPlayerG2 = 0;
    
        var RealMode = 0;
    	numPlugins = navigator.plugins.length;
    	for (i = 0; i < numPlugins; i++) {
    		plugin = navigator.plugins[i];
    		if (plugin.name.substring(0,10) == "RealPlayer") {
    			RealMode = 1;
    		}
    	}
    	
    	var num = Math.random() + "";
    	var re  = /\./g;
    	num = num.replace(re, "");
        re = /\,/g;
        num = num.replace(re, "");    	
    	
        if (RealMode || RealPlayerG2 || RealPlayer5 || RealPlayer4) {
            document.write("<table border='0' cellspacing='0' cellpadding='0'>")
            document.write("<tr>")
            document.write("<td><object id=RVOCX classid='clsid:CFCDAA03-8BE4-11cf-B84B-0020AFBBCCFA' width=44 height=26>")
            document.write("<param name='SRC' value='" + URL + "'>")
            document.write("<param name='CONTROLS' value='PlayButton'>")
            document.write("<param name='CONSOLE' value='audio" + num + "'>")
            document.write("<embed height=26 width=44 src='" + URL + "' type=audio/x-pn-realaudio-plugin nojava='true' center='true' console='" + num + "' controls='PlayButton' pluginspage='http://www.real.com'></embed><embed height=26 width=26 type=audio/x-pn-realaudio-plugin nojava='true' console='" + num + "' controls='StopButton'></embed><embed height=26 width=120 type=audio/x-pn-realaudio-plugin nojava='true' console='" + num + "' controls='PositionSlider'></embed>")
            document.write("</object><object id=RVOCX classid='clsid:CFCDAA03-8BE4-11cf-B84B-0020AFBBCCFA' width=26 height=26>")
            document.write("<param name='CONTROLS' value='StopButton'>")
            document.write("<param name='CONSOLE' value='video" + num + "'>")
            document.write("</object><object id=RVOCX classid='clsid:CFCDAA03-8BE4-11cf-B84B-0020AFBBCCFA' width=120 height=26>")
            document.write("<param name='CONTROLS' value='positionslider'>")
            document.write("<param name='CONSOLE' value='audio" + num + "'>")
            document.write("</object></td>")
            document.write("</tr>")
            document.write("</table>")
        } else {
        	document.write('<table cellpadding="10" bgcolor="#eaeaea">');
        	document.write('<tr valign="middle" align="center">');
            document.write('<td><br>');
            document.write('<font face="Verdana, Arial, Helvetica, sans-serif" size="1" color="#666666"><b>Foi detectado que o plugin do Real Player n&atilde;o foi instalado em sua m&aacute;quina.<br>');
            document.write('Clique <a class="a" href="../plugins/lrginst.exe">aqui</a> para instalar a versão para PC e <a class="a" href="../plugins/playinst.sea">aqui</a> para instalar a versão para Mac.<br>');
            document.write('</b></font><br>');
            document.write('</td>');
            document.write('</tr></table>');
        }
    }
    
    return true;
}

// ********************
// *** showVideoMac ***
// ********************
//
// Esta rotina carrega o ActiveX da Real com o 
// vídeo recebido por parâmetro. Retorna TRUE.
// esta rotina deve ser usada em IE para MAC
//
// DataCriacao: 2001/02/19
// Autor: Marcelo Sequeiros
//
function showVideoMac(URL)
{
	document.write("<table cellpadding='10' bgcolor='#eaeaea'>");
	document.write("<tr valign='middle' align='center'>");
    document.write("<td><br>");
    document.write("<font face='Verdana, Arial, Helvetica, sans-serif' size='1' color='#666666'><b>Se você já possui o RealPlayer instalado em seu computador clique <A class='a' href='" + URL + "'>aqui</A>.<BR> Caso você não tenha o RealPlayer instalado, clique <a class='a' href='../plugins/playinst.sea'>aqui</a> para fazer o download.<br>");
    document.write("</b></font><br>");
    document.write("</td>");
    document.write("</tr></table>");
    
    return true;
}





// ***********************************
// *** validaTextoCaracterEspecial ***
// ***********************************
//
// Esta rotina verifica se a String passada por parametro
// possui tamanho superior a zero (0), ou possui algum caracter especial
// Se ok, retorna true
// Se ñ ok, retorna false
//
// Parametros -> Campo a ser verificado
// Retorno    -> true/false
// 
// DataCriacao: 2001/07/17
// Autor:       Alan Warszawski
//
function validaTextoCaracterEspecial(textField)
{
    var strVal = textField.value;
	
	if(strVal.length == 0)
	{
	    return false;
	}


	for (var i = 0; i < strVal.length; i++)
	{
	    if (strVal.charCodeAt(i)>255)
		{
			return false;	        
		}
	}
	return true;

}