//---------------------------------------------------------------------------------------------------------
// Nome:		LibValidaDados
// Descrição:	Arquivo de biblioteca de funções para Validação de Dados.
//---------------------------------------------------------------------------------------------------------

//---------------------------------------------------------------------------------------------------------
// Descrição das funções disponíveis neste arquivo:
//---------------------------------------------------------------------------------------------------------
// Nome						Descrição
//---------------------------------------------------------------------------------------------------------
// ComparaDatas				Retorna se data inicial é maior que data final.
//---------------------------------------------------------------------------------------------------------
// ValidaData				Retorna se data é válida (utiliza a função Bissexto e VerificaNumero).
//---------------------------------------------------------------------------------------------------------
// Bissexto					Retorna se ano é Bissexto.
//---------------------------------------------------------------------------------------------------------
// DataMaiorCorrente		Retorna se Data é maior que a Data Corrente.
//---------------------------------------------------------------------------------------------------------
// ValidaCEP				Retorna se Cep é válido.
//---------------------------------------------------------------------------------------------------------
// ValidaCPF				Retorna se CPF é válido.
//---------------------------------------------------------------------------------------------------------
// ValidaCNPJ				Retorna se CNPJ é válido.
//---------------------------------------------------------------------------------------------------------
// VerificaNumero			Retorna se Número é válido.
//---------------------------------------------------------------------------------------------------------
// ValidaTamanho			Retorna se Tamanho é válido.
//---------------------------------------------------------------------------------------------------------
// ValidaPreco				Retorna se Preço é válido.
//---------------------------------------------------------------------------------------------------------
// ValidaZero				Retorna se valor é zero.
//---------------------------------------------------------------------------------------------------------
// ValidaCampoVazio			Retorna se valor é igual a vazio (""), não trata espaço.
//---------------------------------------------------------------------------------------------------------
// ValidaCampoEmBranco		Retorna se valor é igual a vazio (""), trata espaço.
//---------------------------------------------------------------------------------------------------------
// CampoVazio				Retorna se campo é vazio.
//---------------------------------------------------------------------------------------------------------
// TamanhoTextArea			Permite digitar somente até um tamanho definido de caracteres.
//---------------------------------------------------------------------------------------------------------
// ValidaEmail				Retorna se e-mail é válido.
//---------------------------------------------------------------------------------------------------------
// ValidaHora				Função para validar se uma hora é válida e está no formato 
//---------------------------------------------------------------------------------------------------------
// ComparaHoras				Retorna verdadeiro se a HoraInicial for MENOR OU IGUAL a HoraFinal
//---------------------------------------------------------------------------------------------------------
// ComparaHoras3			Retorna verdadeiro se a HoraInicial for MENOR ou IGUAL a HoraFinal.
//---------------------------------------------------------------------------------------------------------
// ComparaHoras2			Retorna verdadeiro se a HoraInicial for MENOR a HoraFinal.
//---------------------------------------------------------------------------------------------------------
// NumeroPreenchido			Retorna true se o valor for NUMÉRICO e maior que ZERO.
//---------------------------------------------------------------------------------------------------------
// ValidaNumHora			Retorna VERDADEIRO se hora for válida no formato numérico HHMM.
//---------------------------------------------------------------------------------------------------------
// FormataNumHora			Retorna hora numérica (925 para 09:25 ou 092 para 09:20) formatada em hora comum (HH:MM).
//---------------------------------------------------------------------------------------------------------

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

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


