// Compatibilizando o event.type para Mozilla
function MOZEventHandlers(_eventos)
{
	var i; 
	for (i=0; i< _eventos.length; i++)
	{
		document.addEventListener(_eventos[i], function(e){window.event = e;}, true);
	}
}
if(!document.all){MOZEventHandlers(["click","mousedown","mouseup","mouseover","mouseout","mousemove","keyup","keydown","load","focus","blur"]);}
//-->
function checaCPF(CPF)
{
    if (CPF=="") return true;

    if (CPF.length != 11 || CPF == "00000000000" || CPF == "11111111111" || CPF == "22222222222" || CPF == "33333333333" || CPF == "44444444444" || CPF == "55555555555" || CPF == "66666666666" || CPF == "77777777777" || CPF == "88888888888" || CPF == "99999999999")
	{
        return false;
	}
		
        soma = 0;
        for (i=0; i < 9; i ++)
                soma += parseInt(CPF.charAt(i)) * (10 - i);
        resto = 11 - (soma % 11);
        if (resto == 10 || resto == 11)
                resto = 0;
        if (resto != parseInt(CPF.charAt(9)))
                return false;
        soma = 0;
        for (i = 0; i < 10; i ++)
                soma += parseInt(CPF.charAt(i)) * (11 - i);
        resto = 11 - (soma % 11);
        if (resto == 10 || resto == 11)
                resto = 0;
        if (resto != parseInt(CPF.charAt(10)))
                return false;
        return true;
 }
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
function ChecaMaxText(ObjTextArea,Max) {
	if (ObjTextArea.value.length>Max){
		alert("A quantidade máxima de caracteres permitidas para este campo é de "+Max+" caracteres e foi excedido.\nO texto foi reduzido ao tamanho máximo, por favor confira.")
		ObjTextArea.value = ObjTextArea.value.substring(0,Max)
		ObjTextArea.focus();
	}
}
function ValidaCNPJ(CNPJ){
	if(CNPJ==""){
		return false;
	}
	if (CNPJ.length==14){
		CNPJcompleto = CNPJ;
		parte5 = CNPJ.substring(12,14);
	}else{	
		parte1 = CNPJ.substring(0,2);
		parte2 = CNPJ.substring(3,6);
		parte3 = CNPJ.substring(7,10);
		parte4 = CNPJ.substring(11,15);
		parte5 = CNPJ.substring(16,18);
		CNPJcompleto = parte1 + parte2 + parte3 + parte4 + parte5;
	}

	CNPJ1 = CNPJcompleto;
	CNPJ2 = parte5;
	fluxo = '543298765432';
	SOMA = 0;
	  
	for (i = 0; i <= CNPJ1.length; i++){ 
		SOMA = SOMA + CNPJ1.substring(i, i + 1) * fluxo.substring(i, i + 1);
	}  
	SOMA = SOMA * 10;
	digito1 = (SOMA % 11);
	  
	if (digito1 == 10){
		digito1 = 0;
	}  
	fluxo = '6543298765432';
	CNPJ1 = CNPJ1 + parseInt(digito1);
	SOMA = 0;
	for (i = 0; i <= CNPJ1.length; i++) {
		SOMA = SOMA + CNPJ1.substring(i, i + 1) * fluxo.substring(i, i + 1);
	}  
	SOMA = SOMA * 10;
	digito2 = (SOMA % 11);
	if (digito2 == 10){
		digito2 = 0;
	}  
	if (CNPJ2.substring(0,1) != digito1 || CNPJ2.substring(1,2) != digito2){
		return false;
	}else{
	    return true;
	}	    
}

