var pagStrErro='';
var pagStrBotao='';

/***********************************************************************
* Função fnEvnRejeitaChar()
*
* Descrição: 	Rejeita caracteres especificados em lista,
*				separados por · (ASCII alt + 250)
* Chamada:		onKeyPress="javascript:return fnEvnRejeitaChar();"
************************************************************************/
function fnEvnRejeitaChar(peStrCharList)
{
	var locBitRetorno = true;
	var peCharEntrada = String.fromCharCode(event.keyCode);

	var locVetCharRejeitado = peStrCharList.split('·');

	for (i=0; i<locVetCharRejeitado.length; i++)
	{
		if(peCharEntrada == locVetCharRejeitado[i])
		{
			locBitRetorno = false;
			break;
		}
	}

	if (locBitRetorno)
	{
		return true;
	}
	else
	{
		event.keyCode = 0;
		return false;
	}
}


/***********************************************************************
* Função fnEvnEntradaTMA()
*
* Descrição: 	Controla a máscara para campos de valores do tipo moeda
*
* Chamada:		onKeyPress="javascript:return fnEvnEntradaMoeda();"
************************************************************************/
function fnEvnEntradaTMA(peStrCampo, peStrMil, peStrDec, peMaxCampo)
{
	e = event;

	var sep = 0;
	var key = '';
	var i = j = 0;
	var len = len2 = 0;
	var strCheck = '0123456789';
	var aux = aux2 = '';
	var whichCode = (window.Event) ? e.which : e.keyCode;

	if (whichCode == 13) return true;  // Enter
	key = String.fromCharCode(whichCode);  // Get key value from key code
	if (strCheck.indexOf(key) == -1) return false;  // Not a valid key
	len = peStrCampo.value.length;
	for(i = 0; i < len; i++)
		if ((peStrCampo.value.charAt(i) != '0') && (peStrCampo.value.charAt(i) != peStrDec)) break;

	aux = '';
	for(; i < len; i++)
	if (strCheck.indexOf(peStrCampo.value.charAt(i))!=-1) aux += peStrCampo.value.charAt(i);
	aux += key;
	len = aux.length;
	if (len == 0) peStrCampo.value = '';
	if (len == 1) peStrCampo.value = '0'+ peStrDec + aux;
	//if (len == 2) peStrCampo.value = '0'+ peStrDec + aux;
	if (len < peMaxCampo)
	{
		if (len > 1)
		{
			aux2 = '';
			for (j = 0, i = len - 2; i >= 0; i--)
			{
				if (j == 2)
				{
					aux2 += peStrMil;
					j = 0;
				}
				aux2 += aux.charAt(i);
				j++;
			}
			peStrCampo.value = '';
			len2 = aux2.length;
			for (i = len2 - 1; i >= 0; i--)
			peStrCampo.value += aux2.charAt(i);
			peStrCampo.value += peStrDec + aux.substr(len - 1, len);
		}
	}
	else
	{
		return false;
	}
	return false;
}

/***********************************************************************
* Função fnEvnEntradaMoeda()
*
* Descrição: 	Controla a máscara para campos de valores do tipo moeda
*
* Chamada:		onKeyPress="javascript:return fnEvnEntradaMoeda();"
************************************************************************/
function fnEvnEntradaMoeda(peStrCampo, peStrMil, peStrDec, peMaxCampo)
{
	e = event;

	var sep = 0;
	var key = '';
	var i = j = 0;
	var len = len2 = 0;
	var strCheck = '0123456789';
	var aux = aux2 = '';
	var whichCode = (window.Event) ? e.which : e.keyCode;

	if (whichCode == 13) return true;  // Enter
	key = String.fromCharCode(whichCode);  // Get key value from key code
	if (strCheck.indexOf(key) == -1) return false;  // Not a valid key
	len = peStrCampo.value.length;
	for(i = 0; i < len; i++)
		if ((peStrCampo.value.charAt(i) != '0') && (peStrCampo.value.charAt(i) != peStrDec)) break;

	aux = '';
	for(; i < len; i++)
	if (strCheck.indexOf(peStrCampo.value.charAt(i))!=-1) aux += peStrCampo.value.charAt(i);
	aux += key;
	len = aux.length;
	if (len == 0) peStrCampo.value = '';
	if (len == 1) peStrCampo.value = '0'+ peStrDec + '0' + aux;
	if (len == 2) peStrCampo.value = '0'+ peStrDec + aux;
	if (len < peMaxCampo)
	{
		if (len > 2)
		{
			aux2 = '';
			for (j = 0, i = len - 3; i >= 0; i--)
			{
				if (j == 3)
				{
					aux2 += peStrMil;
					j = 0;
				}
				aux2 += aux.charAt(i);
				j++;
			}
			peStrCampo.value = '';
			len2 = aux2.length;
			for (i = len2 - 1; i >= 0; i--)
			peStrCampo.value += aux2.charAt(i);
			peStrCampo.value += peStrDec + aux.substr(len - 2, len);
		}
	}
	else
	{
		return false;
	}
	return false;
}

/***********************************************************************
* Função fnEvnEntradaNome()
*
* Descrição: 	Controla a entrada de dados para campos do tipo "NOME"
*
* Chamada:		onKeyPress="javascript:return fnEvnEntradaMoeda();"
************************************************************************/
function fnEvnEntradaNome()
{
	var peCharEntrada = String.fromCharCode(event.keyCode);

	var locStrExpression	= /[^A-Za-záãèêíóõúçÇÁÃÉÊÍÓÔÕÚ .]/i;
	var locRetorno			= peCharEntrada.match(locStrExpression);

	if (locRetorno == null)
	{
		return true;
	}
	else
	{
		event.keyCode = 0;
		return false;
	}
}

/***********************************************************************
* Função fnEvnEntradaSimNao()
*
* Descrição: 	Controla a entrada de dados para campos do tipo "NOME"
*
* Chamada:		onKeyPress="javascript:return fnEvnEntradaSimNao();"
************************************************************************/
function fnEvnEntradaSimNao(oCampo)
{
	//var peCharEntrada = String.fromCharCode(event.keyCode);

	//var locStrExpression	= /[^SN .]/i;
	//var locRetorno			= peCharEntrada.match(locStrExpression);
	
	if (event.keyCode == 83 || event.keyCode == 115) //S
	{
		event.keyCode == 83
		oCampo.value = 'S'
		return true;
	}
	else if(event.keyCode == 78 || event.keyCode == 110)//N
	{
		event.keyCode == 78
		oCampo.value = 'N'
		return true;
	}
	else
	{
		event.keyCode = 0;
		return false;
	}
}

/***********************************************************************
* Função fnStrVerificaSimNao()
*
* Descrição: 	Controla a entrada de dados para campos do tipo "NOME"
*
* Chamada:		onKeyPress="javascript:return fnEvnEntradaSimNao();"
************************************************************************/
function fnStrVerificaSimNao(oCampo)
{

	if(oCampo.value == ''){
		return true;
	}
		
	if (oCampo.value == 's' || oCampo.value == 'S') //S
	{		
		return true;
	}
	else if(oCampo.value == 'n' || oCampo.value == 'N')//N
	{		
		return true;
	}
	else
	{		
		return false;
	}
}

/***********************************************************************
* Função fnEvnEntradaFechadoAberto()
*
* Descrição: 	Controla a entrada de dados para campos do tipo "NOME"
*
* Chamada:		onKeyPress="javascript:return fnEvnEntradaSimNao();"
************************************************************************/
function fnEvnEntradaFechadoAberto(oCampo)
{
	//var peCharEntrada = String.fromCharCode(event.keyCode);

	//var locStrExpression	= /[^SN .]/i;
	//var locRetorno			= peCharEntrada.match(locStrExpression);
	
	if (event.keyCode == 70 || event.keyCode == 102) //F
	{
		event.keyCode == 70
		oCampo.value = 'F'
		return true;
	}
	else if(event.keyCode == 65 || event.keyCode == 97)//A
	{
		event.keyCode == 65
		oCampo.value = 'A'
		return true;
	}
	else
	{
		event.keyCode = 0;
		return false;
	}
}


/***********************************************************************
* Função fnEvnEntradaLetraNumero()
*
* Descrição: 	Controla a entrada de dados para campos do tipo "LETRA"
*				e "NÚMERO"
* Chamada:		onKeyPress="javascript:return fnEvnEntradaLetraNumero();"
************************************************************************/
function fnEvnEntradaLetraNumero()
{
	var peCharEntrada = String.fromCharCode(event.keyCode);

	var locStrExpression	= /[^A-Za-z0-9áãèêíóõúçÇÁÃÉÊÍÓÔÕÚ .]/i;
	var locRetorno			= peCharEntrada.match(locStrExpression);

	if (locRetorno == null)
	{
		return true;
	}
	else
	{
		event.keyCode = 0;
		return false;
	}
}

/***********************************************************************
* Função fnEvnEntradaChave()
*
* Descrição: 	Controla a entrada de dados para campos do tipo "CHAVE"
*
* Chamada:		onKeyPress="javascript:return fnEvnEntradaChave();"
************************************************************************/
function fnEvnEntradaChave()
{
	var peCharEntrada = String.fromCharCode(event.keyCode);

	var locStrExpression	= /[^A-Za-z0-9]/i;
	var locRetorno			= peCharEntrada.match(locStrExpression);

	if (locRetorno == null)
	{
		return true;
	}
	else
	{
		event.keyCode = 0;
		return false;
	}
}

/***********************************************************************
* Função fnEvnEntradaEndereco()
*
* Descrição: 	Controla a entrada de dados para campos do tipo "ENDEREÇO"
*
* Chamada:		onKeyPress="javascript:return fnEvnEntradaEndereco();"
************************************************************************/
function fnEvnEntradaEndereco()
{
	var peCharEntrada = String.fromCharCode(event.keyCode);

	var locStrExpression	= /[^A-Za-z0-9áãèêíóõúçÇÁÃÉÊÍÔÓÕÚºª().\/\-, ]/i;
	var locRetorno			= peCharEntrada.match(locStrExpression);

	if (locRetorno == null)
	{
		return true;
	}
	else
	{
		event.keyCode = 0;
		return false;
	}
}