//---------------------------------------------------------------------------------------------------------
// Retorna se data inicial é maior que data final.
//Deve validar as datas antes de chamar esta função.
function ComparaDatas(pData1, pData2, cFocus) 
{ 
	var parData1 = pData1.value;
	var parData2 = pData2.value;
  	
	// Pega dia inicial (DD).
	l_js_Dia1 = parData1.substring(0, parData1.indexOf("/"));
	sData1 = l_js_Dia1
	if (l_js_Dia1.length == 1)
	{
		sData1 = "0" + sData1;
	}
	
	// Pega mês inicial (MM).
	l_js_Mes1 = parData1.substring(parData1.indexOf("/")+1, parData1.lastIndexOf("/"));
	sData1 = l_js_Mes1 + sData1;
	if (l_js_Mes1.length == 1)
	{
		sData1 = "0" + sData1;
	}
	
	// Pega ano inicial (AAAA).
	l_js_Ano1 = parData1.substring(parData1.lastIndexOf("/")+1, parData1.length);
	sData1 = l_js_Ano1 + sData1;
	if (l_js_Ano1.length == 1)
	{
		sData1 = "0" + sData1;
	}

	// Pega dia final (DD).
	l_js_Dia2 = parData2.substring(0, parData2.indexOf("/"));
	sData2 = l_js_Dia2;
	if (l_js_Dia2.length == 1)
	{
		sData2 = "0" + sData2;
	}
	
	// Pega mês final (MM).
	l_js_Mes2 = parData2.substring(parData2.indexOf("/")+1, parData2.lastIndexOf("/"));
	sData2 = l_js_Mes2 + sData2;
	if (l_js_Mes2.length == 1)
	{
		sData2 = "0" + sData2;
	}
	
	// Pega ano final (AAAA).
	l_js_Ano2 = parData2.substring(parData2.lastIndexOf("/")+1, parData2.length);
	sData2 = l_js_Ano2 + sData2;
	if (l_js_Ano2.length == 1)
	{
		sData2 = "0" + sData2;
	}
	
	if (Math.abs(sData1) > Math.abs(sData2))
	{
		if (cFocus == 1)
		{
			pData1.focus();
		}
		if (cFocus == 2)
		{
			pData2.focus();
		}
		return false;
	}
	return true;
}
//---------------------------------------------------------------------------------------------------------
// Retorna se data é válida.
function ValidaData(pData)
{
	var l_js_Dia = 0;
	var l_js_Mes = 0;
	var l_js_Ano = 0;
  
	var parData = pData.value;
  
	// Verifica se é formato de data.
	if ((parData.indexOf("/") == -1) || (parData.indexOf("/") == parData.lastIndexOf("/")))
	{
		pData.focus();
		return false;
	}
	
	// Pega dia.
	l_js_Dia = parData.substring(0, parData.indexOf("/"));
	// Valida dia.
	if (ValidaNumero(l_js_Dia) == false)
	{
	  	pData.focus();
	  	return false;
	}
	
	// Pega mês.
	l_js_Mes = parData.substring(parData.indexOf("/")+1, parData.lastIndexOf("/"));
	// valida mês.
	if (ValidaNumero(l_js_Mes) == false)
	{
	  	pData.focus();
	  	return false;
	}
	
	// Pega ano.
	l_js_Ano = parData.substring(parData.lastIndexOf("/")+1, parData.length);
	// valida ano.
	if ((ValidaNumero(l_js_Ano) == false) || (l_js_Ano.length < 2) || (l_js_Ano.length > 4))
	{
	  	pData.focus();
	  	return false;
	}
	
	// Valida dia e mês.
	if (l_js_Mes == 0 || l_js_Mes > 12 || l_js_Dia == 0) {
		pData.focus();
		return false;
	}	
	else
	{
		// Se mês Abr, Set, Out ou Nov.	
		if (l_js_Mes == 4 || l_js_Mes == 6 || l_js_Mes == 9 || l_js_Mes == 11) 
		{
			// Valida dia.
			if (l_js_Dia > 30) {
				pData.focus();
				return false;
			}
		}
		else
		{
			// Se mês Fev.
			if (l_js_Mes == 2)
			{
				// Verifica se ano é Bissexto.
				if (Bissexto(l_js_Ano)) 
				{
					// Valida dia.
					if (l_js_Dia > 29)
					{
						pData.focus();
						return false;
					}
				}
				else
				{
					// Valida dia.
					if (l_js_Dia > 28)
					{
						pData.focus();
						return false;
					}
				}
			}
			else
			{
				// Valida dia.
				if (l_js_Dia > 31)
				{
					pData.focus();
					return false;
				}
			}
		}
	}
	return true;
}
//---------------------------------------------------------------------------------------------------------
// Retorna se ano é Bissexto.
function Bissexto(parAno) 
{
	if (parAno % 4 == 0)
	{
		return true;
	}
	else
	{
		return false;
	}
}
//---------------------------------------------------------------------------------------------------------
// Retorna se Data é maior que a Data Corrente.
// Deve validar data antes de chamar esta função.
function DataMaiorCorrente(parData)
{

	dtData = parData.value;

	// Pega dia.
	nDia = dtData.substring(0, dtData.indexOf("/"));
	
	// Pega mês.
	nMes = dtData.substring(dtData.indexOf("/")+1, dtData.lastIndexOf("/"));
	
	// Pega ano.
	nAno = dtData.substring(dtData.lastIndexOf("/")+1, dtData.length);
	
	D = new Date();
	diaCorrente = parseInt(D.getDate());
	mesCorrente = parseInt(D.getMonth()) + 1;
	anoCorrente = parseInt(D.getFullYear());
	
	if (nAno > anoCorrente)
	{
		parData.focus();
		return false;
	}
	
	if (((nAno == anoCorrente) || (nAno < anoCorrente)) && (nMes > mesCorrente))
	{
		parData.focus();
		return false;
	}

	if (((nAno == anoCorrente) || (nAno < anoCorrente)) && ((nMes == mesCorrente) || (nMes > mesCorrente)) && (nDia > diaCorrente))
	{
		parData.focus();
		return false;
	}
	
	return true;
}
//---------------------------------------------------------------------------------------------------------
// Retorna se Cep é válido.
function ValidaCEP(parNumero)
{
	if (!ValidaCampoEmBranco(parNumero))
	{
		return true;
	}
	if (parNumero.value.length != 10)
	{
		return false;
	}
	// 2 primeiros números.
	if (!ValidaNumero(parNumero.value.substring(0, 2)))
	{
		return false;
	}
	// 3 próximos números.
	if (!ValidaNumero(parNumero.value.substring(4, 6)))
	{
		return false;
	}
	// 3 últimos números.
	if (!ValidaNumero(parNumero.value.substring(7, 10)))
	{
		return false;
	}
		
	// Ponto.
	if (parNumero.value.substring(2, 3) != ".")
	{
		return false;
	}
	
	// Traço.
	if (parNumero.value.substring(6, 7) != "-")
	{
		return false;
	}
	
	return true;
}
//---------------------------------------------------------------------------------------------------------
// Deixa só os digitos no número. Para uso da ValidaCPF.
function LimpaString(parNumero)
{
	var l_js_Digitos = "0123456789";
	var l_js_Retorno = "";
	var l_js_Digito = "";
	for (var l_js_Contador=0; l_js_Contador < parNumero.length; l_js_Contador++) {
    l_js_Digito = parNumero.charAt(l_js_Contador);
    if (l_js_Digitos.indexOf(l_js_Digito) >= 0) {
			l_js_Retorno = l_js_Retorno + l_js_Digito
		}
  }
  return l_js_Retorno
}
//---------------------------------------------------------------------------------------------------------
// Retorna se CPF é válido.
function ValidaCPF(pNumero)
{
	var l_js_Contador;
		
	parNumero = pNumero.value;
		
	parNumero = LimpaString(parNumero);
	var l_js_Corpo = parNumero.substr(0, 9);
	var l_js_DV = parNumero.substr(9, 2);
	var d1 = 0;
	for (l_js_Contador = 0; l_js_Contador < 9; l_js_Contador++) 
	{
		d1 += l_js_Corpo.charAt(l_js_Contador)*(10 - l_js_Contador);
	}
	if (d1 == 0)
	{
		return false;
	}
	d1 = 11 - (d1 % 11);
	if (d1 > 9)
	{
		d1 = 0;
	}
	if (l_js_DV.charAt(0) != d1) 
	{
		return false;
	}

	d1 *= 2;
	for (l_js_Contador = 0; l_js_Contador < 9; l_js_Contador++)	
	{
		d1 += l_js_Corpo.charAt(l_js_Contador)*(11 - l_js_Contador);
	}
	d1 = 11 - (d1 % 11);
	if (d1 > 9)
	{
		d1 = 0;
	}
	if (l_js_DV.charAt(1) != d1) 
	{
		return false;
	}
	return true;
	
}
//---------------------------------------------------------------------------------------------------------
// Retorna se CNPJ é válido.
function ValidaCNPJ(pNumero)
{

	var parNumero = pNumero.value;

	var l_js_Contador;
	parNumero = LimpaString(parNumero);
	var l_js_Corpo = parNumero.substr(0,12);
	var l_js_DV = parNumero.substr(12,2);
	var d1 = 0;
	for (l_js_Contador = 0; l_js_Contador < 12; l_js_Contador++) 
	{
		d1 += l_js_Corpo.charAt(11 - l_js_Contador) * (2 + (l_js_Contador % 8));
	}
	if (d1 == 0)
	{
		return false;
	}
	d1 = 11 - (d1 % 11);
	if (d1 > 9)
	{
		d1 = 0;
	}
	if (l_js_DV.charAt(0) != d1) 
	{
		return false;
	}

	d1 *= 2;
	for (l_js_Contador = 0; l_js_Contador < 12; l_js_Contador++)	
	{
		d1 += l_js_Corpo.charAt(11 - l_js_Contador)*(2 + ((l_js_Contador+1) % 8));
	}
	d1 = 11 - (d1 % 11);
	if (d1 > 9) 
	{
		d1 = 0;
	}
	if (l_js_DV.charAt(1) != d1)
	{
		return false;
	}
	return true;
}
//---------------------------------------------------------------------------------------------------------
// Retorna se Número é válido.
function ValidaNumero(oValor)
{
	num = "0123456789";
	for (i = 0; i < oValor.length; i++)
	{
		sCaracter = oValor.substring(i, i+1);
		if (num.indexOf(sCaracter) < 0)
		{
			return false;
		}		
	}
	return true;
}
//---------------------------------------------------------------------------------------------------------
// Retorna se Número é válido (para Campos).
function VerificaNumero(oCampo)
{
	num = "0123456789";
	for (i = 0; i < oCampo.value.length; i++)
	{
		sCaracter = oCampo.value.substring(i, i+1);
		if (num.indexOf(sCaracter) < 0)
		{
			oCampo.focus();
			return false;
		}		
	}
	return true;
}
//---------------------------------------------------------------------------------------------------------
// Retorna se Tamanho é válido.
function ValidaTamanho(parObjeto, parTamanho)
{
	if (parObjeto.value.length > parTamanho)
	{
		parObjeto.focus();
		return false;
	}
	return true;
}
//---------------------------------------------------------------------------------------------------------
// Retorna se Preço é válido.
function ValidaPreco(oCampo, sDescricao)
{
	num = "0123456789,";
	for (i = 0; i < oCampo.value.length; i++)
	{
		sCaracter = oCampo.value.substring(i, i+1);
		if (num.indexOf(sCaracter) < 0)
		{			
			oCampo.focus();
			return false;
		}		
	}
	return true;
}
//---------------------------------------------------------------------------------------------------------
/*
Valida se um campo está preenchido com zero.
Retorna false se valor é for zero.
Testado 29 Jul 2002.
Exemplo:
	if (!ValidaZero(frmGeneric.txtNumero))
	{			
		alert('O campo Número deve ser preenchido!');
		return false;
	}
*/
function ValidaZero(oCampo)
{
	num = "0123456789";
	// Se não houver um caracter.
	if (oCampo.value.length == 0)
	{		
		oCampo.focus();
		return false;
	}

	// Se houver um caracter.
	if (oCampo.value.length == 1)
	{		
		if (oCampo.value == 0 || oCampo.value == "0" || oCampo.value == "")
		{		
			oCampo.focus();
			return false;
		}
		else
		{
			oCampo.focus();
			return true;		
		}
	}	
	
	// Se houver mais de um caracter (retira espaço).
	if (oCampo.value.length > 1)
	{
		sCaracter = ""
		for (i = 0; i < oCampo.value.length; i++)
		{
			if (oCampo.value != "")
			{
				sCaracter = sCaracter + oCampo.value.substring(i, i+1);			
			}
		}
		if (sCaracter <= 0)
		{		
			oCampo.focus();
			return false;
		}	
	}
	return true;
}
//---------------------------------------------------------------------------------------------------------
// Retorna se valor é igual a vazio (""), não trata espaço.
function ValidaCampoVazio(oCampo, sDescricao)
{
	if (oCampo.value == "")
	{
		oCampo.focus();
		return false;
	}
	else
		return true;
}
//---------------------------------------------------------------------------------------------------------
// Retorna se valor é igual a vazio (""), trata espaço.
function ValidaCampoEmBranco(oCampo)
{
	sValor = oCampo.value;
	x = 0;
	y = 1;
	nCont = 0;
	
	do 
	{
		sCaracter = sValor.substring(x, y);
		
		if (sCaracter == " ")
		{
			nCont = nCont + 1;
		}
		x++;
		y++;
	}
	while (y <= sValor.length)
	
	if (sValor.length == nCont)
	{
		oCampo.value = "";
		oCampo.focus();
		return false;
	}
	else
		return true;
	
}
//---------------------------------------------------------------------------------------------------------
// Retorna se campo é vazio.
// Retorna TRUE - se campo vazio e FALSE caso contrário.
function CampoVazio(pCampo)
{
 if (!(pCampo.replace(/ /g,'').length > 0))
 	return true;
 else
 	return false;
}
//---------------------------------------------------------------------------------------------------------
// Permite digitar somente até um tamanho definido de caracteres.