function trim(string) {
	while (string.substring(0,1) == ' ') {
			string = string.substring(1,string.length);
	}
	while (string.substring(string.length-1,string.length) == ' ') {
			string = string.substring(0,string.length-1);
	}
	return string;
}
function FSNumeros(strPermissao){
	var	KeyCode = event.keyCode;
	var strPermitido = " KeyCode != 46 && KeyCode != 37 && KeyCode != 39 && KeyCode != 8 && KeyCode != 9  && KeyCode != 33 && KeyCode != 34 && KeyCode != 35 && KeyCode != 36 && KeyCode != 16 && KeyCode != 109 && KeyCode != 189";
	if (strPermissao != "")
	{
		if (strPermissao.indexOf(",") != -1){
			strPermissao = strPermissao.split(",");
			for(i=0; i < strPermissao.length; i++){
				strPermitido += " && KeyCode!= " + parseInt(strPermissao[i]);
			}
		}
		else
		{
			strPermitido += " && KeyCode!= " + parseInt(strPermissao);
		}
		strPermitido = eval(strPermitido);
		if ((KeyCode < 48 || KeyCode > 57) && (KeyCode < 96 || KeyCode > 105) && (strPermitido))
		{
			event.cancelBubble;
			event.returnValue= false;
			return false;
		}
	}
	else
	{
		if ((KeyCode < 48 || KeyCode > 57) && (KeyCode < 96 || KeyCode > 105) && (eval(strPermitido)))
		{
			event.cancelBubble;
			event.returnValue= false;
			return false;
		}
	}
//Valores para AlfaNumerico, Numerico
//Virgulas 188, 110
//Pontos 190,194
}
function FormataData(Campo, teclapres) 
{
	vr = Campo.value
	vr = vr.replace(".","")
	vr = vr.replace("-","")
	vr = vr.replace("/","")
	tam = vr.length + 1 


	if (teclapres!=9 && teclapres!=8 && teclapres!=111 && teclapres!=223 && teclapres!=47)
	{
		if (tam==3)
		{
			Campo.value = vr.substr(0,2) + '/' + vr.substr(5,tam)
		}
		if (tam==5)
		{
			Campo.value = vr.substr(0,2) + '/' + vr.substr(2,2) + '/' + vr.substr(5,tam)
		}
	}
}

function ValidaData(Data, Campo){
	Data = VerificaValue(Data);
	if (Data == "")
	{
		alert("Por favor, informe a Data.");
		Campo.focus();
	}
	else if ((Data.indexOf("/") < 2) || (Data.indexOf("/",3) < 5))
	{
		window.alert ('Informe o campo data no padrão dd/mm/aaaa.')
		Campo.focus();
		return false;
	} 
	else 
	{
		DataDia = Data.substring(0,2);
		DataMes = Data.substring(3,5);
		DataAno = Data.substring(6,10);
		if (isNaN(DataDia) == true || isNaN(DataMes) == true || isNaN(DataAno) == true)
		{
			alert('Data inválida.')
			Campo.focus();
			return false;
		}
		data = new Date();
		ano = data.getYear()
		if(DataAno < 1900){
			window.alert ('Ano inválido!')
			Campo.focus();
			return false;
		}
		if (DataMes > 12 || DataMes < 1)
		{
			window.alert ('Mês inválido.')
			Campo.focus();
			return false;
		}
		if (DataDia > 31 || DataDia < 1)
		{
			window.alert ('Dia inválido.')
			Campo.focus();
			return false;
		}
		if (DataMes==1)
		{
			ultdia = 31
		}
		if (DataMes==2)
		{
			if ((DataAno % 4) == 0)
			{
				ultdia = 29
			} 
			else 
			{
				ultdia = 28
			}
		}
		if ((DataMes==3)||(DataMes==5)|| (DataMes==7)||(DataMes==8)||(DataMes==10)||(DataMes==12))
		{
			ultdia = 31
		}
		if ((DataMes==4)||(DataMes==6) || (DataMes==9) || (DataMes==11))
		{
			ultdia = 30
		}
		
		if (DataDia>ultdia)
		{
			window.alert ('Data inválida')
			Campo.focus();
			return false;
		}
				
		return true
	}
}
function LimpaForm(strPagina)
{
	window.location.href = strPagina; 
}
function insereZeroNaData(strData, idObj) {

	re = /[0-9]{1,2}\/[0-9]{1,2}\/[0-9]{4}/i;
	
	if (!re.test(strData))
		return;
	
	dia = strData.split("/")[0];
	mes = strData.split("/")[1];
	ano = strData.split("/")[2];
	
	re = /[0-9]{2}/i;
	
	if (!re.test(dia))
		dia = "0" + dia;
	
	if (!re.test(mes))
		mes = "0" + mes;
	
	strData = dia + "/" + mes + "/" + ano;
	
	try
	{
		idObj.value = strData;
	}
	catch(e)
	{
	}
	
	return strData;
	
}