/***********************************************************************
* Função fnEvnEntradaEmail()
*
* Descrição: 	Controla a entrada de dados para campos do tipo "EMAIL"
*
* Chamada:		onKeyPress="javascript:return fnEvnEntradaEmail();"
************************************************************************/
function fnEvnEntradaEmail()
{
	var peCharEntrada = String.fromCharCode(event.keyCode);

	var locStrExpression	= /[^A-Za-z0-9@().\/\-, ]/i;
	var locRetorno			= peCharEntrada.match(locStrExpression);

	if (locRetorno == null)
	{
		return true;
	}
	else
	{
		event.keyCode = 0;
		return false;
	}
}

/***********************************************************************
* Função fnEvnEntradaNumeros()
*
* Descrição: 	Controla a entrada de dados para campos do tipo "NUMERO"
*
* Chamada:		onKeyPress="javascript:return fnEvnEntradaNumeros();"
************************************************************************/
function fnEvnEntradaNumeros()
{
	var peCharEntrada		= String.fromCharCode(event.keyCode);

	var locStrExpression	= /[^0-9]/i;
	var locRetorno			= peCharEntrada.match(locStrExpression);

	if (locRetorno == null)
	{
		return true;
	}
	else
	{
		event.keyCode = 0;
		return false;
	}
}

/***********************************************************************
* Função fnEvnEntradaNumeroTelefone()
*
* Descrição: 	Controla a entrada de dados para campos do tipo "NUMERO"
*
* Chamada:		onKeyPress="javascript:return fnEvnEntradaNumeros();"
************************************************************************/
function fnEvnEntradaNumeroTelefone()
{
	var peCharEntrada		= String.fromCharCode(event.keyCode);

	var locStrExpression	= /[^0-9\-]/i;
	var locRetorno			= peCharEntrada.match(locStrExpression);

	if (locRetorno == null)
	{
		return true;
	}
	else
	{
		event.keyCode = 0;
		return false;
	}
}

/***********************************************************************
* Função fnEvnEntradaNumeroDesafio()
*
* Descrição: 	Controla a entrada de dados para campos do tipo "NUMERO"
*
* Chamada:		onKeyPress="javascript:return fnEvnEntradaNumeros();"
************************************************************************/
function fnEvnEntradaNumeroDesafio()
{
	var peCharEntrada		= String.fromCharCode(event.keyCode);

	var locStrExpression	= /[^0-9\-]/i;
	var locRetorno			= peCharEntrada.match(locStrExpression);

	if (locRetorno == null)
	{
		return true;
	}
	else
	{
		event.keyCode = 0;
		return false;
	}
}


/***********************************************************************
* Função fnEvnEntradaNumeroSep()
*
* Descrição: 	Controla a entrada de dados para campos do tipo número "SEP"
*
* Chamada:		onKeyPress="javascript:return fnEvnEntradaNumeroSep();"
************************************************************************/
function fnEvnEntradaNumeroSep()
{
	var peCharEntrada		= String.fromCharCode(event.keyCode);

	var locStrExpression	= /[^0-9.\-]/i;
	var locRetorno			= peCharEntrada.match(locStrExpression);

	if (locRetorno == null)
	{
		return true;
	}
	else
	{
		event.keyCode = 0;
		return false;
	}
}


/***********************************************************************
* Função fnStrVerificaPreenchimento()
*
* Descrição: 	Verificar os preenchimentos mínimo e máximo de um campo
************************************************************************/
function fnStrVerificaPreenchimento(peStrCampo, peStrDescricao, peIntMin, peIntMax, peStrMensagemOpcional)
{
	if (peStrCampo.value.length < peIntMin)
	{
		if (peStrMensagemOpcional == '')
		{
			pagStrErro += '-O prenchimento mínimo para o campo [' + peStrDescricao + '] é de ' + peIntMin + ' caracteres.\n';
		}
		else
		{
			pagStrErro += peStrMensagemOpcional + '.\n';
		}
		return false;
	}

	if (peStrCampo.value.length > peIntMax)
	{
		if (peStrMensagemOpcional == '')
		{
			pagStrErro += '-O prenchimento máximo para o campo [' + peStrDescricao + '] é de ' + peIntMax + ' caracteres.\n';
		}
		else
		{
			pagStrErro += peStrMensagemOpcional + '\n';
		}
		return false;
	}
	return true;
}

/***********************************************************************
* Função fnStrVerificaPreenchimento()
*
* Descrição: 	Verifica o conteúdo de campos do tipo "NOME"
************************************************************************/
function fnStrVerificaNome(peStrCampo, peStrDescricao, peStrMensagemOpcional)
{
	var peStr = peStrCampo.value;

	var locStrExpression	= /[^A-Za-záãêèíóõúçÇÁÃÉÊÍÓÕÚ .$]/i;
	var locRetorno			= peStr.match(locStrExpression);

	if (locRetorno == null)
	{
		return true;
	}
	else
	{
		if (peStrMensagemOpcional == '')
		{
			pagStrErro += "-Caracter inválido [" + locRetorno + "] no campo [" + peStrDescricao + "]\n";
		}
		else
		{
			pagStrErro += peStrMensagemOpcional + '\n';
		}
		return false;
	}
}

/***********************************************************************
* Função fnStrVerificaLetraNumero()
*
* Descrição: 	Verifica o conteúdo de campos do tipo "LETRA" e "NÚMERO"
************************************************************************/
function fnStrVerificaLetraNumero(peStrCampo, peStrDescricao, peStrMensagemOpcional)
{
	var peStr = peStrCampo.value;

	var locStrExpression	= /[^A-Za-z0-9áãêèíóõúçÇÁÃÉÊÍÓÕÚ .$]/i;
	var locRetorno			= peStr.match(locStrExpression);

	if (locRetorno == null)
	{
		return true;
	}
	else
	{
		if (peStrMensagemOpcional == '')
		{
			pagStrErro += "-Caracter inválido [" + locRetorno + "] no campo [" + peStrDescricao + "]\n";
		}
		else
		{
			pagStrErro += peStrMensagemOpcional + '\n';
		}
		return false;
	}
}

/***********************************************************************
* Função fnStrVerificaChave()
*
* Descrição: 	Verifica o conteúdo de campos do tipo "CHAVE"
************************************************************************/
function fnStrVerificaChave(peStrCampo, peStrDescricao, peStrMensagemOpcional)
{
	var peStr = peStrCampo.value;

	var locStrExpression	= /[^A-Za-z0-9]/i;
	var locRetorno			= peStr.match(locStrExpression);

	if (locRetorno == null)
	{
		return true;
	}
	else
	{
		if (peStrMensagemOpcional == '')
		{
			pagStrErro += "-Caracter inválido [" + locRetorno + "] no campo [" + peStrDescricao + "]\n";
		}
		else
		{
			pagStrErro += peStrMensagemOpcional + '\n';
		}
		return false;
	}
}

/***********************************************************************
* Função fnStrVerificaEndereco()
*
* Descrição: 	Verifica o conteúdo de campos do tipo "ENDERECO"
************************************************************************/
function fnStrVerificaEndereco(peStrCampo, peStrDescricao, peStrMensagemOpcional)
{
	var peStr = peStrCampo.value;
	var locStrExpression	= /[^A-Za-z0-9áàâãêéíóôõúçÇÀÁÂÃÉÊÍÔÓÕÚºª().\/\-, \t\n\r\f\v$]/i;
	var locRetorno			= peStr.match(locStrExpression);

	if (locRetorno == null)
	{
		return true;
	}
	else
	{
		if (peStrMensagemOpcional == '')
		{
			pagStrErro += "-Caracter inválido [" + locRetorno + "] no campo [" + peStrDescricao + "]\n";
		}
		else
		{
			pagStrErro += peStrMensagemOpcional + '\n';
		}
		return false;
	}
}

/***********************************************************************
* Função fnStrVerificaNumero()
*
* Descrição: 	Verifica o conteúdo de campos do tipo "NUMERO"
************************************************************************/
function fnStrVerificaNumero(peStrCampo, peStrDescricao, peStrMensagemOpcional)
{
	var peStr = peStrCampo.value;

	var locStrExpression	= /[^0-9$]/i;
	var locRetorno			= peStr.match(locStrExpression);

	if (locRetorno == null)
	{
		return true;
	}
	else
	{
		if (peStrMensagemOpcional == '')
		{
			pagStrErro += "-Caracter inválido [" + locRetorno + "] no campo [" + peStrDescricao + "]\n";
		}
		else
		{
			pagStrErro += peStrMensagemOpcional + '\n';
		}
		return false;
	}
}

/***********************************************************************
* Função fnStrVerificaNumeroTelefone()
*
* Descrição: 	Verifica o conteúdo de campos do tipo "NUMERO"
************************************************************************/
function fnStrVerificaNumeroTelefone(peStrCampo, peStrDescricao, peStrMensagemOpcional)
{
	var peStr = peStrCampo.value;

	var locStrExpression	= /[^0-9\-]/i;
	var locRetorno			= peStr.match(locStrExpression);

	if (locRetorno == null)
	{
		return true;
	}
	else
	{
		if (peStrMensagemOpcional == '')
		{
			pagStrErro += "-Caracter inválido [" + locRetorno + "] no campo [" + peStrDescricao + "]\n";
		}
		else
		{
			pagStrErro += peStrMensagemOpcional + '\n';
		}
		return false;
	}
}


/***********************************************************************
* Função fnStrVerificaNumeroSEP()
*
* Descrição: 	Verifica o conteúdo de campos do tipo "NUMERO"
************************************************************************/
function fnStrVerificaNumeroSEP(peStrCampo, peStrDescricao, peStrMensagemOpcional)
{
	var peStr = peStrCampo.value;

	var locStrExpression	= /[^0-9.\-]/i;
	var locRetorno			= peStr.match(locStrExpression);

	if (locRetorno == null)
	{
		return true;
	}
	else
	{
		if (peStrMensagemOpcional == '')
		{
			pagStrErro += "-Caracter inválido [" + locRetorno + "] no campo [" + peStrDescricao + "]\n";
		}
		else
		{
			pagStrErro += peStrMensagemOpcional + '\n';
		}
		return false;
	}
}