// Exemplo:
// <textarea name="txtDescr" OnKeyPress="TamanhoTextArea(frmGeneric.txtDescr,10);"></textarea>

function TamanhoTextArea(oTextArea,nMaxLength)
{
	if (oTextArea.value.length >= nMaxLength)
	{
		oTextArea.value = oTextArea.value.slice(0,nMaxLength);
		return;
	}
}
//---------------------------------------------------------------------------------------------------------
// Retorna se e-mail é válido.
function ValidaEmail(oEmail)
{
	txt = oEmail.value;

	// Existe @?
	if (txt.indexOf("@") == -1)
	{
		oEmail.focus();
		return false;
	}

	if (txt.indexOf("@") == txt.length - 1)
	{
		oEmail.focus();
		return false;
	}
		
	if (txt.length < 5)
	{		
		oEmail.focus();
		return false;
	}
		
	str = txt;
	var cont = 0;
	
	// Valida @
	if (str.indexOf("@") != str.lastIndexOf("@"))
	{
		oEmail.focus();
		return false;		
	}

	// Valida "."(ponto)
	//if (str.indexOf(".") != str.lastIndexOf("."))
	//{
	//	oEmail.focus();
	//	return false;		
	//}	
	
	return true;
}
//---------------------------------------------------------------------------------------------------------
// Função para validar se uma hora é válida e está no formato 
// hh:mm ou se é nula.	
var hr;
function ValidaHora(pHora)
{
	var fc_i;
	var fc_a1;
	var fc_str;
	var fc_CharsValidos = "0123456789";

	var hora = pHora.value;

	var fc_hora = hora.substring(0, 2);
	var fc_b1 = hora.substring(2, 3);
	var fc_minutos = hora.substring(3, 5);

	if (hora.length == 0) return(true);
	if (hora.length != 5)
	{
		pHora.focus();
		return(false);
	}

	hr = fc_hora + fc_minutos;
	for (fc_i=0; fc_i<=3; fc_i++) 
	{
		fc_a1 = hr.substring(fc_i, fc_i+1);
		fc_str = fc_CharsValidos.indexOf(fc_a1);
		if (fc_str==-1)
		{
			pHora.focus();
			return(false);
		}
	}

	if (fc_hora < 0 || fc_hora > 23)
	{
		pHora.focus();	
		return(false);
	}
	if (fc_b1 != ':')
	{
		pHora.focus();
		return(false);
	}
	if (fc_minutos < 0 || fc_minutos > 59)
	{
		pHora.focus();
		return(false);
	}

	return(true);
}
//---------------------------------------------------------------------------------------------------------
// Retorna verdadeiro se a HoraInicial for MENOR OU IGUAL a HoraFinal
// OBS: A funcao espera receber duas horas VALIDAS no formado: HH:MM.
function ComparaHoras(pHoraInicial,pHoraFinal,pFoco)
{
	var hr;
	var fc_i;
	var fc_a1;
	var fc_str;
	var fc_CharsValidos = "0123456789";

	var HoraInicial = pHoraInicial.value;
	var HoraFinal = pHoraFinal.value;

	var fc_hora_i = HoraInicial.substring(0, 2);
	var fc_minutos_i = HoraFinal.substring(3, 5);
	var fc_hora_f = HoraFinal.substring(0, 2);
	var fc_minutos_f = HoraFinal.substring(3, 5);

	if (fc_hora_f < fc_hora_i) 
	{
		if (pFoco == 1)
		{
			pHoraInicial.focus();
		}
		if (pFoco == 2)
		{
			pHoraFinal.focus();
		}
		return false;
	} 
	else 
	{
		if (fc_hora_i == fc_hora_f)	
		{
			if (fc_minutos_f < fc_minutos_i) 
			{
				if (pFoco == 1)
				{
					pHoraInicial.focus();
				}
				if (pFoco == 2)
				{
					pHoraFinal.focus();
				}
				return false;
			}
		}
	}
	return true;
}   
//---------------------------------------------------------------------------------------------------------