//Permite utilização de vírgulas e números
function validaNumero() 
{
	if ((event.keyCode > 47 && event.keyCode < 59) || (event.keyCode == 44) || (event.keyCode == 46))
		return true;
	else
		return false;
}
//--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

//Verifica se uma data pode ser menor que a outra, pre-requisito: data no formato dd/mm/yyyy
function ValidaDiferencaData(DataMenor,DataMaior){
	var strData1 = DataMenor.substring(6,10) + DataMenor.substring(3,5) + DataMenor.substring(0,2);
	var strData2 = DataMaior.substring(6,10) + DataMaior.substring(3,5) + DataMaior.substring(0,2);
	if (strData1 <= strData2)
	{	
		return false;
	} 
	else
	{	
		return true;
	}
}
//--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

//Função para formatar moeda no javascript
function FormatNumber(strValor, lngCasasDecimais, blnCentavoComPonto, blnMoeda)
{
	var strValorDecimal = "";
	strValor = strValor.toString();
	
	//Formatando o conteudo inicialmente
	if( strValor.indexOf(",") != -1 && strValor.indexOf(".") != -1 )
	{
		strValor = strValor.replace(".","");
	}
	else if(strValor.indexOf(".") != -1)
	{
		strValor = strValor.replace(".", ",");		
	}
	
	if (strValor.indexOf(",") != -1)
	{
		strValorDecimal = strValor.split(",")[1];
		strValor = strValor.split(",")[0];
	}
	
	var lngTamanhoDecimal = strValorDecimal.length;
	if(lngTamanhoDecimal > lngCasasDecimais)
	{
		lngTamanhoDecimal = lngCasasDecimais;
		strValorDecimal = strValorDecimal.substr(0, lngCasasDecimais);
	}
	for(var i=0; i < parseInt(lngCasasDecimais)-lngTamanhoDecimal; i++)
	{
		strValorDecimal += "0";
	}
	strValor += "," + strValorDecimal;
	if(blnCentavoComPonto)
	{
		strValor = strValor.replace(",", ".");
	}
	if(blnMoeda)
	{
		strValor = "R$ " + strValor;
	}
	return strValor;
}
//--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

// Seleciona/Deseleciona Todos os checkes da pagina
var blnChkTodos = true
function MarcarTodos(strCaminhoCheck) 
{ 
	var objCheck = eval(strCaminhoCheck);
	if (objCheck != null) 
	{
		if (isNaN(objCheck.length))
		{
			objCheck.checked = blnChkTodos;
		}
		else 
		{
			for (j=0;j < objCheck.length; j++)	
			{
				objCheck[j].checked = blnChkTodos
			}
		}
	}
	else
	{
		alert("Não há registros para selecionar");
		return false;
	}
	blnChkTodos = !blnChkTodos 
}
//--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------


// Limpa os options da select
function LimpaOptionSelect(objSelect, blnNaoLimparUltimo )
{
	if ( blnNaoLimparUltimo )
	{
		var lngPrimeiro = 1
	}
	else
	{
		var lngPrimeiro = 0
	}
	
	for(var i = objSelect.options.length; i >= lngPrimeiro; i--) 
	{
		objSelect.options[i] = null;
	}
	
	if ( blnNaoLimparUltimo )
	{
		try
		{
			objSelect.focus();
		}
		catch(e)
		{
		}
	}
}
//--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

// Abrir 1 div Por vez (Veja os que estao abertos 
var strDivAtivo = "";
function AbrirDiv(strNome)
{
	try
	{
		if (strDivAtivo != "" )
		{
			document.getElementById(strDivAtivo).style.display='none';
		}
		
		if ( strDivAtivo != strNome )
		{
			strDivAtivo = strNome;
			document.getElementById(strNome).style.display='block';
		}
		else
		{
			strDivAtivo = "";
		}
	}
	catch(e)
	{
	}
}
//--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

function AbrirFecharDiv(strIdDiv)
{
	try
	{
		
		if ( document.getElementById(strIdDiv).style.display.toLowerCase() == 'none' )
		{
			document.getElementById(strIdDiv).style.display = '';
		}
		else
		{
			document.getElementById(strIdDiv).style.display = 'none';
		}
	}
	catch(e)
	{
	}
}