/***********************************************************************
* Função fnStrVerificaNumeroReal()
*
* Descrição: 	Verifica o conteúdo de campos do tipo "NUMERO REAL"
************************************************************************/
function fnStrVerificaNumeroReal(peStrCampo, peStrDescricao, peStrMensagemOpcional)
{
	var peStr = peStrCampo.value;

	if(peStr == "")
		return true;

	var locStrExpression	=  /^[+-]?((\d+|\d{1,3}(\.\d{3})+)(\,\d*)?|\,\d+)$/;
	//var locRetorno			= peStr.match(locStrExpression);
	var locRetorno			= locStrExpression.test(peStr);

	var locStrExpression2 =  /[^0-9,$]/i;
	var locRetorno2			= peStr.match(locStrExpression2);
	if (locRetorno == true)
	{
		var pos = peStr.indexOf(",");
		var decs = pos == -1? -1: peStr.length - pos - 1;
		if (decs == 0)
		{
			if (peStrMensagemOpcional == '')
			{
				pagStrErro += "-O número [" + peStr + "] no campo [" + peStrDescricao + "] não é válido.\n";
			}
			else
			{
				pagStrErro += peStrMensagemOpcional + '\n';
			}
			return false;
		}
		else
		{
			return true;
		}
	}
	else
	{
		if (locRetorno2 == null)
		{
			if (peStrMensagemOpcional == '')
			{
				pagStrErro += "-O número [" + peStr + "] no campo [" + peStrDescricao + "] não é válido.\n";
			}
			else
			{
				pagStrErro += peStrMensagemOpcional + '\n';
			}
			return false;
		}
		else
		{
			if (peStrMensagemOpcional == '')
			{
				pagStrErro += "-Caracter inválido [" + locRetorno2 + "] no campo [" + peStrDescricao + "]\n";
			}
			else
			{
				pagStrErro += peStrMensagemOpcional + '\n';
			}
			return false;
		}

	}
}


/***********************************************************************
* Função fnStrVerificaEmail()
*
* Descrição: 	Verifica o conteúdo de campos do tipo "EMAIL"
************************************************************************/
function fnStrVerificaEmail(peStrCampo, peStrDescricao, peStrMensagemOpcional)
{
	var strEmail;
	
	if (typeof(peStrCampo) == 'object')
		strEmail = peStrCampo.value;
	else
		strEmail = peStrCampo;
	
	
	if (strEmail != '')
	{
		var peStrMail = strEmail;
		var locStrExpression	= /^([a-zA-Z0-9_\.\-])+\@(([a-zA-Z0-9\-])+\.)+([a-zA-Z0-9])+$/;


		if (locStrExpression.test(peStrMail))
		{
			return true;
		}
		else
		{
			if (peStrMensagemOpcional == '')
			{
				pagStrErro += "-Endereço de email inválido!\n";
			}
			else
			{
				pagStrErro += peStrMensagemOpcional + '\n';
			}
			return false;
		}
	}
}

/***********************************************************************
* Função fnStrVerificaData()
*
* Descrição: 	Verifica o conteúdo de campos do tipo "DATA"
************************************************************************/
function fnStrVerificaData(peStrCampo, peStrDescricao, peStrMensagemOpcional)
{
    var peStrData = peStrCampo.value;

    var dia = Number(peStrData.substring(0,2));
    var mes = Number(peStrData.substring(3,5));
    var ano = Number(peStrData.substring(6));
    var ultDiaMes = 0;

    if(peStrData == '')
    {
		return true;
    }

    if (ano < 1900)
    {
		if (peStrMensagemOpcional == '')
		{
			pagStrErro += "-A data inserida no campo [" + peStrDescricao + "] é inválida!\n";
		}
		else
		{
			pagStrErro += peStrMensagemOpcional + '\n';
		}
        return false;
	}

    if (mes == 2)
    {
        if (ano % 4 == 0)
        {
            ultDiaMes = 29;
		}
        else
        {
            ultDiaMes = 28;
		}
    }
    else if (mes == 1 || mes == 3 || mes == 5 || mes == 7 || mes == 8 || mes == 10 || mes == 12)
	{
        ultDiaMes = 31;
	}
    else if (mes == 4 || mes == 6 || mes == 9 || mes == 11)
	{
        ultDiaMes = 30;
	}
    else
    {
		if (peStrMensagemOpcional == '')
		{
			pagStrErro += "-A data inserida no campo [" + peStrDescricao + "] é inválida!\n";
		}
		else
		{
			pagStrErro += peStrMensagemOpcional + '\n';
		}
        return false;
    }

    if (dia < 1 || dia > ultDiaMes)
    {
		if (peStrMensagemOpcional == '')
		{
			pagStrErro += "-A data inserida no campo [" + peStrDescricao + "] é inválida!\n";
		}
		else
		{
			pagStrErro += peStrMensagemOpcional + '\n';
		}
        return false;
    }
	return true;
}

/***********************************************************************
* Função fnStrVerificaData()
*
* Descrição: 	Verifica o conteúdo de campos do tipo "DATA"
************************************************************************/
function fnStrVerificaDataAmericana(peStrCampo, peStrDescricao, peStrMensagemOpcional)
{
    var peStrData = peStrCampo.value;

    var mes = Number(peStrData.substring(0,2));
    var dia = Number(peStrData.substring(3,5));
    var ano = Number(peStrData.substring(6));
    var ultDiaMes = 0;

    if(peStrData == '')
    {
		return true;
    }

    if (ano < 1900)
    {
		if (peStrMensagemOpcional == '')
		{
			pagStrErro += "-A data inserida no campo [" + peStrDescricao + "] é inválida!\n";
		}
		else
		{
			pagStrErro += peStrMensagemOpcional + '\n';
		}
        return false;
	}

    if (mes == 2)
    {
        if (ano % 4 == 0)
        {
            ultDiaMes = 29;
		}
        else
        {
            ultDiaMes = 28;
		}
    }
    else if (mes == 1 || mes == 3 || mes == 5 || mes == 7 || mes == 8 || mes == 10 || mes == 12)
	{
        ultDiaMes = 31;
	}
    else if (mes == 4 || mes == 6 || mes == 9 || mes == 11)
	{
        ultDiaMes = 30;
	}
    else
    {
		if (peStrMensagemOpcional == '')
		{
			pagStrErro += "-A data inserida no campo [" + peStrDescricao + "] é inválida!\n";
		}
		else
		{
			pagStrErro += peStrMensagemOpcional + '\n';
		}
        return false;
    }

    if (dia < 1 || dia > ultDiaMes)
    {
		if (peStrMensagemOpcional == '')
		{
			pagStrErro += "-A data inserida no campo [" + peStrDescricao + "] é inválida!\n";
		}
		else
		{
			pagStrErro += peStrMensagemOpcional + '\n';
		}
        return false;
    }
	return true;
}

/***********************************************************************
* Função fnStrVerificaMoeda()
*
* Descrição: 	Verifica o conteúdo de campos do tipo "MOEDA"
************************************************************************/
function fnStrVerificaMoeda(peStrCampo, peStrDescricao, peStrMensagemOpcional)
{
	var peStr = peStrCampo.value;

	var locStrExpression	= /[^(\d{1,3})(\.\d{3})*?(,\d{2})$]/i;

	var locRetorno			= peStr.match(locStrExpression);

	if (locRetorno == null)
	{
		return true;
	}
	else
	{
		if (peStrMensagemOpcional == '')
		{
			pagStrErro += "-Caracter inválido [" + locRetorno + "] no campo [" + peStrDescricao + "]\n";
		}
		else
		{
			pagStrErro += peStrMensagemOpcional;
		}
		return false;
	}
}

/***********************************************************************
* Função fnStrVerificaMascara()
*
* Descrição: 	Verifica o conteúdo dos campos com respeito à mascara especificada.
************************************************************************/
function fnStrVerificaMascara(peStrCampo, peStrDescricao, peStrMascara, peStrMensagemOpcional)
{
	var locMascChar;
	var locCampoChar;
	var locNumeros='0123456789';
	var locLetras='abcdefghijklmnopqrstuvxzABCDEFGHIJKLMNOPQRSTUVXZáàâãÁÀÂÃéèêÉÈÊíìîÍÌÎÓÒÔÕóòôõÚÙÛúùûçÇñÑ ';
	var locValorCampo = peStrCampo.value;

	if(locValorCampo.length == 0)
	{
		return true;
	}

	if (locValorCampo.length != peStrMascara.length)
	{
		if (peStrMensagemOpcional == '')
		{
			pagStrErro += "-O campo [" + peStrDescricao + "] não está devidamente preenchido.\n";
		}
		else
		{
			pagStrErro += peStrMensagemOpcional;
		}
		return false;
	}

	for (locIntCount=0; locIntCount < peStrMascara.length; locIntCount++)
	{
		locMascChar = peStrMascara.substring(locIntCount, locIntCount + 1);
		locCampoChar = locValorCampo.substring(locIntCount, locIntCount + 1);

		switch (locMascChar)
		{
			case "#":
			{
				if (locNumeros.indexOf(locCampoChar) == -1)
				{
					if (peStrMensagemOpcional == '')
					{
						pagStrErro += "-O preenchimento do campo '" + peStrDescricao + "' é inválido! [" + locCampoChar + "]\n";
					}
					else
					{
						pagStrErro += peStrMensagemOpcional;
					}
					return false;
				}
				break;
			}
			case "A":
			{
				if (locLetras.indexOf(locCampoChar) == -1)
				{
					if (peStrMensagemOpcional == '')
					{
						pagStrErro += "-O preenchimento do campo '" + peStrDescricao + "' é inválido! [" + locCampoChar + "]\n";
					}
					else
					{
						pagStrErro += peStrMensagemOpcional;
					}
					return false;
				}
				break;
			}
			default:
			{
				if (locCampoChar != locMascChar)
				{
					if (peStrMensagemOpcional == '')
					{
						pagStrErro += "-O preenchimento do campo '" + peStrDescricao + "' é inválido! [" + locCampoChar + "]\n";
					}
					else
					{
						pagStrErro += peStrMensagemOpcional;
					}
					return false;
				}
			}
		}
	}
}

/***********************************************************************
* Função fnStrMascValor()
*
* Descrição: 	Aplica máscara à um determinado valor.
************************************************************************/
function fnStrMascValor(peStrValor, peStrMask)
{
	var psStrRetorno	='';
	var locStrCharMask  ='';
	var locStrCharValor ='';

	var j=0;

	for (i=0; i<peStrMask.length; i++)
	{
		locStrCharMask  = peStrMask.substring(j,j+1);
		locStrCharValor = peStrValor.substring(i,i+1);

		if((locStrCharMask != '#') && (locStrCharMask != 'A'))
		{
			psStrRetorno += locStrCharMask;
			j++;
		}
		j++;
		psStrRetorno += locStrCharValor;
	}

	return psStrRetorno;
}