/*
Retorna verdadeiro se a HoraInicial for MENOR a HoraFinal.
OBS:
	- A funcao espera receber duas horas VÁLIDAS no formado: HH:MM.
	- Entende 00:00 como MEIA-NOITE.
*/
function ComparaHoras2(pHoraInicial,pHoraFinal,pFoco)
{
	var HoraInicial = pHoraInicial.value;
	var HoraFinal = pHoraFinal.value;

	var fc_hora_i = HoraInicial.substring(0, 2);
	var fc_minutos_i = HoraInicial.substring(3, 5);	
	
	var fc_hora_f = HoraFinal.substring(0, 2);		
	var fc_minutos_f = HoraFinal.substring(3, 5);

	var bTest = true;	
	// Se horas iguais.	
	if (fc_hora_f == fc_hora_i) 
	{
		// Testar minutos. Minuto final deve ser MAIOR que inicial.
		if (fc_minutos_f == fc_minutos_i) 
		{
			bTest = false;
		}
		else
		{
			if (fc_minutos_f < fc_minutos_i) 
			{
				bTest = false;
			}
		}
	}	
	else
	{
		// Se horas diferentes.
	
		// Hora final deve ser MAIOR que inicial. 00 representa MEIA-NOITE.
		if (fc_hora_f != 00 && fc_hora_f < fc_hora_i) 
		{
			bTest = false;
		}
	}
	if (!bTest)
	{
		// Problema.
		if (pFoco == 1 || pFoco == null || pFoco == "")
		{
			pHoraInicial.focus();
		}
		if (pFoco == 2)
		{
			pHoraFinal.focus();
		}
		return false;		
	}
	else
	{
		// Correto.
		return true;
	}	
}   
//---------------------------------------------------------------------------------------------------------
/*
Retorna verdadeiro se a HoraInicial for MENOR ou IGUAL a HoraFinal.
OBS:
	- A funcao espera receber duas horas VÁLIDAS no formado: HH:MM.
	- Entende 00:00 como MEIA-NOITE.
*/
function ComparaHoras3(pHoraInicial,pHoraFinal,pFoco)
{
	var HoraInicial = pHoraInicial.value;
	var HoraFinal = pHoraFinal.value;

	var fc_hora_i = HoraInicial.substring(0, 2);
	var fc_minutos_i = HoraInicial.substring(3, 5);
	var fc_hora_f = HoraFinal.substring(0, 2);
	var fc_minutos_f = HoraFinal.substring(3, 5);

	var bTest = true;	
	// Se horas iguais.
	if (fc_hora_f == fc_hora_i) 
	{
		// Testar minutos. Minuto final deve ser MAIOR ou IGUAL ao inicial.
		if (fc_minutos_f != fc_minutos_i) 
		{
			if (fc_minutos_f < fc_minutos_i) 
			{
				bTest = false;
			}
		}
	}	
	else
	{
		// Se horas diferentes.
	
		// Hora final deve ser MAIOR ou IGUAL ao inicial. 00 representa MEIA-NOITE.
		if (fc_hora_f != 00 && fc_hora_f < fc_hora_i) 
		{
			bTest = false;
		}
	}

	if (!bTest)
	{
		// Problema.
		if (pFoco == 1 || pFoco == null || pFoco == "")
		{
			pHoraInicial.focus();
		}
		if (pFoco == 2)
		{
			pHoraFinal.focus();
		}
		return false;		
	}
	else
	{
		// Correto.
		return true;
	}	
}   
//---------------------------------------------------------------------------------------------------------