// Calcular o digito verificador modulo 11 de um valor
function DigitoModulo11 ( strValor )
{
	var lngSomatorio = 0;
	var lngResto;
	var lngPeso = 9;
	var i;
	
	for ( i = 0 ; i < strValor.length; i++ )
	{
		lngSomatorio = lngSomatorio + ( parseInt ( strValor.charAt( strValor.length - i - 1)  ) * lngPeso);
		lngPeso = lngPeso - 1;
		if ( lngPeso == 1 ) lngPeso = 9;
	}
	
	lngResto = lngSomatorio % 11;
	
	if ( lngResto == 10 )
	{
		return 0;
	}
	else
	{
		return lngResto;
	}
}
//--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

//Função para criar ou atualizar um cookie
function SetCookie( name, value, expires, path, domain, secure ){
	document.cookie = name + "=" + escape(value) + 
	((expires) ? "| expires=" + expires.toGMTString() : "") +
	((path) ? "| path=" + path : "") +
	((domain) ? "| domain=" + domain : "") +
	((secure) ? "| secure=" + secure : "");
}
//--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//Função para Buscar um Cookie
function GetCookie( name ){
	var NomeCookie = name + "=";
	var TamanhoNomeCookie = NomeCookie.length;
	var TamanhoCookie = document.cookie.length;
	var i = 0;
	while ( i < TamanhoCookie ){
		var j = i + TamanhoNomeCookie;
		if (document.cookie.substring( i, j ) == NomeCookie){
			var lngString = document.cookie.indexOf(";", j);
			if ( lngString == -1 ){
				lngString = document.cookie.length;
			}
			return unescape(document.cookie.substring(j, lngString));
		}
		i = document.cookie.indexOf(" ", i ) + 1;
		if ( i == 0 ) {
			break;
		}
	}
	return null;
}
//--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//função para deletar cookie
function DeleteCookie ( name, path, domain ) {
	if (GetCookie( name ) ) {
		document.cookie = name + "=" + 
		((path) ? "| path=" + path : "") +
		((domain) ? "| domain=" + domain : "") +
		"| expires= Thu, 01-Jan-70 00:00:01 GMT";
	}
}
//--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

function AbreInformacaoAlunoGestor(lngCodAluno, lngCodUsuarios_AcadCurso)
{
	var objJanela = window.open("/PerfilAluno.asp?CodUsuario=" + lngCodAluno + "&lngCodUsuarios_AcadCurso=" + lngCodUsuarios_AcadCurso + "&TipoUsuario=1","Perfil","width=420,height=350,scrollbars=yes,scrolling=yes");
	objJanela.focus();
}

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

//Desprezando a parte decimal de um número a partir do valor passado em lngCasas
function Trunc(lngNumero, lngCasas)
{
    return parseFloat( parseInt( lngNumero * Math.pow(10, lngCasas) ) / Math.pow(10, lngCasas) );
}

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

//Substituindo todas as ocorrências de uma string em outra
   
function replaceString(fullS,oldS,newS)
{
    // Replaces oldS with newS in the string fullS
    for (var i=0; i<fullS.length; i++) 
    {
        if (fullS.substring(i,i+oldS.length) == oldS) 
        {
            fullS = fullS.substring(0,i)+newS+fullS.substring(i+oldS.length,fullS.length)
        }
    }
    return fullS
}

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

// Exibindo uma mensagem de erro e retornando false
function retorno(obj, strMsg, blnSelecionar)
{
    alert(strMsg);
    try
    {
	SelecionaTexto(obj, blnSelecionar);
    }
    catch(e){}
    return false;
} 

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

// Verificando se a extensão é de imagem
function checkImagem(strNome)
{
    return checkExtensoes(".JPG .BMP .GIF .PNG", strNome);
}

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

//Obtendo a extensao de um arquivo
function checkExtensoes(strExtensoes, strNome)
{
    return strNome.length > 5 && strExtensoes.toUpperCase().indexOf(strNome.substr(strNome.lastIndexOf(".")).toUpperCase()) != -1;
}

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