/***********************************************************************
* Função fnMascDinam()
*
* Descrição: 	Cria dinâmicamente uma máscara especifica
************************************************************************/
function fnMascDinam(peStrCampo, peStrMask)
{
	var locObj		 = peStrCampo;

	var locStr		 = locObj.value;

	var locCharPos   = locStr.length;
	var locCharInput = String.fromCharCode(event.keyCode);

	var locCharMask  = peStrMask.substring(locCharPos, locCharPos + 1);
	var locCharProx	 = peStrMask.substring(locCharPos + 1, locCharPos + 2);
	var locStrNumeros= '0123456789';
	var locStrLetras = 'abcdefghijklmnopqrstuvxzABCDEFGHIJKLMNOPQRSTUVXZáàâãÁÀÂÃéèêÉÈÊíìîÍÌÎÓÒÔÕóòôõÚÙÛúùûçÇñÑ';

	// A - Alfanumérico (Letras, espaço e números)
	// # - Números apenas.

	if (locStr.length >= peStrMask.length)
	{
		locObj.value = locStr.substring(0,peStrMask.length);
		return false;
	}

	switch (locCharMask)
	{
		case "#":
		{
			if (locStrNumeros.indexOf(locCharInput) == -1)
			{
				return false;
			}
			break;
		}
		case "A":
		{
			if (locStrLetras.indexOf(locCharInput) == -1)
			{
				return false;
			}
			break;
		}
		default:
		{
			switch (locCharProx)
			{
				case "#":
				{
					if (locStrNumeros.indexOf(locCharInput) == -1)
					{
						return false;
					}
					break;
				}
				case "A":
				{
					if (locStrLetras.indexOf(locCharInput) == -1)
					{
						return false;
					}
					break;
				}
			}
		}
		locObj.value += locCharMask;
	}
}

/***********************************************************************
* Função fnStrVerificaLista()
*
* Descrição: 	Verifica itens numa lista
************************************************************************/
function fnStrVerificaLista(peObjForm, peStrListaTiposObjeto, peStrMensagemOpcional)
{
	var locStrObj='';
	var locStrChar='';
	var locIntChecks=0;
	var ii=0;

	//Cria array baseado em lista de tipos de objeto especificada
	for (i=0; i < peStrListaTiposObjeto.length; i++)
	{
		locStrChar = peStrListaTiposObjeto.substring(i,i+1);
		if(locStrChar == ';')
		{
			eval('var locStrObj' + ii + '="' + locStrObj + '"');
			locStrObj = '';
			ii++;
		}
		else
		{
			locStrObj += locStrChar;
		}
	}

	//Para cada um dos tipos de objeto, corre array de elementos do formulário,
	//Verificando quais estão com "checked=true".
	for (j=0; j<ii; j++)
	{
		for (i=0; i< peObjForm.elements.length; i++)
		{
			if (peObjForm.elements[i].type == eval('locStrObj' + j))
			{
				if (peObjForm.elements[i].checked) locIntChecks++;
			}
		}
	}

	//Se o número de itens checados na lista for inferior ao mínimo, adiciona erro.
	if (locIntChecks < 1)
	{
		if (peStrMensagemOpcional == '')
		{
			pagStrErro += '- É necessário que pelo menos um item da lista seja selecionado para esta operação.\n';
		}
		else
		{
			pagStrErro += peStrMensagemOpcional + '\n';
		}
		return false;
	}
	return true;
}

/***********************************************************************
* Função fnStrVerificaChar()
*
* Descrição: 	Verifica se o campo possui um dos caracteres rejeitados
*				separados por (·) Alt + 250
************************************************************************/
function fnStrVerificaChar(peObjForm, peStrCharList, peStrCampo, peStrMensagemOpcional)
{
	var locVetCharRejeitado = peStrCharList.split('·');
	var locStrValor = peObjForm.value;

	for (i=0; i<locStrValor.length; i++)
	{
		for (j=0; j<locVetCharRejeitado.length; j++)
		{
			if(locStrValor.substring(i,i+1) == locVetCharRejeitado[j])
			{
				if (peStrMensagemOpcional == '')
				{
					pagStrErro += '- O caracter [' + locStrValor.substring(i,i+1) + '] é inválido para o campo [' + peStrCampo + '].\n';
				}
				else
				{
					pagStrErro += peStrMensagemOpcional + '\n';
				}
				return false;
			}
		}
	}
	return true;
}

/***********************************************************************
* Função fnObjMarcaSomenteUmCheckBox()
*
* Descrição: 	Marca somente o checkbox passado e desmarca todos os outros
*				da página
************************************************************************/
function fnObjMarcaSomenteUmCheckBox(peObjLista)
{
	for (i=0; i < peObjLista.form.elements.length; i++)
	{
		if (peObjLista.form.elements[i].type == 'checkbox')
	    {
	    	if (peObjLista.checked)
	    	{
	    		if (peObjLista.form.elements[i].name != peObjLista.name)
	    		{
					peObjLista.form.elements[i].checked = false;
				}
			}
		}
	}
}

/***********************************************************************
* Função fnIntComparaDatas()
*
* Descrição: 	Verifica a relação entre duas datas.
*				Data1 > Data2 retorna 1
*				Data1 = Data2 retorna 0
*				Data1 < Data2 retorna -1
************************************************************************/
function fnIntComparaDatas(peStrData1,peStrData2)
{
    var data1=peStrData1.substring(6)+peStrData1.substring(3,5)+peStrData1.substring(0,2);
    var data2=peStrData2.substring(6)+peStrData2.substring(3,5)+peStrData2.substring(0,2);

    if (Number(data1)>Number(data2))
	{
		return 1;
	}
	if (Number(data1)==Number(data2))
	{
		return 0;
    }
    if (Number(data1)<Number(data2))
	{
		return -1;
	}
}

/***********************************************************************
* Função fnIntComparaDatas()
*
* Descrição: 	Verifica a relação entre duas datas.
*				Data1 > Data2 retorna 1
*				Data1 = Data2 retorna 0
*				Data1 < Data2 retorna -1
************************************************************************/
function fnIntComparaDatasAmericana(peStrData1,peStrData2)
{
    var data1=peStrData1.substring(6)+peStrData1.substring(0,2)+peStrData1.substring(3,5);
    var data2=peStrData2.substring(6)+peStrData2.substring(0,2)+peStrData2.substring(3,5);

    if (Number(data1)>Number(data2))
	{
		return 1;
	}
	if (Number(data1)==Number(data2))
	{
		return 0;
    }
    if (Number(data1)<Number(data2))
	{
		return -1;
	}
}

/***********************************************************************
* Função fnArredonda()
*
* Descrição: 	Arredonda Valores
************************************************************************/
function fnArredonda(paramValue,decimal){
	var str, str2, strDec, xx = new String();
	var x, i, a;
	var xDec, xValue;

	str = paramValue + "";
	x = str.indexOf(".");

	if(x > 0){
		str = paramValue + "00000";
	}

	strDec = "";

	strDec = str.substr(x+1, decimal+1);

	xValue = parseFloat(str);

	a = "";
	if(x > -1){
		xx = str.substr(x+1, decimal+1);

		strDec = str.substr(x+1, decimal+1);

		if(xx.length > decimal){

			a = parseInt(xx.substr(decimal,1));

			if(a >= 5){

				if(xValue < 0){
					xValue -= ((1/Math.pow(10,decimal))-(a/Math.pow(10,decimal+1)));
				}else{
					xValue += parseFloat((1/Math.pow(10,decimal))-(a/Math.pow(10,decimal+1)));
				}
			}
		}
		strDec = xValue;
		for(i = 0; i < decimal; i++){
			strDec += "0";
		}

		str2 = str.substring(0,x) + "." + strDec.substring(0,decimal);
		str2 = strDec.substring(0,x+decimal+1);

		return str2;
	}else{
		strDec = str + ".";
		for(i = 0; i < decimal; i++){
			strDec += "0";
		}

		return strDec;
	}

}

/***********************************************************************
* Função fnFormataValorBR()
*
* Descrição: 	Formata o numero no padrão brasileiro
************************************************************************/
function fnFormataValorBR(Valor,numDecs)
{
	var cRetu;
	var nPos;
	var inte2;
	var inte3;
	var zeros;
	var cValor = new String(Valor);
	var k, x, deci;

	nPos = cValor.indexOf(".");
	numDecs = parseInt(numDecs);

	if (nPos > 0){
	  inte1 = cValor.substr(0, nPos);
	}else{
	  inte1 = cValor;
	}

	inte2="";
	inte3="";
	x = 0;
	for (k=inte1.length-1;k>=0;k--){
		inte2 += inte1.substr(k,1);
		x++;
		if ((x == 3) && (k > 0)){
			inte2 += ".";
			x = 0;
		}
	}

	for (k=inte2.length-1; k >= 0;k--){
		inte3 += inte2.substr(k,1);
	}

	deci = "";
	zeros = "";
	zeros += Math.pow(10, numDecs);

	if (numDecs > 0){
		if (nPos > 0){
			deci = cValor.substr(nPos + 1, numDecs);
		}

		for(k=zeros.length-1; k >= 0; k--){
			deci += zeros.substr(k, 1);
		}
		//alert("deci = " + deci);
		cRetu = inte3 + "," + deci.substr(0, numDecs);
	}else{
		cRetu = inte2;
	}
	//alert("cRetu = " + cRetu);
	return cRetu;
}

/***********************************************************************
* Função fnStrResumeCritica()
*
* Descrição: 	Resume as criticas de um formulário
************************************************************************/
function fnStrResumeCritica()
{
	if (pagStrErro == '')
	{
		return true;
	}
	else
	{
		alert(pagStrErro);
		pagStrErro = '';
		return false;
	}
}

/***********************************************************************
* Função Submete()
*
* Descrição: 	Executa o submit para a página passada
************************************************************************/
function Submete( asPagina )
{
	document.forms[0].action = asPagina;
	document.forms[0].submit();
}

/***********************************************************************
* Função Trim()
*
* Descrição: 	Retira os espaços antes e depois do texto passado
************************************************************************/
function Trim(sTrim)
{
	var String = sTrim;
	var Resultado = String;

	//Retira os espaços do inicio. Enquanto o primeiro caracter for igual à "Espaço" 1 caracter do inicio é removido.
	var i = 0;

	if (Resultado.charCodeAt(2-1) == '32'){
	}

	while (Resultado.charCodeAt(0) == '32'){
		Resultado = String.substring(i,String.length);
		i++;
	}

	//Pega a string já formatada e agora retira os espaços do final
	//mesmo esquema, enquanto o ultimo caracter for um espaço,
	//ele retira 1 caracter do final...

	while(Resultado.charCodeAt(Resultado.length-1) == '32'){
		Resultado = Resultado.substring(0,Resultado.length-1);
	}
	String = "";
	return Resultado;
}