/*
Retorna true se o valor for NUMÉRICO e maior que ZERO.
*/
function NumeroPreenchido(oCampo)
{
	var b = true;
	num = "0123456789";

	// Se não houver um caracter.
	if (oCampo.value.length == 0)
	{		
		oCampo.focus();
		return false;
	}
	
	// Verifica se valor é numérico.
	for (i = 0; i < oCampo.value.length; i++)
	{
		sCaracter = oCampo.value.substring(i, i+1);
		if (num.indexOf(sCaracter) < 0)
		{
			oCampo.focus();
			return false;						
		}		
	}

	// Se número é maior que zero.
	if ((oCampo.value + 0) == 0)
	{		
		oCampo.focus();
		return false;
	}

	return true;
}
//---------------------------------------------------------------------------------------------------------
/*
Nome: ValidaNumHora
Descrição: Retorna VERDADEIRO se hora for válida no formato numérico HHMM.
DICA: Para que a página aceite as duas formas de digitar horas (hh:mm ou hhmm),
teste o tamanho, se for < 5 utilize esta função para validar, senão utilize outra.
*/
function ValidaNumHora(oCampo)
{
	var hora, minuto;
	var b = true;
	var num = "0123456789";
	
	// Verificar se o valor do campo é numérico.
	for (i = 0; i < oCampo.value.length; i++)
	{
		sCaracter = oCampo.value.substring(i, i+1);
		if (num.indexOf(sCaracter) < 0)
		{			
			b = false;
		}		
	}

	// Se chegou até aqui como true o valor é numérico. Continue.
	if (b)
	{		
		if (oCampo.value.length == 3 || oCampo.value.length == 4)
		{
			// Pegue os valores.
			hora = oCampo.value / 100; // Coeficiente da divisão.
			minuto = oCampo.value % 100; // Resto da divisão.
			// Testa hora.
			if (hora < 0 || hora >= 24 || minuto < 0 || minuto > 59)
			{
				b = false;
			}
		}
		else
		{
			b = false;
		}
	}
	
	// Se função resultou verdadeiro ou falso.
	if (!b)
	{
		oCampo.focus();
		return false;
	}
	else
	{
		return true;
	}
}
//---------------------------------------------------------------------------------------------------------
/*
Nome: FormataNumHora
Descrição: Retorna hora numérica (925 para 09:25 ou 092 para 09:20) formatada em hora comum (HH:MM).
OBS: Suponhe-se que a hora numérica (parâmetro) seja válida (NÃO faz validação!).
*/
function FormataNumHora(oCampo)
{
	var hora = 0;
	var minuto = 0;
	
	// Verifique se hora é HHMM.
	if (oCampo.value.length == 4)
	{
		// Pegue os valores.
		hora = oCampo.value.substring(0,2); // Hora.
		minuto = oCampo.value.substring(2,4); // Minuto.
	}
	else
	{
		// Verifique se hora é HHM.
		if (oCampo.value.length == 3)
		{
			hora = oCampo.value.substring(0,2); // Hora.
			minuto = oCampo.value.substring(2,3); // Minuto.
		}
	}
	
	if (oCampo.value.length == 4 || oCampo.value.length == 3)
	{
		// Formata campo.
		if (hora.length == 1) { hora = "0" + hora;}
		if (minuto.length == 1) { minuto = minuto + "0";}
		return hora + ':' + minuto;
	}
	else
	{
		// Retorna mesmo valor do campo passado no parâmetro.
		return oCampo.value;
	}
}
//---------------------------------------------------------------------------------------------------------