//Verificando arquivos proibidos
function checkUpLoad(strNome)
{
    var strExtensoes = ".EXE .COM .VBS .ASA .ASP .APSX .ASMX .INC .SRC .ASCX";
    if ( checkExtensoes(strExtensoes, strNome) )
    {
        alert("As seguintes extensoes são inválidas:\n" + strExtensoes + ".");
        return false;  
    }
    return true; 
}

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

// Obtendo o valor do option selecionado em uma caixa de seleção
function getSelectedIndex(objID)
{
	var obj
	if (IsObject(objID))
	{
		obj = objID;
	}
	else
	{
		obj = document.getElementById(objID);
	}
	
	if (obj.tagName.toUpperCase != "INPUT")
	{
		return obj.value;
	}
	return obj.options[obj.selectedIndex].value;
}

// Atribuiodn o valor do option selecionado em uma caixa de seleção
function setSelectedIndex(objID, lngValor)
{
	for ( var i = 0 ; i < objID.options.length ; i ++ )
	{
		if ( objID.options[i].value == lngValor)
		{
			objID.selectedIndex = i;
			return false;
		}
	}
}

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


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

// Obtendo um atributo de um option em uma caixa de seleção
function getSelected(objID, strAtributo)
{
	try
	{
		return eval("objID.options[objID.selectedIndex].getAttribute('" + strAtributo + "');");
	}
	catch(e)
	{
		var obj = document.getElementById(objID);
		return eval("obj.options[obj.selectedIndex].getAttribute('" + strAtributo + "');");
	}
}

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

// Atribuindo o display para um objeto
function setDisplay(objID, strDisplay)
{
	try
	{
		return eval("objID.style.display='" + strDisplay + "';");
	}
	catch(e)
	{
		return eval("document.getElementById(objID).style.display='" + strDisplay + "';");
	}
}

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

// Verificando se um nome é um objeto
function VerificaValue(obj)
{
	if (obj.value == undefined)
	{
		return obj;
	}
	return obj.value;
}

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

// Invertendo data para comparação
function DataInvertida(strData)
{

	strValorData = VerificaValue(strData);

	if (strValorData == "")
	{
		return "19000101";
	}
	
	strValorData = insereZeroNaData(strValorData);
	return ( strValorData.substring(6, 10).toString() + strValorData.substring(5, 3).toString() + strValorData.substring(0, 2).toString() );
}

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

// Verificando se uma pessoa nascida em [strData] já tem [lngIdade] anos em [strDataAtual]
function ValidaIdadeMinima(strData, strDataAtual, lngIdade)
{
	var strDataMinima = parseInt(strDataAtual) - lngIdade * 10000;
	return ( parseInt(DataInvertida(strData)) <= strDataMinima);
}

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

// Adicionando dias a uma data
function AddDias(strData, lngNumDias)
{
	var strDataJS = new Date();
	strDataJS.setDate(strData.substring(0, 2));
	strDataJS.setMonth(strData.substring(5, 3).valueOf() -1);
	strDataJS.setFullYear(strData.substring(6, 10));
	strDataJS.setTime(strDataJS.getTime() + (lngNumDias * 86400000))
	return insereZeroNaData(strDataJS.getDate() + "/" + (strDataJS.getMonth() + 1) + "/" + strDataJS.getFullYear());
}

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

// Verificando se existe um objeto checado e retornando o valor
function getChecked(objName)
{
	var arrObj = document.getElementsByName(objName);
	for (var i = 0 ; i < arrObj.length ; i ++)
	{
		if ( arrObj[i].checked )
		{
			return arrObj[i].value;
		}
	}
	return null;
}

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

// Verificando se uma data está invertida
function VerificaDataInvertida(strData)
{
	if (strData.lastIndexOf("/") != -1 )
	{
		return DataInvertida(strData)
	}
	return strData
}

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

// Verificando se uma data está entre duas outras, com comparação parametrizada em strOp
function DataValida(strData, strDataMinima, strDataMaxima, strOp)
{
	var arrOp = strOp.split(",");
	var strValorData = VerificaDataInvertida(VerificaValue(strData));
	var strValorDataMinima = VerificaDataInvertida(VerificaValue(strDataMinima));
	var strValorDataMaxima = VerificaDataInvertida(VerificaValue(strDataMaxima));
	var blnDataValida = eval("strValorData " + arrOp[0] + " strValorDataMinima && strValorData " + arrOp[1] + " strValorDataMaxima;");
	return blnDataValida;
}

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