/***********************************************************************
* Função fnAbrePopup()
*
* Descrição: 	Abre uma popup com as características passadas
************************************************************************/
function fnAbrePopup( asURL, asTarget, aiLargura, aiAltura, aiOpcoes, aiScroll, aiResize )
	{
	var oJanela;
	var sOpcoes;

	sOpcoes = "";
	if ( parseInt( navigator.appVersion ) < 4 )
		{
		sOpcoes	= "toolbar=no,location=no,address=no,directories=no,status=no,menubar=no,copyhistory=yes,maximized=yes"
					+ ",width=" + aiLargura + ",height=" + aiAltura;
		}
	else
		{
		var lX = screen.width	- aiLargura;		// Posição X da janela
		var lY = screen.height	- aiAltura;			// Posição y da janela

		if ( lX != 0 )
			{
			lX = Math.round( lX / 0.5 );
			lY = Math.round( lY / 0.5 );
			}
		sOpcoes = aiOpcoes;
		sOpcoes	+= ",width=" + aiLargura + ",height=" + aiAltura;

		}
	if ( aiScroll > 0 )
		sOpcoes += ",scrollbars=yes";
	else
		sOpcoes += ",scrollbars=no";

	if ( aiResize > 0 )
		sOpcoes += ",resizable=yes";
	else
		sOpcoes += ",resizable=no";

	//aoTelaPai.open( asURL, "pop", sOpcoes );
	window.open( asURL, asTarget, sOpcoes );
	}

/***********************************************************************
* Função ValidaCampoData()
*
* Descrição: 	Valida um campo Data
************************************************************************/
function ValidaCampoData( evento , oCampo )
{
	var sData = oCampo.value;
	var i;

	if( evento.keyCode == 37 || evento.keyCode == 38 || evento.keyCode == 39 || evento.keyCode == 40 )
	{
		return true;
	}

	if( oCampo.value != '' )
	{
		for( i = 0 ; i < sData.length ; i++ )
		{
			if( sData.charAt(i) == "/" )
			{
				sData = sData.substring( 0 , i ) + sData.substring( i + 1 , sData.length )
				i = i - 1;
			}
		}

		if( fnStrVerificaCampoNumerico( sData ) )
		{
			if( evento.keyCode == 8 )
			{
				if( sData.length == 4 || sData.length == 3 )
				{
					sData = sData.substring( 0 , 2 ) + "/" + sData.substring( 2 , sData.length );
				}
				else
				{
					if( sData.length < 3 )
					{
						sData = sData.substring( 0 , sData.length );
					}
					else
					{
						sData = sData.substring( 0 , 2 ) + "/" + sData.substring( 2 , 4 ) + "/" + sData.substring( 4 , sData.length );
					}
				}
			}
			else
			{
				if( sData.length != 1 )
				{
					if( sData.length < 4 )
					{
						sData = sData.substring( 0 , 2 ) + "/" + sData.substring( 2 , sData.length );
					}
					else
					{
						if( sData.length == 4 )
						{
							sData = sData.substring( 0 , 2 ) + "/" + sData.substring( 2 , 4 ) + "/";
						}
						else
						{
							sData = sData.substring( 0 , 2 ) + "/" + sData.substring( 2 , 4 ) + "/" + sData.substring( 4 , sData.length );
						}
					}
				}
			}
			oCampo.value = sData.substr( 0 , 10 );
		}
		else
		{
			oCampo.value = '';
			alert( 'Preencha o campo apenas com números' );
		}
	}
	return true;
}

/***********************************************************************
* Função fnStrVerificaCampoDataMesAno()
*
* Descrição: 	Valida um campo Data no formato mm/aaaa
************************************************************************/
function fnStrVerificaCampoDataMesAno(evento, oCampo, peStrMensagemOpcional)
{
	var sData = oCampo.value;
	var i;

	if( evento.keyCode == 37 || evento.keyCode == 38 || evento.keyCode == 39 || evento.keyCode == 40 )
	{
		return false;
	}

	if( oCampo.value != '' )
	{
		for( i = 0 ; i < sData.length ; i++ )
		{
			if( sData.charAt(i) == "/" )
			{
				sData = sData.substring( 0 , i ) + sData.substring( i + 1 , sData.length )
				i = i - 1;
			}
		}

		if( fnStrVerificaCampoNumerico( sData ) )
		{
			if( evento.keyCode == 8 )
			{
				if( sData.length == 4 || sData.length == 3 )
				{
					sData = sData.substring( 0 , 2 ) + "/" + sData.substring( 2 , sData.length );
				}
				else
				{
					if( sData.length < 3 )
					{
						sData = sData.substring( 0 , sData.length );
					}
					else
					{
						sData = sData.substring( 0 , 2 ) + "/" + sData.substring( 4 , sData.length );
					}
				}
			}
			else
			{
				if( sData.length != 1 )
				{
					sData = sData.substring( 0 , 2 ) + "/" + sData.substring( 2 , sData.length );
				}
			}
			oCampo.value = sData.substr( 0 , 6 );
		}
		else
		{
			if (peStrMensagemOpcional == '')
			{
				pagStrErro += "'Preencha o campo apenas com números'\n";
			}
			else
			{
				pagStrErro += peStrMensagemOpcional;
			}
			return false;
		}
	}
	return true;
}

/***********************************************************************
* Função fnStrVerificaCampoNumerico()
*
* Descrição: 	Valida um campo do tipo número
************************************************************************/
function fnStrVerificaCampoNumerico( sTexto )
{
	var ValidChars = "0123456789";
	var IsNumber=true;
	var Char;

 	for ( i = 0 ; i < sTexto.length && IsNumber == true ; i++ )
	{
		Char = sTexto.charAt( i );
		if ( ValidChars.indexOf(Char) == -1 )
		{
			IsNumber = false;
		}
	}
	return IsNumber;
}

/***********************************************************************
* Função fnStrVerificaDataMesAno()
*
* Descrição: 	Valida um campo Data no formato mm/aaaa
************************************************************************/
function fnStrVerificaDataMesAno( peStrCampo, peStrDescricao, peStrMensagemOpcional )
{
	var locCampoChar = peStrCampo.value;
	var mes = parseInt( peStrCampo.value.toString().substr( 0, 2 ), 10 );
	var ano = parseInt( peStrCampo.value.toString().substr( 3, 4 ), 10 );

	if( mes < 1 || mes > 12 )
	{
		if (peStrMensagemOpcional == '')
		{
			pagStrErro += "-O preenchimento do campo '" + peStrDescricao + "' é inválido! [" + locCampoChar + "]\n";
		}
		else
		{
			pagStrErro += peStrMensagemOpcional;
		}
		return false;
	}
	if( ano < 1900 )
	{
		if (peStrMensagemOpcional == '')
		{
			pagStrErro += "-O preenchimento do campo '" + peStrDescricao + "' é inválido! [" + locCampoChar + "]\n";
		}
		else
		{
			pagStrErro += peStrMensagemOpcional;
		}
		return false;
	}
	return true;
}

/***********************************************************************
* Função fnStrVerificaDataAno()
*
* Descrição: 	Valida um campo Data no formato aaaa
************************************************************************/
function fnStrVerificaDataAno( peStrCampo, peStrDescricao, peStrMensagemOpcional )
{
	var locCampoChar = peStrCampo.value;
	var ano = parseInt( peStrCampo.value.toString().substr( 0, 4 ), 10 );
	
	if (( ano < 1900 ) || (ano > 3000))
	{
		if (peStrMensagemOpcional == '')
		{
			pagStrErro += "-O preenchimento do campo '" + peStrDescricao + "' é inválido! [" + locCampoChar + "]\n";
		}
		else
		{
			pagStrErro += peStrMensagemOpcional;
		}
		return false;
	}
	return true;
}

/***********************************************************************
* Função fnStrVerificaRadio()
*
* Descrição: 	Verifica se existe pelo menos um radio selecionado
************************************************************************/
function fnStrVerificaRadio( peStrCampo, peStrDescricao, peStrMensagemOpcional )
{
	bMarcado = 0;
	if(peStrCampo[0]){
		for( var i=0; i < peStrCampo.length; i++ )
		{
			if( peStrCampo[i].checked == true )
				bMarcado = 1;
		}
	}
	else{
		if( peStrCampo.checked == true )
			bMarcado = 1;
	}

	if( bMarcado == 0 )
	{
		if (peStrMensagemOpcional == '')
		{
			pagStrErro += "O campo [" + peStrDescricao + "] é obrigatório.\n";
		}
		else
		{
			pagStrErro += peStrMensagemOpcional + "\n";
		}

		return false;
	}

}

/***********************************************************************
* Função fnVerificaAlteracao(oFrm)
*
* Descrição: 	Verifica se ouve alguma alteração nos valores do formulario
************************************************************************/
function fnVerificaAlteracao(oFrm)
{
	var i;
	var mudou;
	var oObj;
	for (i=0; i<oFrm.tags("TEXTAREA").length; i++)
	{
		if (oFrm.tags("TEXTAREA")[i].defaultValue != oFrm.tags("TEXTAREA")[i].value)
		{
			mudou=true;
			oObj = oFrm.tags("TEXTAREA")[i];
		}
	}
	for (i=0; i<oFrm.tags("SELECT").length; i++)
	{
		TemDefault = false;
		for (j=0; j<oFrm.tags("SELECT")[i].length; j++)
		{
			if (oFrm.tags("SELECT")[i][j].defaultSelected)
			{
				if (oFrm.tags("SELECT")[i].selectedIndex != j)
				{
					mudou=true;
					oObj = oFrm.tags("SELECT")[i];
				}
				TemDefault = true;
			}
		}
		if (!TemDefault)
		{
			if (oFrm.tags("SELECT")[i].selectedIndex != 0)
			{
				mudou=true;
				oObj = oFrm.tags("SELECT")[i];
			}
		}
	}
	for (i=0; i<oFrm.tags("INPUT").length; i++)
	{
		switch (oFrm.tags("INPUT")[i].type)
		{
			case "text" :
			{
				if (oFrm.tags("INPUT")[i].defaultValue != oFrm.tags("INPUT")[i].value)
				{
					mudou=true;
					oObj = oFrm.tags("INPUT")[i];
				}
			}
			break;

			case "password" :
			{
				if (oFrm.tags("INPUT")[i].defaultValue != oFrm.tags("INPUT")[i].value)
				{
					mudou=true;
					oObj = oFrm.tags("INPUT")[i];
				}
			}
			break;

			case "checkbox" :
			{
				if (oFrm.tags("INPUT")[i].defaultChecked != oFrm.tags("INPUT")[i].checked)
				{
					mudou=true;
					oObj = oFrm.tags("INPUT")[i];
				}
			}
			break;

			case "radio" :
			{
				if (oFrm.tags("INPUT")[i].defaultChecked != oFrm.tags("INPUT")[i].checked)
				{
					mudou=true;
					oObj = oFrm.tags("INPUT")[i];
				}
			}
			break;
		}
	}

	if (mudou)
	{
		return true;
	}
	return false;
}
/***********************************************************************
* Função fnAdicionaMensagem()
*
* Descrição: 	Adiciona uma mensagem avulsa de erro
************************************************************************/
function fnAdicionaMensagem( peStrMensagem )
{
	pagStrErro += peStrMensagem + "\n";
}