// Função que valida datas de vários períodos de tempo, de forma:
// datainicio1-datafim1;datainicio2-datafim2..., os objetos estão no array objDatas
// todo o período deve estar compreendido dentro dos objetos objDataInicio e obDataFim.
// O número de datas a serem validadas é passado em lngNumDatas
function ValidaPeriodos(strNameDatas, strNameDataInicio, strNameDataFim, lngNumDatas)
{
	var strMsg, strOp;
	var objDatas = document.getElementsByName(strNameDatas);
	var objDataInicio = document.getElementById(strNameDataInicio);
	var objDataFim = document.getElementById(strNameDataFim);

	// Validação das datas incial a final
	//*******************************************************
	if ( ! ValidarData(objDataInicio) || ! ValidarData(objDataFim) )
	{
		return false;
	}
		
	var strDataInicio = DataInvertida(objDataInicio);
	var strDataFim = DataInvertida(objDataFim);

	if (strDataFim <= strDataInicio) 
	{
		return retorno(objDataFim, "A data final deve ser posterior à data inicial.");
	}
	//*******************************************************
	
	// Validação da data inicial do primeiro período
	//*******************************************************
	if (! ValidarData(objDatas[0])) 
	{
		return false;
	}
	
	if ( ! DataValida(objDatas[0], strDataInicio, strDataFim, ">=,<="))
	{
		return retorno (objDatas[0], "Todas as datas devem estar entre as datas inicial e final.");
	}
	//*******************************************************

	// Validação das demais datas
	//*******************************************************
	for ( var i = 1 ; i < lngNumDatas- 1; i ++ )
	{
		if (! ValidarData(objDatas[i]) ) 
		{
			return false;
		}
		
		if (objDatas[i].name.lastIndexOf("Inicio") != -1)
		{
			strOp = ">,<=";
			strMsg = "A data inicial de cada período deve ser posterior à data final do período anterior \ne anterior ou igual à data final do mesmo período.";
		}
		else
		{
			strOp = ">=,<=";
			strMsg = "A data final de cada período deve ser posterior ou igual à data inicial do período \ne anterior ou igual à data final.";
		}
		if ( ! DataValida (objDatas[i], objDatas[i - 1], strDataFim, strOp) )
		{
			return retorno (objDatas[i], strMsg);
		}
		if (i == lngNumDatas - 2  )
		{
			if ( ! ValidarData(objDatas[ i + 1]) )
			{
				return false;
			}
			if ( DataInvertida(objDatas[i + 1]) > strDataFim)
			{
				return retorno (objDatas[i + 1], "A data final de cada período deve ser posterior ou igual à data inicial do período \ne anterior ou igual à data final.");
			}
		}
	}
	//*******************************************************
	return true;
}

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

// Função que valida hora e minutos
function ValidaHorario(objHora, objMinuto)
{
	if ( objHora.value == "" || objHora.value < 0 || objHora.value > 23 )
		return retorno ( objHora , "Por favor, preencha corretamente a hora (de 00 até 23)." );

	if ( objMinuto.value == "" || objMinuto.value < 0 || objMinuto.value > 59 )
		return retorno ( objMinuto , "Por favor, preencha corretamente os minutos (de 00 até 59)." );
	return true;
}

function MontaHorario(objData, objHora, objMinuto)
{
	return ( DataInvertida(objData) + VerificaValue(objHora).toString() + VerificaValue(objMinuto).toString() );
}

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

// Função que verifica se o horário anterior ocorre antes do horário posterior
function ComparaHorario(objDataAnterior, objHoraAnterior, objMinutoAnterior, objDataPosterior, objHoraPosterior, objMinutoPosterior)
{
	return (	MontaHorario(objDataAnterior, objHoraAnterior, objMinutoAnterior) < 
			MontaHorario(objDataPosterior, objHoraPosterior, objMinutoPosterior) )
}

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

function getObjID(strID)
{
	return ( document.getElementById(strID) );
}


function getObjName(strName)
{
	return ( document.getElementsByName(strName) );
}
//--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

// JScript File