/***********************************************************************
* Função MudaLado()
*
* Descrição: 	Função que troca os itens uma combo para a outra
************************************************************************/
function MudaLado(objEnvia, objRecebe)
{
	var nomecampo;
	objEnvia = eval(objEnvia);
	objRecebe = eval(objRecebe);
	icont = 0;

	for (x=0;x<objEnvia.length;x++)
	{
		if (objEnvia[x].selected)
			icont++;
	}
	for (x=0;x<icont;x++)
	{
		for(y=0;y<objEnvia.length;y++)
		{
			if (objEnvia[y].selected)
			{
				objRecebe.length++;
				objRecebe[objRecebe.length - 1].text = objEnvia[y].text;
				objRecebe[objRecebe.length - 1].value = objEnvia[y].value;
				objEnvia[y] = null;
			}
		}
	}

	for(x=0;x<objEnvia.length;x++)
		objEnvia[x].selected = false;
	for(x=0;x<objRecebe.length;x++)
		objRecebe[x].selected = false;

	// Ordeno o Resultado
	OrdenaSelect( objRecebe );
}

// Orderna Asc
function sortFuncAsc(record1, record2) {
    var value1 = record1.optText.toLowerCase();
    var value2 = record2.optText.toLowerCase();
    if (value1 > value2) return(1);
    if (value1 < value2) return(-1);
    return(0);
}

// Orderna Desc
function sortFuncDesc(record1, record2) {
    var value1 = record1.optText.toLowerCase();
    var value2 = record2.optText.toLowerCase();
    if (value1 > value2) return(-1);
    if (value1 < value2) return(1);
    return(0);
}

// Função de Ordenação
function OrdenaSelect(selectToSort, Ordem) {
	var ascendingOrder = false;
    if (arguments.length == 1) ascendingOrder = true;    // default to ascending sort

    // copy options into an array
    var myOptions = [];
    for (var loop=0; loop<selectToSort.options.length; loop++) {
        myOptions[loop] = { optText:selectToSort.options[loop].text, optValue:selectToSort.options[loop].value };
    }

    // sort array
    if (ascendingOrder) {
        myOptions.sort(sortFuncAsc);
    } else {
        myOptions.sort(sortFuncDesc);
    }

    // copy sorted options from array back to select box
    selectToSort.options.length = 0;
    for (var loop=0; loop<myOptions.length; loop++) {
        var optObj = document.createElement('option');
        optObj.text = myOptions[loop].optText;
        optObj.value = myOptions[loop].optValue;
        selectToSort.options.add(optObj);
    }
}

/***********************************************************************
* Função limiteCampo()
*
* Descrição: 	função verifica o tamanho máximo do campo na digitação
************************************************************************/
function limiteCampo(aocampo, aitamanho, asmsgErro)
{
	if(aocampo.value.length>=aitamanho)
	{
		alert(asmsgErro);
		window.event.keyCode=0;
		return false;
	}
	return true;
}

// Abre uma janela para verificar Ortografia
function NovaJanelaMenu ( sPagina, sTitulo )
{
	window.open (sPagina,sTitulo,'resizable=yes,menubar=yes,scrollbars=yes,width=750,height=600');
}

// Abre uma janela para o verificar ortografia
function AbrirVerificacaoOrtografica ( aoCampo, asMensagem )
{
	if ( aoCampo.value != '' )
	{
		var sPagina = 'conVerificacaoOrtografica.asp?texto=' + aoCampo.value;
		var sTitulo = 'VerificacaoOrtografica';

		NovaJanelaMenu ( sPagina, sTitulo );
	}
	else
	{
		alert( asMensagem );
		aoCampo.focus();
	}
}

//Retorna a data atual
function retornaData()
{
	var dtData = new Date();
	var sDia, sMes, sAno, sData

	sDia = dtData.getDate();
	sAno = dtData.getFullYear();
	sMes = dtData.getMonth() + 1;

	if ( sMes < 10 )
		sMes = '0' + sMes;

	if ( sDia < 10)
		sDia = '0' + sDia;

	sData = sDia + '/' + sMes + '/' + sAno;

	return sData;
}

//Substitui os caracteres "<" e ">" pelo seu código html
function HTMLEncode( asString )
{
	var i;
	var sRet='';

	for ( i=0; i<asString.length; i++)
	{
		aux = asString.substr(i,1);

		switch(aux)
		{
			case "<":
				sRet += "&lt;";
				break;
			case ">":
				sRet += "&gt;";
				break;
			default:
				sRet += aux;
		}
	}
	return sRet;
}

/***********************************************************************
* Funo fnVerificaResolucao()
*
* Descrio: 	função para setar o tamnho de um div dependendo da resolucao
*				do monitor
************************************************************************/
function fnVerificaResolucao(nomeiFrame)
{
	var oiFrame;
	var sAltura;

	oiFrame = document.getElementById(nomeiFrame);
	//alert(oiFrame);
	sAltura = screen.height;
	//alert(sAltura);
	if (sAltura <= '600') {
		oiFrame.style.height = 193;
		oiFrame.style.width  = 593;
	}else if (sAltura > '600' && sAltura <= '768') {
		oiFrame.style.height = 361;
		oiFrame.style.width  = 817;
	}else if (sAltura > '768' && sAltura <= '1024') {
		oiFrame.style.height = 610;
		oiFrame.style.width  = 1000;
	}
	else {
		oiFrame.style.height = 595;
		oiFrame.style.width  = 1000;
	}
}


/* ATIVA E DESATIVA A TAG SPAN*/
function toggleMenu(currMenu) {
	if (document.all) {
		thisMenu = eval("document.all." + currMenu + ".style")
		if (thisMenu.display == "block") {
			thisMenu.display = "none"
		}
		else {
			thisMenu.display = "block"
		}
		return false
	}
	else {
		return true
	}
}

function ToggleMenuMaisMenos(NomeMenu,ImagemMenu)
{
	if (document.all) {
		imagem = eval("document.all." + ImagemMenu)
		thismenu = eval("document.all." + NomeMenu + ".style")
		if (thismenu.display == "block") {
			thismenu.display = "none"
			imagem.src = "../IMG/botao_mais.gif"
		}
		else {
			thismenu.display = "block"
			imagem.src = "../IMG/botao_menos.gif"
		}
		return false
	}
	else {
		return true
	}
}

function retiraAlfaNumerico(oTexto)
{
	var sTexto= oTexto.value;
	var nTam = sTexto.length;
	var nAsc;
	var sTextoFinal = '';
	//alert(sTexto);
	if(nTam>0)
	{
		for(i=0;i<nTam;i++)
		{
			nAsc=sTexto.charCodeAt(i) ;
			if( (nAsc != 13) && (nAsc != 10) && !(nAsc>33 && nAsc<40))
			{
				sTextoFinal = sTextoFinal + sTexto.substr(i,1);
			}
		 }
	}

	oTexto.value = sTextoFinal;
	return true;
}
/***********************************************************************
* Função STamMax(oTextArea, Max)
*
* Descrição: 	Verifica os dados digitados no campo, se for maior truca.
*
************************************************************************/
function TamMax(oTextArea, Max)
{
	var length = oTextArea.value.length;
	var sAux;
	if (length > Max)	{
		sAux = oTextArea.value;
		oTextArea.value = sAux.substring(0,Max)
	}
}

/***********************************************************************
* Função fnStrVerificaTamMin(oTextArea, Min, peStrDescricao)
*
* Descrição: 	Verifica se o número de caracteres digitados no campo está de acordo com o mínimo
*               necessário, se for Menor exibe msg de erro.
*				ex. Campo ano, com no mínimo 4 dígitos
************************************************************************/
function fnStrVerificaTamMin(oTextArea, Min, peStrDescricao)
{
	var length = oTextArea.value.length;
	
	if (length < Min)	{		
		pagStrErro += '- O prenchimento mínimo para o campo [' + peStrDescricao + '] é de ' + Min + ' caracteres.\n';
		return false;
	}
	
	return true;
}

/***********************************************************************
* Função selecionarLinha(indiceLinha,cod,nomeTabela,nomeCampo,HiddenFieldName)
*
* Descrição: 	Seleciona a linha do grid quando clica no radioButton, jogando uma cor de fundo diferente.
*
************************************************************************/
//Esta Variável informa que não existe nenhuma selecionada no grid quando se entra na página.
linhaSelecionada = -1;

function selecionarLinha(indiceLinha,cod,nomeTabela,nomeCampo,HiddenFieldName)
{
	var tabela = document.all[nomeTabela];
	
	/*alert(indiceLinha);
	alert(cod);
	alert(nomeTabela);
	alert(nomeCampo);
	alert(HiddenFieldName);*/
	
	if (linhaSelecionada != indiceLinha)
	{
		if (linhaSelecionada != -1)
		{
			if (linhaSelecionada % 2 == 0)
			{
				tabela.rows(linhaSelecionada).className = "TabelaLinhaParConsulta";
			}
			else
			{
				tabela.rows(linhaSelecionada).className = "TabelaLinhaImParConsulta";
			}
		}

		if (eval("typeof(oFormulario." + nomeCampo + ".length) != \"undefined\""))
		{
			eval("oFormulario." + nomeCampo + "(indiceLinha).checked = true");
		}
		else
		{
			eval("oFormulario." + nomeCampo + ".checked = true");
		}

		tabela.rows(indiceLinha).className = "TabelaLinhaSelecionada";
		linhaSelecionada = indiceLinha;		
		HiddenFieldName.value = cod;
		
	}
}

/***********************************************************************
* Função selecionarLinha2(indiceLinha,cod,nomeTabela,nomeCampo,HiddenFieldName)
*
* Descrição: 	Seleciona a linha do grid quando clica no radioButton, jogando uma cor de fundo diferente.
*				OBS: ESTA É USADA QUANDO SE TEM DUAS TABELAS NA MESMA TELA EX: ISUP/Paradas de Produção
************************************************************************/
//Esta Variável informa que não existe nenhuma selecionada em nenhum grid quando se entra na página.
linhaSelecionada = -1;
tabelaSelecionada = '';

function selecionarLinha2(indiceCampo,indiceLinha,cod,nomeTabela,nomeCampo,HiddenFieldName)
{
	var tabela = document.all[nomeTabela];
	
	//alert('indiceLinha: ' + indiceLinha);
	//alert('cod: ' + cod);
	//alert('nomeTabela: ' + nomeTabela);
	//alert('tabelaSelecionada: ' + tabelaSelecionada);
	//alert('nomeCampo: ' + nomeCampo);
	//alert('HiddenFieldName: ' + HiddenFieldName);
	//alert('linhaSelecionada: ' + linhaSelecionada);
	
	//Se Trocou de tabela, zera tudo
	if((tabelaSelecionada != nomeTabela) && (tabelaSelecionada != '')){		
		var tabelaOld = document.all[tabelaSelecionada];
		
		if (linhaSelecionada % 2 == 0)
		{			
			tabelaOld.rows(linhaSelecionada).className = "TabelaLinhaParConsulta";
		}
		else
		{			
			tabelaOld.rows(linhaSelecionada).className = "TabelaLinhaImParConsulta";
		}
		
		linhaSelecionada = -1;
	}
	
	if (linhaSelecionada != indiceLinha)
	{
		if (linhaSelecionada != -1)
		{			
			if (linhaSelecionada % 2 == 0)
			{				
				tabela.rows(linhaSelecionada).className = "TabelaLinhaParConsulta";
			}
			else
			{				
				tabela.rows(linhaSelecionada).className = "TabelaLinhaImParConsulta";
			}
		}

		if (eval("typeof(oFormulario." + nomeCampo + ".length) != \"undefined\""))
		{
			eval("oFormulario." + nomeCampo + "(indiceCampo).checked = true");
		}
		else
		{
			eval("oFormulario." + nomeCampo + ".checked = true");
		}

		tabela.rows(indiceLinha).className = "TabelaLinhaSelecionada";
		linhaSelecionada = indiceLinha;		
		tabelaSelecionada = nomeTabela;
		HiddenFieldName.value = cod;
				
	}
}


/***********************************************************************
* Função MascaraDataTempoReal(oData)
*
* Descrição: 	Coloca a máscara d/mm/aaaa em campos do tipo data
*
************************************************************************/

function MascaraDataTempoReal(oData){

	if (oData.value.length == 2){
		oData.value = oData.value + "/";
	}
	if (oData.value.length == 5){
		oData.value = oData.value + "/";
	}
}

/***********************************************************************
* Função MascaraHoraTempoReal(oHora)
*
* Descrição: 	Coloca a máscara hh:mm em campos do tipo Hora
*
************************************************************************/

function MascaraHoraTempoReal(oHora){
	
	if (oHora.value.length == 2){
		oHora.value = oHora.value + ":";
	}
	if (oHora.value.length == 5){
		oHora.value = oHora.value + ":00";
	}
}

/***********************************************************************
* Função fnStrVerificaHora(oHora)
*
* Descrição: 	Verifica se hora é válida, recebendo no formato HH:MM:SS ou HH:MM
*
************************************************************************/
function fnStrVerificaHora(peStrCampo, peStrDescricao, peStrMensagemOpcional){
	
	var sHora = peStrCampo.value.toString().substr(0, 2);	
	var sMinuto = peStrCampo.value.toString().substr(3, 2);
	var sSegundo = peStrCampo.value.toString().substr(6, 2);
	var sErro = "";
		
		
	if(sHora != '') {
		
		if (!fnStrVerificaCampoNumerico(sHora)){			
			sErro =  sErro + "  A hora possui caracteres não numéricos\n";
			if (peStrMensagemOpcional == '')
			{
				pagStrErro += "- A hora inserida no campo [" + peStrDescricao + "] é inválida!\n  Motivo(s):\n " + sErro;
			}
			else
			{
				pagStrErro += peStrMensagemOpcional + '\n';
			}
			
			return false;
		}
				
		var iHora = parseInt(sHora);
		
		if (iHora > 23){
			sErro =  sErro + "  Hora maior que 24\n";
		}	
		
	}
	
	if(sMinuto != '') {
		if (!fnStrVerificaCampoNumerico(sMinuto)){
			sErro = sErro + "  A hora possui caracteres não numéricos\n";
			if (peStrMensagemOpcional == '')
			{
				pagStrErro += "- A hora inserida no campo [" + peStrDescricao + "] é inválida!\nMotivo: " + sErro;
			}
			else
			{
				pagStrErro += peStrMensagemOpcional + '\n';
			}
			
			return false;
		}
		
		var iMinuto = parseInt(sMinuto);
		
		if (iMinuto > 59){
			sErro =  sErro + "  Minutos maior que 59\n";			
		}		
	}
	
	if(sSegundo != '') {
		
		if (!fnStrVerificaCampoNumerico(sSegundo)){
			sErro =  sErro + "  A hora possui caracteres não numéricos\n";
			if (peStrMensagemOpcional == '')
			{
				pagStrErro += "- A hora inserida no campo [" + peStrDescricao + "] é inválida!\nMotivo: " + sErro;
			}
			else
			{
				pagStrErro += peStrMensagemOpcional + '\n';
			}
			
			return false;
		}
		
		var iSegundo = parseInt(sSegundo);
		
		if (iSegundo > 59){
			sErro =  sErro + "  Segundos maior que 59\n";			
		}	
	}
	
	if (sErro != ""){
		if (peStrMensagemOpcional == '')
		{
			pagStrErro += "- A hora inserida no campo [" + peStrDescricao + "] é inválida!\nMotivo:\n" + sErro;
		}
		else
		{
			pagStrErro += peStrMensagemOpcional + '\n';
		}
		return false;
	}
	
	return true;
}

/***********************************************************************
* Função PulaProximoCampo(iTamanhoCampo, oOrigem, oDestino){
*
* Descrição: 	Passa o cursor para o próximo campo, quando o número máximo caracteres foi atingido
*
************************************************************************/

function PulaProximoCampo(iTamanhoCampo, oOrigem, oDestino){
	if (oOrigem.value.length == iTamanhoCampo){
		oDestino.focus();
	}
}

/***********************************************************************
* Função FormataValorNumerico()
*
* Descrição: 	Controla a máscara para campos de valores do tipo moeda
*
* Chamada:		onKeyPress="javascript:return fnOnBlurMoeda();"
************************************************************************/
function FormataValorNumerico(Valor)
{
	
	if(isNaN(Valor.value) || parseFloat(Valor.value) < 0 || Trim(Valor.value) == ''){
		Valor.value = '';	
		return false;
	}

	var iValorNumeico = new String();
	var teste = new String();
	var VetValor;
	var sFlogCondigcao = '';
	var valorNumber = new String() ;
	var VetNumeros = new Array();
	var VetNumeros1 = new Array();
	var z = 1;
	var aux = '';
	iValorNumeico = Valor.value;
	for (i=0;i<1000;i++)
	{
		iValorNumeico = iValorNumeico.replace(' ','');
	}
	if (iValorNumeico.length > 0 )
	{
		if (iValorNumeico.substr(0,1) == '-' )
		{
			sFlogCondigcao = '-';
		}
	}

	iValorNumeico = iValorNumeico + ',00';
	VetValor = iValorNumeico.split(',') ;

	aux = VetValor[1]
	VetValor[1] = ''
	for (i=0;i<aux.length;i++)
	{
			if ( (! isNaN(aux.substr(i,1))) || (! aux.substr(i,1) == '.') || (! aux.substr(i,1) == '-'))
			{
			VetValor[1] +=  aux.substr(i,1);
			}
	}
	VetValor[1]  = VetValor[1] + '00'
	VetValor[1]  = VetValor[1].substr(0,2)

	for (i=0;i<= VetValor[0].length - 1 ;i++)
	{	
		if ( (! isNaN(VetValor[0].substr(i,1))) || (! VetValor[0].substr(i,1) == '.'))
		{
				VetNumeros[i] =  VetValor[0].substr(i,1);
		}
	}

	aux = '';
	for (i=VetNumeros.length-1;i>=0;i--)
	{	
		if ( (! isNaN(VetNumeros[i])) || (! VetNumeros[i] == '.'))
		{
			if (z == 3 )
			{
				aux = aux + VetNumeros[i];
				if ( i > 0 )
				{
				aux = aux + '';
				}
				z=0;
			}
			else
			{
				aux = aux + VetNumeros[i];
			}
			z++;	
		}
	}
	//INVERTE A STRING
	for (i=0;i<= aux.length - 1 ;i++)
	{	
		VetNumeros1[i] =  aux.substr(i,1);
	}
	//ZERA A VERIAVEL "AUX"
	aux='';
	//PERCORRRE O VETOR MONTANDO A STRING DE RETORNO
	for (i=VetNumeros1.length-1;i>=0;i--)
	{		
		aux = aux + VetNumeros1[i];
	}

	Valor.value = sFlogCondigcao + aux + ',' +  VetValor[1];
}

/***********************************************************************
* Função dateDiff(p_Interval, p_Date1, p_Date2)
*
* Descrição: 	Diferença entre datas
*
************************************************************************/
function isDate(p_Expression){
	return !isNaN(new Date(p_Expression));		// >>--- this needs checking
}