//-----------------------------------------------------
//Funcao: MascaraMoeda
//Sinopse: Mascara de preenchimento de moeda
//Parametro:
//   objTextBox : Objeto (TextBox)
//   SeparadorMilesimo : Caracter separador de milésimos (.)
//   SeparadorDecimal : Caracter separador de decimais (,)
//   e : Evento (event)
//Retorno: Booleano
//-----------------------------------------------------
function MascaraMoeda(objTextBox, SeparadorMilesimo, SeparadorDecimal, e)
{               
	if (objTextBox.value.length <= objTextBox.maxLength)
	{
	    var sep = 0;
	    var key = '';
	    var i = j = 0;
	    var len = len2 = 0;
	    var strCheck = '0123456789';
	    var aux = aux2 = '';
	    if ( e != undefined )
	    { 
		    var whichCode = (window.Event) ? e.which : e.keyCode;
		    if (whichCode == 13)
		    {
			    return true;
		    }
		    key = String.fromCharCode(whichCode); // Valor para o código da Chave
		    if (strCheck.indexOf(key) == -1)
		    {
			    return false; // Chave inválida
		    }
	    }
    	
	    len = objTextBox.value.length;
	    for(i = 0; i < len; i++)
	    {
		    if (objTextBox.value.charAt(i) != '0' && objTextBox.value.charAt(i) != SeparadorDecimal)
		    {
			    break;
		    }
	    }
	    aux = '';
	    for( ; i < len; i++)
	    {
		    if ( strCheck.indexOf(objTextBox.value.charAt(i)) != -1 )
		    {
			    aux += objTextBox.value.charAt(i);
		    }
	    }
	    aux += key;
	    len = aux.length;
	    switch (len)
	    {
		    case 0 :	objTextBox.value = ''; 
				    break;
		    case 1 :	objTextBox.value = '0'+ SeparadorDecimal + '0' + aux; 
				    break;
		    case 2 :	objTextBox.value = '0'+ SeparadorDecimal + aux; 
				    break
		    default:	aux2 = '';
				    for (j = 0, i = len - 3; i >= 0; i--) 
				    {
					    if (j == 3)
					    {
						    aux2 += SeparadorMilesimo;
						    j = 0;
					    }
					    aux2 += aux.charAt(i);
					    j++;
				    }
				    objTextBox.value = '';
				    len2 = aux2.length;
				    for (i = len2 - 1; i >= 0; i--) 
				    {
					    objTextBox.value += aux2.charAt(i);
				    }
				    objTextBox.value += SeparadorDecimal + aux.substr(len - 2, len);
	    }
	} 
	return false;
}

function LimpaMascara(objTextBox, SeparadorMilesimo, SeparadorDecimal)
{
	return objTextBox.value.replace(SeparadorMilesimo, "").replace(SeparadorDecimal, ".");
}

// Função que desabilita/habilita elementos de uma página pelo tagname e atributo específico
function DesabilitarElementos(strTagName, strAtributo, strValorAtributo, blnDisabled)
{
		var arrElement = document.getElementsByTagName(strTagName);
		for ( var i = 0 ; i < arrElement.length ; i ++ )
		{
			if ( arrElement[i].getAttribute(strAtributo) == strValorAtributo)
			{
				arrElement[i].disabled = blnDisabled;
			}
		}
}

// Função que seleciona um texto em um elemento input text
function SelecionaTexto(objText, blnSelecionar)
{
	objText.focus();
	if ( blnSelecionar == false )
	{
		return false
	}
	if ( objText.value != "" )
	{
		var objRange = objText.createTextRange();
		objRange.findText(objText.value);
		objRange.select();
	}
}

// Função que verifica se o elemento é um objeto ou nao
    function IsObject ( strConteudo )
    {
        var blnRetorno = false;
        try
        {
           if (strConteudo != null) 
                if (typeof strConteudo == "object") 
                    blnRetorno = true;
        }
        catch(e)
        {
        }
        finally
        {
            return blnRetorno;
        }
    }    

//função para validar campos que são somente numéricos
	function ValidaCampoNumerico(obj,campo)
	{  	    	    
	    var retorno = true;
	    var numero = obj.value.replace(".","");
		if( isNaN(numero.replace(",",".")))
        {	        
			alert("Preencha o campo " + campo + " somente com valores númericos.");
			obj.value = "";
			obj.focus();	        
			retorno = false;	        
        }
         
        return retorno; 
	}

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