function dateDiff(p_Interval, p_Date1, p_Date2)
	{
		
		if(!isDate(p_Date1)){return "Data Inválida: '" + p_Date1 + "'";}
		if(!isDate(p_Date2)){return "Data Inválida: '" + p_Date2 + "'";}
	
		var dt1 = new Date(p_Date1.substr(6,4),p_Date1.substr(3,2)-1,p_Date1.substr(0,2));
		var dt2 = new Date(p_Date2.substr(6,4),p_Date2.substr(3,2)-1,p_Date2.substr(0,2));
	
		// get ms between dates (UTC) and make into "difference" date
		var iDiffMS = dt2.valueOf() - dt1.valueOf();
		var dtDiff = new Date(iDiffMS);
	
		// calc various diffs
		var nYears  = dt2.getYear() - dt1.getYear();
		var nMonths = dt2.getMonth() - dt1.getMonth() + (nYears!=0 ? nYears*12 : 0);
		var nQuarters = parseInt(nMonths/3);	//<<-- different than VBScript, which watches rollover not completion
		
		var nMilliseconds = iDiffMS;
		var nSeconds = parseInt(iDiffMS/1000);
		var nMinutes = parseInt(nSeconds/60);
		var nHours = parseInt(nMinutes/60);
		var nDays  = parseInt(nHours/24);
		var nWeeks = parseInt(nDays/7);
				
		// return requested difference
		var iDiff = 0;		
		switch(p_Interval.toLowerCase()){
			case "yyyy": return nYears;
			case "q": return nQuarters;
			case "m": return nMonths;
			case "y": 		// day of year
			case "d": return nDays;
			case "w": return nDays;
			case "ww":return nWeeks;		// week of year	// <-- inaccurate, WW should count calendar weeks (# of sundays) between
			case "h": return nHours;
			case "n": return nMinutes;
			case "s": return nSeconds;
			case "ms":return nMilliseconds;	// millisecond	// <-- extension for JS, NOT available in VBScript
			
			
			default: return "invalid interval: '" + p_Interval + "'";
		}
		
	}	
	
//****************************************************************************************	

function dateDiffBrasil(p_Interval, p_Date1, p_Date2, tipo)
{
	
	//alert(p_Interval);
	//alert(p_Date1);
	//alert(p_Date2);
	//alert("tipo: " + tipo);
	
	
	if(tipo=="D"){
		//Date
		if(!isDate(p_Date1)){return "Data Inválida: '" + p_Date1 + "'";}
		if(!isDate(p_Date2)){return "Data Inválida: '" + p_Date2 + "'";}
		
		var dt1 = new Date(p_Date1.substr(6,4),p_Date1.substr(3,2),p_Date1.substr(0,2));
		var dt2 = new Date(p_Date2.substr(6,4),p_Date2.substr(3,2),p_Date2.substr(0,2));
	}
	
	if(tipo=="T"){
		//Time
		
		if(!isDate(p_Date1)){return "Data Inválida: '" + p_Date1 + "'";}
		if(!isDate(p_Date2)){return "Data Inválida: '" + p_Date2 + "'";}
				
		//alert(p_Date1.substr(6,4) + p_Date1.substr(3,2)-1 + p_Date1.substr(0,2) +  p_Date1.substr(11,2) +  p_Date1.substr(14,2) +  p_Date1.substr(17,2));
		//alert(p_Date2.substr(6,4) + p_Date2.substr(3,2)-1 + p_Date2.substr(0,2) +  p_Date2.substr(11,2) +  p_Date2.substr(14,2) +  p_Date2.substr(17,2));
		
		//new Date(ano,mês,dia,hora,minutos,segundos)
		var dt1 = new Date(p_Date1.substr(6,4),p_Date1.substr(3,2),p_Date1.substr(0,2), p_Date1.substr(11,2), p_Date1.substr(14,2), p_Date1.substr(17,2));
		var dt2 = new Date(p_Date2.substr(6,4),p_Date2.substr(3,2),p_Date2.substr(0,2), p_Date2.substr(11,2), p_Date2.substr(14,2), p_Date2.substr(17,2));
	}

	
		
	// get ms between dates (UTC) and make into "difference" date
	var iDiffMS = dt2.valueOf() - dt1.valueOf();
	var dtDiff = new Date(iDiffMS);

	// calc various diffs
	var nYears  = dt2.getYear() - dt1.getYear();
	var nMonths = dt2.getMonth() - dt1.getMonth() + (nYears!=0 ? nYears*12 : 0);
	var nQuarters = parseInt(nMonths/3);	//<<-- different than VBScript, which watches rollover not completion
	
	var nMilliseconds = iDiffMS;
	var nSeconds = parseInt(iDiffMS/1000);
	var nMinutes = parseInt(nSeconds/60);
	var nHours = parseInt(nMinutes/60);
	var nDays  = parseInt(nHours/24);
	var nWeeks = parseInt(nDays/7);
		
	// return requested difference
	var iDiff = 0;		
	switch(p_Interval.toLowerCase()){
		case "yyyy": return nYears;
		case "q": return nQuarters;
		case "m": return nMonths;
		case "y": 		// day of year
		case "d": return nDays;
		case "w": return nDays;
		case "ww":return nWeeks;		// week of year	// <-- inaccurate, WW should count calendar weeks (# of sundays) between
		case "h": return nHours;
		case "n": return nMinutes;
		case "s": return nSeconds;
		case "ms":return nMilliseconds;	// millisecond	// <-- extension for JS, NOT available in VBScript
		
		
		default: return "invalid interval: '" + p_Interval + "'";
	}
	
}

function dateDiffBrasil2(p_Interval, p_Date1, p_Date2, p_Hora1, p_Hora2, tipo)
{
	
	//alert(p_Interval);
	//alert(p_Date1);
	//alert(p_Date2);
	//alert("tipo: " + tipo);
	
	
	if(tipo=="D"){
		//Date
		if(!isDate(p_Date1)){return "Data Inválida: '" + p_Date1 + "'";}
		if(!isDate(p_Date2)){return "Data Inválida: '" + p_Date2 + "'";}
		
		var dt1 = new Date(p_Date1.substr(6,4),p_Date1.substr(3,2)-1,p_Date1.substr(0,2));
		var dt2 = new Date(p_Date2.substr(6,4),p_Date2.substr(3,2)-1,p_Date2.substr(0,2));
	}
	
	if(tipo=="T"){
		//Time
		
		if(!isDate(p_Date1)){return "Data Inválida: '" + p_Date1 + "'";}
		if(!isDate(p_Date2)){return "Data Inválida: '" + p_Date2 + "'";}
				
		
		//new Date(ano,mês,dia,hora,minutos,segundos)		
		var dt1 = new Date(p_Date1.substr(6,4),p_Date1.substr(3,2)-1,p_Date1.substr(0,2),"09","00","00");
		var dt2 = new Date(p_Date2.substr(6,4),p_Date2.substr(3,2)-1,p_Date2.substr(0,2),"10","00","00");
	}

	
		
	// get ms between dates (UTC) and make into "difference" date
	var iDiffMS = dt2.valueOf() - dt1.valueOf();
	var dtDiff = new Date(iDiffMS);

	// calc various diffs
	var nYears  = dt2.getYear() - dt1.getYear();
	var nMonths = dt2.getMonth() - dt1.getMonth() + (nYears!=0 ? nYears*12 : 0);
	var nQuarters = parseInt(nMonths/3);	//<<-- different than VBScript, which watches rollover not completion
	
	var nMilliseconds = iDiffMS;
	var nSeconds = parseInt(iDiffMS/1000);
	var nMinutes = parseInt(nSeconds/60);
	var nHours = parseInt(nMinutes/60);
	var nDays  = parseInt(nHours/24);
	var nWeeks = parseInt(nDays/7);
		
	// return requested difference
	var iDiff = 0;		
	switch(p_Interval.toLowerCase()){
		case "yyyy": return nYears;
		case "q": return nQuarters;
		case "m": return nMonths;
		case "y": 		// day of year
		case "d": return nDays;
		case "w": return nDays;
		case "ww":return nWeeks;		// week of year	// <-- inaccurate, WW should count calendar weeks (# of sundays) between
		case "h": return nHours;
		case "n": return nMinutes;
		case "s": return nSeconds;
		case "ms":return nMilliseconds;	// millisecond	// <-- extension for JS, NOT available in VBScript
		
		
		default: return "invalid interval: '" + p_Interval + "'";
	}
	
}

/***********************************************************************
* Função fnEvnEntradaNumNegativo()
*
* Descrição: 	Controla a máscara para campos de valores do tipo negativo ou não
*
* Chamada:		onKeyPress="javascript:return fnEvnEntradaNumNegativo();"
************************************************************************/
function fnEvnEntradaNumNegativo(peStrCampo, peStrMil, peStrDec, peMaxCampo)
{
	e = event;

	var sep = 0;
	var key = '';
	var i = j = 0;
	var len = len2 = 0;
	var strCheck = '0123456789' + '-';
	var aux = aux2 = '';
	var whichCode = (window.Event) ? e.which : e.keyCode;
	var iFlag = 0;
	
	if (whichCode == 13) return true;  // Enter
	key = String.fromCharCode(whichCode);  // Get key value from key code
	if (strCheck.indexOf(key) == -1) return false;  // Not a valid key
	len = peStrCampo.value.length;
	for(i = 0; i < len; i++)
		if ((peStrCampo.value.charAt(i) != '0') && (peStrCampo.value.charAt(i) != peStrDec)) break;
	
	aux = '';
	
	/*for (i=0 ; i < len; i++)
      {
        	 if(peStrCampo.value.charAt(i) == '-'){
        		iFlag = '1'
        	 }
      }*/
    
    if(peStrCampo.value.indexOf('-') != -1 )
	{
		peMaxCampo = peMaxCampo + 1
	}
    
	for(; i < len; i++)
	if (strCheck.indexOf(peStrCampo.value.charAt(i))!=-1) aux += peStrCampo.value.charAt(i);
	aux += key;
	len = aux.length;
	if (len == 0) peStrCampo.value = '';
	if (len == 1) peStrCampo.value = '0'+ peStrDec + '0' + aux;
	if (len == 2) peStrCampo.value = '0'+ peStrDec + aux;
	
	if (len < peMaxCampo)
	{
		if (len > 2)
		{
			aux2 = '';
			for (j = 0, i = len - 3; i >= 0; i--)
			{
				if (j == 3)
				{
					aux2 += peStrMil;
					j = 0;
				}
				aux2 += aux.charAt(i);
				j++;
			}
			peStrCampo.value = '';
			len2 = aux2.length;
			for (i = len2 - 1; i >= 0; i--)
			peStrCampo.value += aux2.charAt(i);
			peStrCampo.value += peStrDec + aux.substr(len - 2, len);
		}
	}
	else
	{
		return false;
	}
	return false;
}