/*
    Programador: Leonardo Caldeira
    Data.......: 27/08/2007
    Descrição..: Este arquivo foi criado com o intúito de centralizar em um único arquivo as funções
                 utilizadas no desenvolvimento das páginas.
                 A idéia é acabar com o problema de ter a mesma função com nomes diferentes em arquivos diferentes e chamadas
                 de maneira diferente por diferentes arquivos, ou seja, tornando quase impossível sua manutenção.
    Observação.: Ao adicionarem outras funções, favor documentá-las de maneira clara ao entendimento de todos.
*/

//Constantes de uso geral
var cstObject = 'object';
var cstFunction = 'function';
var cstBoolean = 'boolean';
var cstCheckBox = 'checkbox';

// Função para anexar includes javascript à página
function AnexarObjeto(strFonte)
{
    var objElementoScript = document.createElement('script');
    var arrOpcaoTAGAnexo = new Array('head', 'body', 'form', 'div', 'span');

    objElementoScript.setAttribute('language', 'javascript');
    objElementoScript.setAttribute('type', 'text/javascript');
    objElementoScript.setAttribute('src', strFonte);

    // Tenta anexar o include à página.
    for(var lngCont = 0; lngCont < arrOpcaoTAGAnexo.length; lngCont++ )
    {
        var objTag = document.getElementsByTagName(arrOpcaoTAGAnexo[lngCont])[0];
        try
        {
            if (objTag){
                objTag.appendChild(objElementoScript);
                break;
            }
        }
        catch(err)
        {
        }
    }
}

/*
    Função para limitar o uso de teclas desnessárias em certos campos.
    Não implementei a permissão dos caracteres alfabéticos, pois, o uso principal dessa função é em campos onde só se pode digitar
    números, e não estou com tempo agora para fazer essa implementação. Mais não a nada que impeça sua codificação mais tarde.
    IMPORTANTE
    A função deve ser chamada no evento ONKEYDOWN, pelo seguinte motivo:
    O IE só valida os digitos por keyCode on evento onkeydown, no evento onkeypress a validação é feita por caracter ascii.
    Com isso não possível validar por exemplo as teclas de setas, home, end, etc.
    Para termos o código dessas teclas, a função tem de ser chamada no evento onkeydown.
    Outra coisa importante, no evento onkeydown onde a validação é feita por keyCode, as teclas numéricas do teclado alfa, e do teclado numérico
    são diferentes: Por exemplo, o "1" do teclado alfa, ou seja, que está em cima do "Q", tem o código 49,
    já no teclado numérico esse código é 105.
    É por isso que quando a função era chamada no evento onkeypress, letras eram liberadas, pois nesse evento a validação é feita pelo caractere ascii, e nesse caso
    o código referente ao "1" dos dois teclados é o mesmo, 49.
*/

//objIdioma
atachamentoDinamico("objIdioma", "Globalizacao/objIdioma.js");
//CaixaMensagem
atachamentoDinamico("InicializarCaixaMensagem", "Recursos/CaixaMensagem/CaixaMensagem.js");

function PermitirCaracteres(objEvento, blnNumeros, strPermitidas)
{
    var objFrameWork    = new LEBJSFrameWork();
    var lngCaracter     = 0;
    var strCaracter     = '';
    var blnRetorno      = false;
    var blnTeclaControl = false;
    var blnTeclaShift   = false;
    var cstTipoBoolen   = "boolean";

    // Recuperando o keyCode da tecla.
    if(objEvento.keyCode)
    {
        lngCaracter = objEvento.keyCode;
    }
    else if(objEvento.which)
    {
        lngCaracter = objEvento.which;
    }
    else if(objEvento.charCode)
    {
        lngCaracter = objEvento.charCode;
    }
    else
    {
        lngCaracter = void(0);
    }

    // Valor booleano que indica se as teclas Shift e/ou Control estão pressionadas.
    blnTeclaControl = objEvento.ctrlKey;
    blnTeclaShift   = objEvento.shiftKey;

    // Permitir o uso de CTRL com as teclas C, V, X e A.
    strCaracter = String.fromCharCode(lngCaracter).toUpperCase();
    var objExpressaoRegular = /^[CVXA]$/;
    if(blnTeclaControl && objExpressaoRegular.test(strCaracter))
    {
        blnRetorno = true;
    }

    /*
    Permissão de teclas pré-definidas para liberdade de navegação dentro do campo:
    8 - Backspace
    9 - TAB
    45 - Insert
    46 - Delete
    36 - Home
    35 - End
    37 - Seta Esquerda
    39 - Seta Direita

    Vou validar estas teclas separadamente, pois algumas teclas requerem certas particularidades.
    O Backspace pode ser utilizado sozinho ou com em conjunto com o CTRL.
    */
    if((!blnTeclaShift) && lngCaracter == 8)
    {
        blnRetorno = true;
    }

    // O Insert e o Delete não podem ser usados em combinação com outras teclas.
    var objExpressaoRegular = /^(45|46)$/;
    if((!(blnTeclaControl || blnTeclaShift)) && objExpressaoRegular.test(lngCaracter))
    {
        blnRetorno = true;
    }

    // As outras teclas podem ser usadas sem restrições.
    var objExpressaoRegular = /^(9|35|36|37|39)$/;
    if(objExpressaoRegular.test(lngCaracter))
    {
        blnRetorno = true;
    }

    /*
    Permitir caracteres numéricos.
    O tratamento do tipo boolean:
        Permitir o acesso a função somente se o valor da variável for True.
    O tratamento de tecla Shift pressionada.
        Restringir a digitação de !@#$%¨&*().
    O tratamento da tecla CTRL pressionada.
        Restringir no IE 7 a mudança de abas.
    */
    if(blnNumeros && typeof(blnNumeros) == cstTipoBoolen)
    {
        var objExpressaoRegular = /^(4[8-9]|5[0-7]|9[6-9]|10[0-5])$/;
        if((!(blnTeclaShift || blnTeclaControl)) && objExpressaoRegular.test(lngCaracter))
        {
            blnRetorno = true;
        }
    }

    // Permitir outras teclas informadas pelo programador, como por exemplo, virgulas e pontos.
    if(!objFrameWork.pIsEmpty(strPermitidas))
    {
        strPermitidas = strPermitidas.replace(/\s/g, '');
        strPermitidas = strPermitidas.replace(/^[,]|[,]$/g, '');
        if(!objFrameWork.pIsEmpty(objFrameWork.pTrim(strPermitidas)))
        {
            var arrPermitidas = strPermitidas.split(',');
            for(var i = 0; i < arrPermitidas.length; i++)
            {
                if(arrPermitidas[i].indexOf("16+") >= 0){
                    arrPermitidas[i] = arrPermitidas[i].split("+")[1];                    
                    if(blnTeclaShift && lngCaracter == arrPermitidas[i])
                    {
                        blnRetorno = true;
                        break;
                    }     
                }else{
                    if((!blnTeclaShift) && lngCaracter == arrPermitidas[i])
                    {
                        blnRetorno = true;
                        break;
                    }
                }
            }
        }
    }

    // Caso a tecla ou combinação de teclas seja permitida, sai da função.
    if(blnRetorno)
    {
        return blnRetorno
    }

    try
    {
        objEvento.returnValue  = false;
        objEvento.cancelBubble = true;

        if(document.all)
        {
            objEvento.keyCode = 0;
        }
        else
        {
            objEvento.preventDefault();
            objEvento.stopPropagation();
        }
    }
    catch(err)
    {
    }
    return blnRetorno;
}

//Função para formatar um campo data
function FormataData(Campo, teclapres, blnPodeEditarReadOnly)
{
	teclapres = ( teclapres == 0 ? event.keyCode : teclapres );
    
    Campo = ( typeof(Campo) == "string" ? document.getElementById(Campo) : Campo );
    if( Campo.readOnly && blnPodeEditarReadOnly != true ) {
        alert('O calendário não pode ser exibido pois o campo de destino está definido como somente leitura.');
        return;
    }

	// Teclas H h + -
    if( teclapres == 72 || teclapres == 104 || teclapres == 43 || teclapres == 45 || teclapres == 107 || teclapres == 109 ) {

	    vr = Campo.value;
	    vr = vr.replace(".","/");
	    vr = vr.replace("-","/");
	    
        if( VerificaData( vr ) ) {
            if( teclapres == 72 || teclapres == 104 ) {
                Campo.value = montaDataFormatada(formataNewDate());
                return true;
            }
            if( teclapres == 43 || teclapres == 45 || teclapres == 107 || teclapres == 109 ) {
                if( Campo.value !="" ) {
                    Campo.value = montaDataFormatada(Calcula_Data( vr, 1, (teclapres==43||teclapres==107?true:false) ));
                    return true;
                } else {
                    var strDataAdicionaSubtrai = montaDataFormatada(formataNewDate());
                    strDataAdicionaSubtrai = Calcula_Data( strDataAdicionaSubtrai, 1, (teclapres==43||teclapres==107?true:false) );
                    Campo.value = montaDataFormatada(strDataAdicionaSubtrai);
                    return true;
                }
            }
        }
    }

	vr = Campo.value;
	vr = vr.replace(".","");
	vr = vr.replace("-","");
	vr = vr.replace("/","");
	tam = vr.length + 1;

	if (teclapres!=9 && teclapres!=8 && teclapres!=111 && teclapres!=223 && teclapres!=47)
	{
		if (tam==3)
			Campo.value = vr.substr(0,2) + '/' + vr.substr(5,tam);
		if (tam==5){
			Campo.value = vr.substr(0,2) + '/' + vr.substr(2,2) + '/' + vr.substr(5,tam)};
	}
}
/**************************************************************************************************************
Formata a data com zeros a esquerda => 01/01/2007 <=
@strData = '1/1/2007'
**************************************************************************************************************/
function montaDataFormatada( strData ) {
    
	strData = strData.replace(".","/");
	strData = strData.replace("-","/");
    
    var strDiaFormatado = ( 100 + parseInt(Dia(strData)) ).toString().substring(1,3);
    var strMesFormatado = ( 100 + parseInt(Mes(strData)) ).toString().substring(1,3);
    var strAnoFormatado = ( 10000 + parseInt(Ano(strData)) ).toString().substring(1,5);

    return dataFormatada = strDiaFormatado + "/" + strMesFormatado + "/" + strAnoFormatado;
}
/**************************************************************************************************************
Retorna a data do objeto new Date() (Retorno: 1/1/2007)
Depois é só enviar para montaDataFormatada( formataNewDate() )
**************************************************************************************************************/
function formataNewDate() { 
    newDate = new Date();
    return newDate.getDate() + "/" + parseInt(newDate.getMonth()+1) + "/" + newDate.getFullYear();
}

/**************************************************************************************************************
Soma ou subtrai dias de uma data teclando "+" ou "-"
Obs.: Enviar a data DD/MM/YYYY formatada obrigatoriamente, para formatar use montaDataFormatada( '1/1/2007' )
@data_DDMMYYYY: 01/01/2007
@dias: X (numérico)
@adicao: true/false
**************************************************************************************************************/
function Calcula_Data(data_DDMMYYYY,dias,adicao){

    Var_Dia=Dia(data_DDMMYYYY);
    Var_Mes=Mes(data_DDMMYYYY);
    Var_Mes=Math.floor(Var_Mes)-1;
    Var_Ano=Ano(data_DDMMYYYY);
    
    var data = new Date(Var_Ano,Var_Mes,Var_Dia);

    if (adicao == true)
    {
        var diferenca = data.getTime() + (dias * 1000 * 60 * 60 * 24);
    }
    else
    {
        var diferenca = data.getTime() - (dias * 1000 * 60 * 60 * 24);
    }
    
    var diferenca = new Date(diferenca);
    return diferenca.getDate()+'/'+(parseInt(diferenca.getMonth())+1)+'/'+diferenca.getFullYear();

}
/**************************************************************************************************************
Calcula a diferença de dias entre duas datas
@data1_DDMMYYYY: 01/01/2007
@data2_DDMMYYYY: 31/12/2007
**************************************************************************************************************/
function Calcula_Dias(data1_DDMMYYYY,data2_DDMMYYYY){

    Var_Dia1=Dia(data1_DDMMYYYY);
    Var_Mes1=Mes(data1_DDMMYYYY);
    Var_Mes1=Math.floor(Var_Mes1)-1;
    Var_Ano1=Ano(data1_DDMMYYYY);
    var data1 = new Date(Var_Ano1,Var_Mes1,Var_Dia1);

    Var_Dia2=Dia(data2_DDMMYYYY);
    Var_Mes2=Mes(data2_DDMMYYYY);
    Var_Mes2=Math.floor(Var_Mes2)-1;
    Var_Ano2=Ano(data2_DDMMYYYY);
    var data2 = new Date(Var_Ano2,Var_Mes2,Var_Dia2);

    var diferenca = data1.getTime() - data2.getTime();
    var diferenca = Math.floor(diferenca / (1000 * 60 * 60 * 24));
    
    return diferenca;
}
/**************************************************************************************************************
Retorna o DIA de uma campo data (DD/MM/YYYY)
@Data_DDMMYYYY: 01/01/2007
**************************************************************************************************************/
function Dia(Data_DDMMYYYY)
{
    strData = Data_DDMMYYYY.toString();
    strData = Data_DDMMYYYY.replace("-","/").replace(".","/");
    posicao_barra = strData.indexOf("/");
    
    if (posicao_barra!= -1) {
        dia = strData.substring(0,posicao_barra);
        return dia;
    } else {
        return false;
    }
}
/**************************************************************************************************************
Retorna o MÊS de uma campo data (DD/MM/YYYY)
@Data_DDMMYYYY: 01/01/2007
**************************************************************************************************************/
function Mes(Data_DDMMYYYY)
{
    strData = Data_DDMMYYYY.toString();
    strData = Data_DDMMYYYY.replace("-","/").replace(".","/");    
    posicao_barra = strData.indexOf("/");
    if (posicao_barra!= -1) {
        dia = strData.substring(0,posicao_barra);
        strMes = strData.substring(posicao_barra+1,strData.length);
        posicao_barra = strMes.indexOf("/");

        if (posicao_barra!= -1) {
            mes = strMes.substring(0,posicao_barra);
            mes = Math.floor(mes);
            return mes;
        } else {
            return false;
        }
    } else {
        return false;
    }
}
/**************************************************************************************************************
Retorna o ANO de uma campo data (DD/MM/YYYY)
@Data_DDMMYYYY: 01/01/2007
**************************************************************************************************************/
function Ano(Data_DDMMYYYY)
{
    strData = Data_DDMMYYYY.toString();
    strData = Data_DDMMYYYY.replace("-","/").replace(".","/");    
    posicao_barra = strData.indexOf("/");

    if (posicao_barra!= -1) {
        dia = strData.substring(0,posicao_barra);
        strMes = strData.substring(posicao_barra+1,strData.length);
        posicao_barra = strMes.indexOf("/");
    
        if (posicao_barra!= -1) {
            mes = strMes.substring(0,posicao_barra);
            mes = Math.floor(mes);
            ano = strMes.substring(posicao_barra+1,strMes.length);
            return ano;
        } else {
            return false;
        }

    } else {
        return false;
    }
}

/*
    Função para atualização de valor relacionado a tamanho em Kilo Bytes.
    Sinal....: "+", ou "-", indica a operação a ser efetuada.
    lngAtual.: Valor numérico a ser atualizado.
    lngPasso.: Valor numérico a ser acrescido ou retirado do valor atual.
    lngLimite: Valor numérico que indica o tamanho máximo que valor atual pode atingir.
    Caso o cálculo possa e tenha sido realizado sem erros o resultado é retornado, caso contrário
    o valor atual é retornado.
*/
function AtualizarTamanhoKBytes(strSinal, lngAtual, lngPasso, lngLimite)
{
    try
    {
        lngPasso  *= 1024;
        lngLimite *= 1024;

        if((lngAtual > 0 && strSinal == '-') || (lngAtual < lngLimite && strSinal == '+'))
        {
            var lngValor = eval(lngAtual + strSinal + lngPasso);

            if(lngValor <= 0)
            {
                lngValor = 0;
            }
            if(lngValor >= lngLimite)
            {
                lngValor = lngLimite;
            }

            return lngValor;
        }
        return lngAtual;
    }
    catch(err)
    {
        return lngAtual;
    }
}

/*
    Função para redimensionamento de imagens.
    strNomeImagens..: ID da imagem a ser redimensionada. Pode ser passada uma string com vários ID's. Ex: 'imgTeste1;imgTeste2;imgTeste3;imgTeste4'
    lngAlturaPadrao.: Altura máxima que a imagem poderá ter. Ex: 150.
    lngLarguraPadrao: Largura máxima que a imagem poderá ter. Ex: 150.
*/
function RedimensionarImagens(strNomeImagens, lngAlturaPadrao, lngLarguraPadrao)
{
    var objFrameWork          = new LEBJSFrameWork();
    var lngDiferencaAltura    = 0;
    var lngPorcentagemReducao = 0;
    var lngDiferencaLargura   = 0;
    var lngAlturaImagem       = 0;
    var lngLarguraImagem      = 0;

    if((!objFrameWork.pIsEmpty(objFrameWork.pTrim(strNomeImagens))) && objFrameWork.pIsNumeric(lngAlturaPadrao) && lngAlturaPadrao >= 0 && objFrameWork.pIsNumeric(lngLarguraPadrao) && lngLarguraPadrao >= 0)
    {
        var arrNomeImagens = strNomeImagens.split(';');

        for(var lngCont = 0; lngCont < arrNomeImagens.length; lngCont++)
        {
            var objImagem = document.getElementById(arrNomeImagens[lngCont]);

            if(objFrameWork.pIsObject(objImagem))
            {
                lngAlturaImagem  = objImagem.height;
                lngLarguraImagem = objImagem.width;

                // Se a altura da imagem for maior que a altura padrão
                // começa a reduzir a imagem tirando como base a altura.
                if(lngAlturaImagem > lngAlturaPadrao)
                {
                    // Diferença entre as alturas.
                    lngDiferencaAltura = lngAlturaImagem - lngAlturaPadrao;
                    // Percentual de redução da altura.
                    lngPorcentagemReducao = (lngDiferencaAltura * 100) / lngAlturaImagem;
                    // Diferenca entre as larguras.
                    lngDiferencaLargura = Math.round((lngLarguraImagem * lngPorcentagemReducao) / 100);

                    // Iguala a altura da imagem à altura padrão.
                    lngAlturaImagem = lngAlturaPadrao;
                    // A mesma porcentagem de redução da altura é usada na redução da largura.
                    lngLarguraImagem -= lngDiferencaLargura;
                }

                // Se a largura da imagem for maior que a largura padrão
                // começa a reduzir a imagem tirando como base a largura.
                if(lngLarguraImagem > lngLarguraPadrao)
                {
                    // Diferença entre as larguras.
                    lngDiferencaLargura = lngLarguraImagem - lngLarguraPadrao;
                    // Percentual de redução da largura.
                    lngPorcentagemReducao = (lngDiferencaLargura * 100) / lngLarguraImagem;
                    // Diferenca entre as alturas.
                    lngDiferencaAltura = Math.round((lngAlturaImagem * lngPorcentagemReducao) / 100);

                    // Iguala a largura da imagem à largura padrão.
                    lngLarguraImagem = lngLarguraPadrao;
                    // A mesma porcentagem de redução da largura é usada na redução da altura.
                    lngAlturaImagem -= lngDiferencaAltura;
                }

                objImagem.style.height = parseInt(lngAlturaImagem) + 'px';
                objImagem.style.width  = parseInt(lngLarguraImagem) + 'px';
            }
        }
    }
}

/*
A função FecharJanelasSessaoExpirada fecha as janelas abertas em cascata, 
e exibe a mensagem de sessão expirada em um alert quando chega na última janela aberta (default.asp).

Exemplo (default.asp):
<script language="javascript" type="text/javascript" src="/ArquivosCompartilhados/libCompartilhada.js"></script>
<script language="javascript" type="text/javascript" src="/Recursos/JSFrameWork/JSFrameWork.js"></script>
<script language="javascript" type="text/javascript" src="/Globalizacao/objIdioma.js"></script>
<script language="javascript" type="text/javascript">
    FecharJanelasSessaoExpirada('<%= strMensagem %>');
</script>
*/

function FecharJanelasSessaoExpirada(strMensagem)
{
    var cstSessaoExpirou = "EXPIROU";
    var objFrameWork     = new LEBJSFrameWork();
    var strUrl           = "";
    
    strUrl = top.location.href;
        
    if(strUrl.indexOf("?msgAcesso") == -1){
        strUrl += "?msgAcesso=" + strMensagem;
    }
      
    if(top.parent.frames.length > 0){
        top.parent.location.href = strUrl;
    }else if(top.opener){
        try{
            top.opener.top.location.href = strUrl;
        }catch(e){
            /*-----------------------------------
            Caso ocorra erro, é porque os cookie FuncaoUnloadEsperaLogout
            não foi limpo por algum motivo. Neste caso a mensagem é exibida, e
            a janela fechada, pois a página anterior (opener) já foi atualizada.
            -----------------------------------
            objIdioma("E004197"):
                Prezado usuário(a), sua sessão com o nosso sistema foi expirada.
                
                Algumas das possiveis causas são:
                
                1) Seu sistema ficou ocioso por um periodo muito prolongado.
                2) Você apertou a tecla F5 ou pediu para atualizar a página (refresh).
                3) Você abriu o sistema mais em mais de uma janela.
                
                Para acessar o sistema favor efetuar seu login novamente.
            */
            self.focus();
            alert(objIdioma("E004197"));
        }
        self.close();
    }else if(!objFrameWork.pIsEmpty(objFrameWork.pTrim(strMensagem)) && objFrameWork.pToUpper(strMensagem) == cstSessaoExpirou){
        /*
        objIdioma("E004197"):
            Prezado usuário(a), sua sessão com o nosso sistema foi expirada.
            
            Algumas das possiveis causas são:
            
            1) Seu sistema ficou ocioso por um periodo muito prolongado.
            2) Você apertou a tecla F5 ou pediu para atualizar a página (refresh).
            3) Você abriu o sistema mais em mais de uma janela.
            
            Para acessar o sistema favor efetuar seu login novamente.
        */
        alert(objIdioma("E004197"));
    }
}

function MascararDataHora(_objCampo, _objEvento ,_strFormato, _blnOnKeyUp){
       
    var cstTeclasAdicionais = "38,39,40,41,65,80,16+65,16+80";
    if (!PermitirCaracteres(_objEvento, true, cstTeclasAdicionais) || _objEvento.keyCode == 8){return false;}
        
    var blnDigitandoTeclaEspecial = false;
    var arrTeclasEspeciais = ["8","9","45","46","36","35","37","39"];
    
    var blnDigitandoAuxiliarHora = false;
    var arrAuxiliarHora = ["65","80","16+65","16+80"];

    var blnDigitandoNumeros = false;

    //Checando teclas especiais
    for (var i=0; i < arrTeclasEspeciais.length; i++){
        if (arrTeclasEspeciais[i] == _objEvento.keyCode){
            blnDigitandoTeclaEspecial = true;
        }
    }
    //Checando auxiliar de hora AM/PM
    for (var i=0; i < arrAuxiliarHora.length; i++){
        if (arrAuxiliarHora[i] == _objEvento.keyCode){
            blnDigitandoAuxiliarHora = true;
        }
    }
    //Checando números
    if( PermitirCaracteres(_objEvento, true, cstTeclasAdicionais) && ! blnDigitandoAuxiliarHora && ! blnDigitandoTeclaEspecial ){
        blnDigitandoNumeros = true;
    }

    if (_blnOnKeyUp!=true){
        _blnOnKeyUp = false;
    }
    var objFrameWork = new LEBJSFrameWork();
    var cstFormatoData = "FORMATODATA";
    var cstFormatoHora = "FORMATOHORA";
    var cstFormatoHoraCompleta = "FORMATOHORACOMPLETA";
    var cstFormatoDataHora = "FORMATODATAHORA";    
    var cstFormatoDataHoraCompleta = "FORMATODATAHORACOMPLETA";
    var cstPadraoHoraIngles = "HH:MM:SS AM/PM";
    var cstPadraoHoraPortugues = "HH:MM:SS";
    var cstPadrao24HAntigo = "HH24:MI";
    var cstPadrao12hAntigo = "HH:MI";
    var cstValorDia = "D";
    var cstValorMes = "M";
    var cstValorAno = "A";
    var lngKeyCode;  
    
    var strPadraoData = objFrameWork.pToUpper(objFrameWork.pGetLanguageParams("Idioma_FormatoData"));
    var strPadraoHora = objFrameWork.pToUpper(objFrameWork.pGetLanguageParams("Idioma_FormatoHora"));    
    var objRegExp = new RegExp("[^0-9]","ig");    

    objFrameWork.Value = strPadraoData;
    objFrameWork.ToUpper().Replace(cstValorDia,"@#").Replace(cstValorMes,"@#").Replace(cstValorAno,"@#");
    var strSeparador = objFrameWork.Value.split("@#")[1];
    
    var strPossivelSeparador = strPadraoData.replace(strSeparador,"");
	strPossivelSeparador = strPossivelSeparador.replace(strSeparador,"");
	strPossivelSeparador = strPossivelSeparador.replace(cstValorDia,"");
	strPossivelSeparador = strPossivelSeparador.replace(cstValorMes,"");
	strPossivelSeparador = strPossivelSeparador.replace(cstValorAno,"");        
    
    if( (!_objEvento || _objEvento == null) && document.all ) { 
        _objEvento = event;
    }else if((!_objEvento || _objEvento == null) && !document.all){
        return; 
    }
    lngKeyCode = _objEvento.keyCode;        
    
    if (strPadraoHora == cstPadrao24HAntigo){ //Padrão 24h usado antigamente
        strPadraoHora = cstPadraoHoraPortugues;        
    }else if (strPadraoHora == cstPadrao12hAntigo){ //Padrão 12h usado antigamente
        strPadraoHora = cstPadraoHoraIngles;
    }
    
    var blnPadraoIngles = (strPadraoHora.indexOf("AM") != -1);    
    var arrOrdemPadrao = strPadraoData.split(strSeparador);
    
    //Define a posição do ano para saber se é a/m/d ou d/m/a
    for (i = 0; i < arrOrdemPadrao.length; i++){ 
        objFrameWork.Value = arrOrdemPadrao[i];
        objFrameWork.ToUpper().Trim();        
        if (objFrameWork.Value == cstValorAno || objFrameWork.Value == cstValorAno + strPossivelSeparador){ //Busca a posição do ano
            var lngPosicaoAno = i;
            break;
        }
    }
    
    var strValorCampo = _objCampo.value.replace(objRegExp, "");
    objFrameWork.Value = strValorCampo;
    var lngTamanhoCampo = objFrameWork.Length();
    var strValorTratado = '';

    if (! _blnOnKeyUp ){ //O evento onKeyDown adiciona os separadores e formata a data/hora
        for(var x = 0; x <= strValorCampo.length; x++){
            switch( _strFormato )
            {
                case cstFormatoData:
                    PermitirCaracteres(_objEvento, true, "");
                    if( ((x == 4 || x == 6) && lngPosicaoAno == 0) || ((x == 2 || x == 4 )&& lngPosicaoAno != 0)){
                        strValorTratado += strSeparador;
                    }else if( x >= 8 ){
                        PermitirCaracteres(_objEvento,false,"");                       
                    }
                    if (strPossivelSeparador != '' && x == 8){
                        strValorTratado += strPossivelSeparador;
                    }
                    break;
                case cstFormatoHora:
                case cstFormatoHoraCompleta:                                   
                    PermitirCaracteres(_objEvento, true, cstTeclasAdicionais);
                    if( lngTamanhoCampo < 4 || lngTamanhoCampo == 5 ){
                        PermitirCaracteres(_objEvento, true, "");
                    }else if( lngTamanhoCampo == 4){
                        if (_strFormato != cstFormatoHoraCompleta && !blnDigitandoAuxiliarHora){
                            PermitirCaracteres(_objEvento, false, "");
                            return;
                        }
                        if (blnPadraoIngles){
                            PermitirCaracteres(_objEvento, true, cstTeclasAdicionais);
                        }else{
                            PermitirCaracteres(_objEvento, true, "");
                        }
                    }else if( lngTamanhoCampo == 6 && blnDigitandoAuxiliarHora && blnPadraoIngles){
                        PermitirCaracteres(_objEvento, false, cstTeclasAdicionais);
                    }else{
                        PermitirCaracteres(_objEvento, false, "");
                        return;
                    }
                    
                    if(x == 2 && (lngTamanhoCampo > 2 || blnDigitandoNumeros) ){
                        strValorTratado += ":";
                    }else if( x == 4 ){
                        if( lngTamanhoCampo > 4 || blnDigitandoNumeros){
                            strValorTratado += ":";
                        }else if( lngTamanhoCampo == 4 && blnDigitandoAuxiliarHora){                            
                            if (_strFormato == cstFormatoHoraCompleta){
                                strValorTratado += ":00";
                            }
                            if (blnPadraoIngles){
                                strValorTratado += " ";
                            }
                        }                      
                    }else if( (x == 6 && blnPadraoIngles) && ((_objCampo.value.indexOf(" ") == -1 && blnDigitandoAuxiliarHora) || lngTamanhoCampo == 6) ){
                        strValorTratado += " ";
                    }
                    break;
                case cstFormatoDataHora:
                case cstFormatoDataHoraCompleta:
                    PermitirCaracteres(_objEvento, true, cstTeclasAdicionais);
                    if( lngTamanhoCampo < 12 || lngTamanhoCampo == 13 ){
                        PermitirCaracteres(_objEvento, true, "");
                    }else if( lngTamanhoCampo == 12 && _objCampo.value.split(" ").length >= 2 ){
                        if (_strFormato != cstFormatoDataHoraCompleta && !blnDigitandoAuxiliarHora){
                            PermitirCaracteres(_objEvento, false, "");
                            return;
                        }
                        if (blnPadraoIngles){
                            PermitirCaracteres(_objEvento, true, cstTeclasAdicionais);
                        }else{
                            PermitirCaracteres(_objEvento, true, "");
                        }
                    }else if( lngTamanhoCampo == 14 && blnDigitandoAuxiliarHora && blnPadraoIngles){
                        PermitirCaracteres(_objEvento, false, cstTeclasAdicionais);
                    }else{
                        PermitirCaracteres(_objEvento, false, "");
                        return;
                    }
                    
                    if( ((x == 4 || x == 6) && lngPosicaoAno == 0) || ((x == 2 || x == 4 )&& lngPosicaoAno != 0)){
                        strValorTratado += strSeparador;
                    }else if( x == 8 && (lngTamanhoCampo >= 8 || blnDigitandoNumeros ) ){                        
                        if (strPossivelSeparador != '' && x == 8){                            
                            strValorTratado += strPossivelSeparador;
                        }
                        if (lngTamanhoCampo >= 8){
                            strValorTratado += " ";
                        }                        
                    }else if(x == 10 && (lngTamanhoCampo > 10 || blnDigitandoNumeros) ){
                        strValorTratado += ":";
                    }else if( x == 12 ){
                        if( lngTamanhoCampo > 12 || blnDigitandoNumeros){
                            strValorTratado += ":";
                        }else if( lngTamanhoCampo == 12 && blnDigitandoAuxiliarHora){
                            if (_strFormato == cstFormatoDataHoraCompleta){
                                strValorTratado += ":00";
                            }
                            if (blnPadraoIngles){
                                strValorTratado += " ";
                            }
                        }
                    }else if( (x == 14 && blnPadraoIngles) && ((_objCampo.value.split(" ").length >= 2 && blnDigitandoAuxiliarHora) || lngTamanhoCampo == 14) ){
                        strValorTratado += " ";
                    }
                    break;
            }            
            strValorTratado += strValorCampo.substr(x,1);
        }        
        _objCampo.value = strValorTratado;
          
   }else{ //onKeyUp adiciona o último separador de acordo com o padrão
      
        var cstUltimoAM = "A";       
        var cstUltimoPM = "P";

        //Valor do campo
        _objCampo.value = _objCampo.value.toUpperCase();
        if (_strFormato != cstFormatoData){ // Hora e Data/Hora
            
            //Defesa contra a situação onde a letra A ou P entra antes das horas
            if (!objFrameWork.pIsNumeric(_objCampo.value.substr(0,1))){
                _objCampo.value = objFrameWork.pRight(_objCampo.value, _objCampo.value.length-1) + objFrameWork.pLeft(_objCampo.value, 1);
            }
            
            var strUltimo = _objCampo.value.substr(_objCampo.value.length-1,1);            
            if (strUltimo == cstUltimoPM || strUltimo == cstUltimoAM){
                _objCampo.value += 'M';
            }
            
        }else{ //Data
        
            var arrConteudo = _objCampo.value.split(strSeparador);
            
            //Busca o último separador de acordo com o padrão de data definido no cookie
            objFrameWork.Value = strPadraoData;
            objFrameWork.ToUpper().Replace(cstValorDia,"@#").Replace(cstValorMes,"@#").Replace(cstValorAno,"@#");
            var strUltimoSeparador = objFrameWork.Value.split("@#")[objFrameWork.Value.split("@#").length-1];
            
            //Caso o último separador não exista, a última posição retornará o ano ou o dia        
            if (objFrameWork.pIsNumeric(strUltimoSeparador)){
                strUltimoSeparador = '';
            }
            
            var strDataTratada = '';
            for (i = 0; i < arrConteudo.length ; i++){
                if (!objFrameWork.pIsEmpty(arrConteudo[i])){
                    strDataTratada += arrConteudo[i].replace(objRegExp, "") + strSeparador;
                }
            }
            
            //Retira o último separador
            strDataTratada = objFrameWork.pTrim(strDataTratada.substring(0, ((strDataTratada.length) - strSeparador.length)));        
            
            if (strPossivelSeparador != '' && lngTamanhoCampo == 8){
                _objCampo.value = strDataTratada + strUltimoSeparador;
            }
        }
   }
   return;
}

function ValidarFormPadrao(objForm)
{    
    var blnRetorno = true;
    var blnMarcadoGrupo = true;
    var objElementosGrupo;
    var objElementoPrimeiroErro;
    var objHidden;
    var strFuncaoHidden;
    var objFrameWork = new LEBJSFrameWork();
    var cstSelect = "SELECT";
    var cstOpcao = "OPCAO";
    var cstInput = "INPUT";
    var cstHidden = "HIDDEN";
    var cstFile = "FILE";
    var cstTrue = "TRUE";
    var strMensagemPadrao = objIdioma("E006578");//O campo <b>[NOMECAMPO]</b> exige preenchimento obrigatório.;
    var strMensagemRetorno;
    var strRetornoFuncaoAtachada;
    var blnConteudoVazio;
    var blnExisteCampoFile = false;
    var i,j;
    
    for(i=0;i<objForm.elements.length; i++)
    {
        //1) Verificação automática de preenchimento
        strRetornoFuncaoAtachada = "";
        if(!objFrameWork.pIsEmpty(objForm.elements[i].getAttribute("preenchimentoobrigatorio")) && objFrameWork.pToUpper(objForm.elements[i].getAttribute("preenchimentoobrigatorio")) == cstTrue)
        {
            //Se o recurso for um grupo (Radio, Checkbox) verifica se ao menos um item está marcado.
            if(objFrameWork.pToUpper(objForm.elements[i].getAttribute("tipocampo")) == cstOpcao){
                blnMarcadoGrupo = false;
                objElementosGrupo = objForm.elements[i].parentNode.parentNode.parentNode.getElementsByTagName(objForm.elements[i].tagName);
                
                for(j=0;j<objElementosGrupo.length;j++){
                    if(objElementosGrupo[j].getAttribute("tipocampo") == cstOpcao && objElementosGrupo[j].checked){
                        blnMarcadoGrupo = true;
                        break;
                    }
                }
            }
            
            //Se o recurso é um campo File, verifica o conteúdo o span.
            if(objFrameWork.pToUpper(objForm.elements[i].tagName) == cstInput && objFrameWork.pToUpper(objForm.elements[i].type) == cstFile){
                blnConteudoVazio = objFrameWork.pIsEmpty(objForm.elements[i].value)?objFrameWork.pIsEmpty(document.getElementById("spnLink"+objForm.elements[i].name)):false;
            }else{
                blnConteudoVazio = objFrameWork.pIsEmpty(objFrameWork.pTrim(objForm.elements[i].value)) || (objForm.elements[i].tagName == cstSelect && objForm.elements[i].selectedIndex == 0);
            }
            
            if( blnConteudoVazio || !blnMarcadoGrupo )
            {
                blnRetorno = false;
                objElementoPrimeiroErro = objForm.elements[i];
                break;
            }
        }
        
        //Se o recurso é um campo File, e estiver preenchido, ativa a execução da barra de progresso.
        if( ( objFrameWork.pToUpper(objForm.elements[i].tagName) == cstInput && objFrameWork.pToUpper(objForm.elements[i].type) == cstFile ) && ( !objFrameWork.pIsEmpty(objForm.elements[i].value) || !objFrameWork.pIsEmpty(document.getElementById("spnLink"+objForm.elements[i].name)) ) ){
            blnExisteCampoFile = true;
        }        
        
        strRetornoFuncaoAtachada = "";
        //Caso o campo tenha alguma função atachada, ela é executada. (O retorno deve ser vazio ou uma mensagem de erro)
        if(!objFrameWork.pIsEmpty(objForm.elements[i].getAttribute("funcaoatachada")))
        {
            strRetornoFuncaoAtachada = eval(objFrameWork.pReplace(objForm.elements[i].getAttribute("funcaoatachada"),"this","objForm.elements[i]"));
        }else if(!objFrameWork.pIsEmpty(objForm.elements[i].getAttribute("validacaoespecial"))){
            strRetornoFuncaoAtachada = eval(objFrameWork.pReplace(objForm.elements[i].getAttribute("validacaoespecial"),"this","objForm.elements[i]"));
        }
        
        if(!objFrameWork.pIsEmpty(objFrameWork.pTrim(strRetornoFuncaoAtachada))){
            blnRetorno = false;
            objElementoPrimeiroErro = objForm.elements[i];
            break;
        }
    }
        
    if(!blnRetorno){
        if(objFrameWork.pIsEmpty(objFrameWork.pTrim(strRetornoFuncaoAtachada))){
            strMensagemRetorno = objFrameWork.pReplace(strMensagemPadrao, "[NOMECAMPO]", objElementoPrimeiroErro.getAttribute("nomevisual"));
        }else{
            strMensagemRetorno = strRetornoFuncaoAtachada;
        }
        ExibirCaixaMensagemRPC('', strMensagemRetorno);
        if(!(objFrameWork.pToUpper(objElementoPrimeiroErro.tagName) == cstInput && objFrameWork.pToUpper(objElementoPrimeiroErro.type) == cstHidden))
        {            
            AlterarCorLabelFormularioPadrao( objElementoPrimeiroErro.name, "#FF0000" );        
        }
    }else if(blnExisteCampoFile){//Caso o retorno esteja true, e exista um campo file, ativa a barra de progresso.
        blnRetorno = BarraDeProgresso(objForm);
    }
  
    return blnRetorno;
}

function ValidarFormExclusao( objForm ) {
	var objFrameWork = new LEBJSFrameWork();
	var lngContador = 0;
	var blnRegistroSelecionado = false;
	var blnExisteCampoOpcao = false;
	var blnRetorno = false;
	var cstCampoOpcao = "OPCAO";
	
	for(lngContador=0;lngContador<objForm.elements.length; lngContador++)
	{
	    //Navega apenas pelos campos do tipo opção.
	    if(objFrameWork.pToUpper(objForm.elements[lngContador].getAttribute("TipoCampo")) == cstCampoOpcao){
	        blnExisteCampoOpcao = true;
	        if(objForm.elements[lngContador].checked) {
			    blnRegistroSelecionado = true;
			    lngContador = objForm.elements.length //Ja encontrou um para deletar
		    }
		}
	}
	
	//Exibe mensagens
	if( !blnExisteCampoOpcao ){
	    ExibirCaixaMensagemRPC('', objIdioma("E001914"));//Não há registros para excluir. 
	}else if( !blnRegistroSelecionado ){
	    ExibirCaixaMensagemRPC('', objIdioma("E001912"));//Por favor, marque pelo menos um item para ser excluido. 
	}else{
	    blnRetorno = confirm(objIdioma("E001913"));//Você tem certeza que deseja excluir os itens selecionados?
	}
	
	return blnRetorno;
}

// Função para verificar se a URL informada é válida.
function ValidarCampoURL(objCampo,strSiteUrlExterno,blnTipoURLArquivo,blnSalvando)
{
    var objFrameWork    = new LEBJSFrameWork();
    var objImagem       = document.getElementById('img'+objCampo.id);
    var strURL          = '/ArquivosCompartilhados/rpcUrlChecker.asp?url=';
    var strURLInformada = objFrameWork.pToLower(objFrameWork.pTrim(objCampo.value));                                                                               
    var strRetornoRPC   = '';
    var cstOK           = 'OK';
    var cstBoolean      = 'boolean';
    var lngSplit        = 2;
    //Informe uma URL válida.
    var strMsgURLInvalida = objIdioma("E008117");
    
    // Caso a URL não tenha sido informada, já configura o retorno e a mensagem.
    if(objFrameWork.pIsEmpty(strURLInformada))
    {
        objImagem.src  = '/Gestor/Imagens/erro.gif';
        objImagem.alt  = strMsgURLInvalida;
        return "";
    }
    
    // Se o padrão de exibição da URL for arquivo, altera o contador do split e 
    // verifica se existe nome de arquivo no caminho da url
    if(blnTipoURLArquivo && typeof(blnTipoURLArquivo) == cstBoolean){
        lngSplit = 3;
        if(strURLInformada.lastIndexOf(".") < strURLInformada.lastIndexOf("/") || objFrameWork.pReplace(strURLInformada, 'http://', '').lastIndexOf("/") < 1)
        {
            objImagem.src  = '/Gestor/Imagens/erro.gif';
            objImagem.alt  = strMsgURLInvalida;
            //A URL informada não é válida. Verifique se a URL foi informada corretamente.
            return objIdioma("E004632");
        }
    }
    
    // Verificando a URL.
    var objExpressaoRegular = /^(http(s)?:[/]{2})/;                                
    if(!objExpressaoRegular.test(strURLInformada))
    {
        strURLInformada = objFrameWork.pReplace(strURLInformada, '../', '');
    
        if(strURLInformada.split('.').length >= lngSplit)
        {
            strURLInformada = 'http://' + strURLInformada;
        } 
        else
        {
            strURLInformada = strSiteUrlExterno + strURLInformada;                        
        }
    }
    
    // Função para tratar o retorno do RPC.
    function TratarRetornoRPC(strRetorno)
    {                    
        if(objFrameWork.pToUpper(strRetorno) == cstOK)
        {
            objImagem.src = '/Gestor/Imagens/certo.gif';
            objImagem.alt = strRetorno;
        }
        else
        {
            objImagem.src = '/Gestor/Imagens/erro.gif';
            objImagem.alt = strRetorno;
        }
    }

    //Quando a chamada vier do submit executa o RPC no modo sincrono
    if(blnSalvando && typeof(blnSalvando) == cstBoolean)
    {
        strRetornoRPC = objFrameWork.pRPC(strURL + strURLInformada);
        
        if(strRetornoRPC == cstOK)
        {
            return "";
        }
        else
        {
            return strRetornoRPC;
        }
    }
    else
    {
        // Submete a URL informada à verificação.
        objCampo.value = strURLInformada;
        objImagem.src  = '/Gestor/Imagens/carregandoconteudo.gif';
        //Verificando URL...
        objImagem.alt  = objIdioma("E008119");
        
        objFrameWork.pRPC(strURL + strURLInformada, TratarRetornoRPC);
    }
}

function MarcarOpcaoLabel(objElemento,objFuncaoAtachada){
    var objFrameWork    = new LEBJSFrameWork();
    if(!objElemento.disabled && !objElemento.readonly){
        AlterarCorLabelFormularioPadrao(objElemento.id,'#000000');
        if(objElemento.type == cstCheckBox){
            objElemento.checked = !objElemento.checked;
        }else{
            objElemento.checked = true;
        }
        if(objFrameWork.pIsFunction(objFuncaoAtachada) || objFrameWork.pIsObject(objFuncaoAtachada)){
            objFuncaoAtachada();
        }
    }
}


//Função que exibe a caixa de mensagem com o retorno da validação presente no evento.
function ExecutarFuncaoAtachadaEvento( objCampo ){
    var strRetornoFuncaoAtachada;
    var objFrameWork = new LEBJSFrameWork();
    strRetornoFuncaoAtachada = eval(objFrameWork.pReplace(objCampo.getAttribute("funcaoatachada"),"this","objCampo"));
    
    if(!objFrameWork.pIsEmpty(strRetornoFuncaoAtachada)){
        AlterarCorLabelFormularioPadrao( objCampo.name, "#FF0000" );
        ExibirCaixaMensagemRPC('', strRetornoFuncaoAtachada);
    }
}

function ValidarCampoPadraoData(objCampoPadraoData, blnRetornarErro){
    var objFrameWork = new LEBJSFrameWork();
    if(!blnRetornarErro == true){
        blnRetornarErro = false;
    }
    
    if (!objFrameWork.pIsEmpty(objCampoPadraoData.value) && !objFrameWork.pIsDate(objCampoPadraoData.value,true)) {
        AlterarCorLabelFormularioPadrao( objCampoPadraoData.name, "#FF0000" );
        //Esta data é inválida, por favor, digite uma data válida. 
	    if(!blnRetornarErro){
	        ExibirCaixaMensagemRPC('', objIdioma("E000655"));
	    }else{
	        return objIdioma("E000655");
	    }
	}else if(blnRetornarErro){
	    return "";
	}
}

function ValidarCampoPadraoDataHora(objCampoPadraoDataHora, blnRetornarErro){
    var objFrameWork = new LEBJSFrameWork();
    if(!blnRetornarErro == true){
        blnRetornarErro = false;
    }    
    
    var lngFimData = (objCampoPadraoDataHora.value.indexOf(":")!= -1)?objCampoPadraoDataHora.value.indexOf(":") - 3:objCampoPadraoDataHora.value.length;
    var strData = objCampoPadraoDataHora.value.substr(0,lngFimData);
    var strHora = objCampoPadraoDataHora.value.substr(lngFimData+1);
    
    if (!objFrameWork.pIsEmpty(objCampoPadraoDataHora.value) && (!objFrameWork.pIsDate(strData,true) || !objFrameWork.pIsHour(strHora,true))) {
        AlterarCorLabelFormularioPadrao( objCampoPadraoDataHora.name, "#FF0000" );
        //Esta data é inválida, por favor, digite uma data válida. 
	    if(!blnRetornarErro){
	        ExibirCaixaMensagemRPC('', objIdioma("E000655"));
	    }else{
	        return objIdioma("E000655");
	    }
	}else if(blnRetornarErro){
	    return "";
	}
}

function ValidarCampoPadraoHora(objCampoPadraoHora, blnRetornarErro){
    var objFrameWork = new LEBJSFrameWork();
    if(!blnRetornarErro == true){
        blnRetornarErro = false;
    }
    
    if (!objFrameWork.pIsEmpty(objCampoPadraoHora.value) && !objFrameWork.pIsHour(objCampoPadraoHora.value,true)) {
	    AlterarCorLabelFormularioPadrao( objCampoPadraoHora.name, "#FF0000" );
        //A hora se encontra em um formato inválido. 
	    if(!blnRetornarErro){
	        ExibirCaixaMensagemRPC('', objIdioma("E000656"));
	    }else{
	        return objIdioma("E000656");
	    }
	}else if(blnRetornarErro){
	    return "";
	}
}

function AlterarCorLabelFormularioPadrao( strNomeCampo, strCor ){
    var objSpanLabel = document.getElementById("spnLabel"+strNomeCampo);
    var objCampo, objTdAtual;
    var cstCampoOpcao = "OPCAO"
    var cstCorAlerta = "#FFFFBF";
    var cstCorPreta = "#000000";
    
    try{
        //Caso exista uma label padronizada, altera a cor do texto.
        if(objSpanLabel){
            objSpanLabel.style.color = strCor;
        }else{//senão, altera o fundo do container do próprio campo para a cor de alerta.
            objCampo = document.getElementsByName(strNomeCampo)[0];
            
            if(objCampo.getAttribute("tipocampo") == cstCampoOpcao){
                objCampo = objCampo.parentNode.parentNode.parentNode;
            }
            
            //Volta para a cor anterior
            if(strCor == cstCorPreta){
                objCampo.style.backgroundColor = objCampo.getAttribute("CorDeFundoAnterior")
            }else{//Coloca a cor de alerta (Laranja)
                objCampo.setAttribute("CorDeFundoAnterior",objCampo.style.backgroundColor);
                objCampo.style.backgroundColor = cstCorAlerta;
            }
        }
    }catch(e){}
}

function AlterarTextoLabelFormularioPadrao(strNomeCampo, strTipoCampo, strEstilosLabel, strClasseLabel, strTextoHint)
{
    /**************************************************************************
    Esta função procura o nodo anterior do mesmo tipo, e altera seu conteúdo
    para a label correta do campo. 
    Funciona para qualquer tipo de nodo, TDs, DIVs, SPANs, etc.
    **************************************************************************/
    
    var cstOpcao = "OPCAO";
    var cstTrue = "TRUE";
    var objCampo;
    var objTdAtual;
    var objTdAnterior;
    var objTrAtual;
    var objTrAnterior;
    var strNovaLabel = "";
    var objFrameWork = new LEBJSFrameWork();
    
    if(objFrameWork.pIsEmpty(strEstilosLabel)){
        strEstilosLabel = "";
    }
    
    if(objFrameWork.pIsEmpty(strClasseLabel)){
        strClasseLabel = "";
    }
    
    //Pegando o nodo atual, para procurar o previousSibling correspondente à label no parentNode
    //Se for um campo do tipo opção, pego o primeiro campo, e por estar envolto e uma table, tenho que pegar mais níveis acima.
    if(objFrameWork.pToUpper(strTipoCampo) == cstOpcao){
        objCampo = document.getElementById(strNomeCampo);
	objTdAtual = objCampo.parentNode.parentNode.parentNode.parentNode.parentNode;
    }else{
        objCampo = document.getElementById(strNomeCampo);
        objTdAtual = objCampo.parentNode;
    }
    
    //Verificando se existe algum nodo anterior do mesmo tipo.
    objTdAnterior = objTdAtual.previousSibling;
    while(objTdAnterior && objTdAtual.tagName != objTdAnterior.tagName){
        objTdAnterior = objTdAnterior.previousSibling;
    }
        
    //Se não encontrar nos nodos anteriores, sobe um nível.
    if(!objTdAnterior){
        //busca a tr anterior
        objTrAtual = objTdAtual.parentNode;
        objTrAnterior = objTrAtual.previousSibling;
        while(objTrAnterior && objTrAtual.tagName != objTrAnterior.tagName){
            objTrAnterior = objTrAnterior.previousSibling;
        }
                
        //Se encontrar a tr anterior, busca uma td, de baixo pra cima.
        if(objTrAnterior){
            objTdAnterior = objTrAnterior.lastChild;
            while(objTdAnterior && objTdAtual.tagName != objTdAnterior.tagName){
                objTdAnterior = objTdAnterior.previousSibling;
            }
        }
    }
        
    //Caso o atributo NomeVisual esteja vazio, não troca o conteúdo da label.
    if(!objFrameWork.pIsEmpty(objFrameWork.pTrim(objCampo.getAttribute("nomevisual"))))
    {
    
        //Se após o processo de busca, ele encontrar o objeto anterior do mesmo tipo, coloca a nova label. 
        if(objTdAnterior)
        {
            //Preparação do novo innerHTML
            strNovaLabel = "<span id='spnLabel" + objCampo.name + "' class='" + strClasseLabel + "' style='" + strEstilosLabel + "'>" + objCampo.getAttribute("nomevisual");
            if(!objFrameWork.pIsEmpty(objCampo.getAttribute("preenchimentoobrigatorio")) && objFrameWork.pToUpper(objCampo.getAttribute("preenchimentoobrigatorio")) == cstTrue)
            {
                strNovaLabel += "*";
            }
            strNovaLabel += "</span>";
        }       
     }
     
     
    //Caso o hint seja informado, o adiciona do lado de fora do span.
    if (!objFrameWork.pIsEmpty(objFrameWork.pTrim(strTextoHint))){                
        var strScriptHint = "<img src=\"/imagens/px.gif\" width=\"7\" height=\"1\"/>";
        strScriptHint += "<img src=\"/imagens/ico_ajuda.gif\" style='vertical-align:bottom;margin-bottom:-2px;margin-top:2px;' onmouseover=\"callHint('" + strTextoHint + "');\" onmouseout=\"callHint();\" />";
        if(!objFrameWork.pIsEmpty(strNovaLabel))
        {
            strNovaLabel += strScriptHint;
        }
        else
        {
            objTdAnterior.innerHTML += strScriptHint;
        }
    }
    if(!objFrameWork.pIsEmpty(strNovaLabel))
    {          
        objTdAnterior.innerHTML = strNovaLabel;
    }
    
    
}

function MascararCampoNumerico(objCampo, lngCasasDecimais)
{    
    var objFrameWork = new LEBJSFrameWork();
    if(!objFrameWork.pIsEmpty(objCampo.value)){        
        var strValorFormatado = objFrameWork.pReplace(objFrameWork.pFormatNumber(objCampo.value,lngCasasDecimais,false,true,false),".","");
        var lngTamanhoCampo = objFrameWork.pLength(strValorFormatado);
        var lngTamanhoMaximo = objCampo.maxLength;
        var lngDiferencaCaracteres = lngTamanhoMaximo - lngCasasDecimais;
            
        if(lngTamanhoCampo > lngTamanhoMaximo){
            objCampo.value = objFrameWork.pFormatNumber(strValorFormatado.substr(0, lngDiferencaCaracteres) + "." + strValorFormatado.substr(lngDiferencaCaracteres,lngCasasDecimais),lngCasasDecimais,false,false,true);
        }else{
            if(lngCasasDecimais == 0){
                strValorFormatado = objFrameWork.pFormatNumber(objFrameWork.pReplace(objCampo.value,".",""),lngCasasDecimais,false,false,true);
            }else{
                strValorFormatado = objFrameWork.pFormatNumber(objCampo.value,lngCasasDecimais,false,false,true);
            }
            objCampo.value = strValorFormatado;
        }
    }
}

//Exibe a divHint com a mensagem de exemplo de formatação de data/hora
function ExibirHintDataHora(strFormato){
    var dtmDataExemplo = new Date(2008,0,31);
    var objFrameWork = new LEBJSFrameWork();
    var strMensagem = objIdioma("E006677");
    
    dtmDataExemplo.setHours(13,59,59);
    
    strMensagem = objFrameWork.pReplace(strMensagem,"[DATA_EXEMPLO]",objFrameWork.pFormatDate(dtmDataExemplo,strFormato));
    //Função presente na divHint.js da pasta Recursos/divHint/
    callHint(strMensagem);
}

/*
Caracteres que devem ser Proibidos na digitação, usar com ONKEYDOWN
Se for usar shift usar 16+keyCode_da_tecla
*/
function ProibirCaracteres( objEvento, strProibidas, blnCaixaMensagem )
{
    var objFrameWork    = new LEBJSFrameWork()
    var lngCaracter     = 0;
    var strCaracter     = '';
    var blnRetorno      = true;
    var blnTeclaControl = false;
    var blnTeclaShift   = false;

    // Recuperando o keyCode da tecla.
    if(objEvento.keyCode)
    {
        lngCaracter = objEvento.keyCode;
    }
    else if(objEvento.which)
    {
        lngCaracter = objEvento.which;
    }
    else if(objEvento.charCode)
    {
        lngCaracter = objEvento.charCode;
    }
    else
    {
        lngCaracter = void(0);
    }

    // Valor booleano que indica se as teclas Shift e/ou Control estão pressionadas.
    blnTeclaControl = objEvento.ctrlKey;
    blnTeclaShift   = objEvento.shiftKey;
    
    // Proibi outras teclas informadas pelo programador.
    if(!objFrameWork.pIsEmpty(strProibidas))
    {
        strProibidas = strProibidas.replace(/\s/g, '');
        strProibidas = strProibidas.replace(/^[,]|[,]$/g, '');
        if(!objFrameWork.pIsEmpty(objFrameWork.pTrim(strProibidas)))
        {
            var arrProibidas = strProibidas.split(',');
            var strTeclaProibida = "";

            for(var i = 0; i < arrProibidas.length; i++)
            {
            
                strTeclaProibida = arrProibidas[i].split("+")[1];
            
                if(arrProibidas[i].indexOf("16+") >= 0 || arrProibidas[i].indexOf("17+") >= 0){
                    if( blnTeclaShift && lngCaracter == strTeclaProibida )
                    {
                        blnRetorno = false;
                        break;
                    }     
                }else{
                    if( (!blnTeclaShift) && lngCaracter == strTeclaProibida )
                    {
                        blnRetorno = false;
                        break;
                    }
                }
                
                if(arrProibidas[i].indexOf("17+") >= 0 || arrProibidas[i].indexOf("16+") >= 0 ){
                    if( blnTeclaControl && lngCaracter == strTeclaProibida )
                    {
                        blnRetorno = false;
                        break;
                    }     
                }else{
                    if( (!blnTeclaControl) && lngCaracter == strTeclaProibida )
                    {
                        blnRetorno = false;
                        break;
                    }
                }                
                
            }
        }
    }

    // Caso a tecla ou combinação de teclas seja permitida, sai da função sem bloquear.
    if(blnRetorno)
    {
        return blnRetorno
    }

    try
    {
        objEvento.returnValue  = false;
        objEvento.cancelBubble = false;

        if(document.all)
        {
            objEvento.keyCode = 0;
        }
        else
        {
            objEvento.preventDefault();
            objEvento.stopPropagation();
        }
        
        if( blnCaixaMensagem ) {
            ExibirCaixaMensagemRPC( "", objIdioma("E006088") ); 
       }
        
    }
    catch(err)
    {
    }
    return blnRetorno;
    
}

function fecharPopup()
{
	var objFrameWork    = new LEBJSFrameWork();
	if(window.opener)
	{
		self.close();
	}
	else
	{
		if (objFrameWork.pIsFunction(parent.fecharDivPopup) || objFrameWork.pIsObject(parent.fecharDivPopup))
		{
			parent.fecharDivPopup('divPopup');
		}
	}
}


//Verifica se uma data ou hora inicial é menor ou igual a uma data ou hora final, com mensagem parametrizada
function validaDataHoraFinal(strIdInicio, strIdFim, strMsg, strTipo, strOperador)
{
	var cstTipoData     = "DATA";
	var cstTipoHora     = "HORA";
	var cstTipoDataHora = "DATAHORA";
	var strValidacaoInicio;
	var strValidacaoFinal;
	
	if (strOperador == undefined)
	{
		strOperador = '<';
	}
	
	if (document.getElementById(strIdInicio) && document.getElementById(strIdFim)){
	
	    var objInicio = document.getElementById(strIdInicio);
	    var objFim = document.getElementById(strIdFim);	    
	    
	    strTipo = objFrameWork.pIsEmpty(strTipo) ? cstTipoData : strTipo;
	    
	    switch(objFrameWork.pTrim(objFrameWork.pToUpper(strTipo)))
	    {
	        case cstTipoData:
	            strValidacaoInicio = objFrameWork.pTrim(ValidarCampoPadraoData(objInicio, true));
	            strValidacaoFinal = objFrameWork.pTrim(ValidarCampoPadraoData(objFim, true));
	            break;
	        case cstTipoHora:
	            strValidacaoInicio = objFrameWork.pTrim(ValidarCampoPadraoHora(objInicio, true));
	            strValidacaoFinal = objFrameWork.pTrim(ValidarCampoPadraoHora(objFim, true));
	            break;
	        case cstTipoDataHora:
	            strValidacaoInicio = objFrameWork.pTrim(ValidarCampoPadraoDataHora(objInicio, true));
	            strValidacaoFinal = objFrameWork.pTrim(ValidarCampoPadraoDataHora(objFim, true));
	            break;
	    }
	    
	    //Se não houve retorno das funções, então os valores são datas válidas e podem ser convertidas
	    if (objFrameWork.pIsEmpty(strValidacaoInicio) && objFrameWork.pIsEmpty(strValidacaoFinal)){
	    
	        var dtmInicio = objFrameWork.pCDate(objInicio.value);
	        var dtmFim = objFrameWork.pCDate(objFim.value);
	        return eval("dtmFim " + strOperador + "dtmInicio") ? strMsg : "";
	        
	    }else{
	    
	        strValidacao = objFrameWork.pLength(strValidacaoInicio) != 0 ? strValidacaoInicio : strValidacaoFinal;
	        return strValidacao;
	    }
    }
    //Não encontrou os campos
    return "";
	
}


//Verifica seu um valor numérico está entre dois valores
function criticaCampoNumerico(objValorOrigem, dblValorMinimo, dblValorMaximo, blnRetornaValorFormatado)
{
	var dblValorOriginal = objValorOrigem.value;
	var lngCasasDecimais = 2;

	if(!objFrameWork.pIsEmpty(dblValorOriginal))
	{
		dblValorOriginal = objFrameWork.pFormatNumber(dblValorOriginal, lngCasasDecimais, false, true);
	}
	
	if(!objFrameWork.pIsNumeric(dblValorMinimo))
	{
		strValorMinimo = 0;
	}
	else
	{
		dblValorMinimo = parseFloat(dblValorMinimo);
	}
	
	if(!objFrameWork.pIsNumeric(dblValorMaximo))
	{
		dblValorMaximo = 100;
	}
	else
	{
		dblValorMaximo = parseFloat(dblValorMaximo);
	}
	
	if(blnRetornaValorFormatado != false)
	{
		blnRetornaValorFormatado = true;
	}
	if(objFrameWork.pIsNumeric(dblValorOriginal))
	{
		if(parseFloat(dblValorOriginal) >= dblValorMinimo && parseFloat(dblValorOriginal) <= dblValorMaximo)
		{
			if(blnRetornaValorFormatado)
			{
				objValorOrigem.value = objFrameWork.pFormatNumber(dblValorOriginal, lngCasasDecimais, false, false, blnRetornaValorFormatado);
			}
			return "";
		}
		else
		{
			//O valor informado deverá ser maior ou igual a [VALOR_MIN] e menor ou igual a [VALOR_MAX]
			objValorOrigem.value = "";
			return objIdioma("E005311").Replace("[VALOR_MIN]", dblValorMinimo).Replace("[VALOR_MAX]", dblValorMaximo);
		}
	}
	else
	{
		objValorOrigem.value = "";
		//O valor informado deverá ser númerico, maior ou igual a [VALOR_MIN] e menor ou igual a [VALOR_MAX].
		return objIdioma("E005312").Replace("[VALOR_MIN]", dblValorMinimo).Replace("[VALOR_MAX]", dblValorMaximo);
	}
}

//Transforma um campo construído através do objFormulário (WAFormulario.clsCampos) em um campo obrigatório (ou não..)
function setaObrigatoriedade(strId, strIdTD, blnCampoObrigatorio)
{
	try
	{
		var strObrigatoriedade = blnCampoObrigatorio ? "*": "";
		var obj = document.getElementsByName(strId)[0];
		var objTD = document.getElementById(strIdTD);
		obj.setAttribute("preenchimentoobrigatorio", blnCampoObrigatorio);
		objTD.innerHTML = "<span id='spnLabel" + strId + "'>" + obj.getAttribute("nomevisual") + strObrigatoriedade + "</span>"
	}
	catch(e)
	{
	}
}

// Buscando o valor de uma variável de sessão
function getSession(strNomeSession, lngPosicao)
{
    var objFrameWork    = new LEBJSFrameWork();
    var strURL = "/rpcGetSession.asp?" + 
				"Session=" + strNomeSession + 
				"&Posicao=" + (lngPosicao == undefined ? "" : lngPosicao);
    return objFrameWork.pRPC(strURL);
}

// Atribuindo o valor a uma variável de sessão
function setSession(strNomeSession, strValorSession)
{
    var objFrameWork    = new LEBJSFrameWork();
    var strURL = "/rpcSetSession.asp?" +
				"Session=" + strNomeSession +
				"&Valor=" + strValorSession;
    objFrameWork.pRPC(strURL); 
}

//Tentando fechar uma janela
function fecharJanela(objJanela)
{
	try
	{
		objJanela.close();
	}
	catch(e)
	{
	}
}

// Realizando o atachamanento dinâmico
function atachamentoDinamico(strObjeto, strPath, strJanela)
{
	strJanela = (strJanela == undefined ? "window" : strJanela);
	var cstObject = "object";
	var cstFunction = "function";
	var cstJS = "js";
	var arrPath = strPath.split(".");
	var blnJS = (arrPath[arrPath.length - 1] == cstJS);
	var strTipo = eval("typeof(" + strJanela + "." + strObjeto + ");");
	var objJanela = eval(strJanela);
	var blnCSS = false;
	if (!blnJS)
	{
		for (var i = 0 ; i < document.styleSheets.length ; i ++)
		{
			if (document.styleSheets[i].href.indexOf(strObjeto + ".css") != -1)
			{
				blnCSS = true;
				break;
			}
		}
	}
	if ( ( !blnJS && !blnCSS) || (blnJS && strTipo != cstObject && strTipo != cstFunction) )
	{
		if (document.all && blnJS)
		{
			objJanela.document.write('<scr' + 'ipt language="javascript" type="text/javascript" src="/' + strPath + '"></scr'+'ipt>');
		}
		else
		{
			var objScript;
			if (blnJS)
			{
				objScript = document.createElement("script");
				objScript.setAttribute("language","javascript");
				objScript.setAttribute("type", "text/javascript");
				objScript.setAttribute("src", "/" + strPath);
			}
			else
			{
				objScript = document.createElement("link");
				objScript.setAttribute("rel","stylesheet");
				objScript.setAttribute("type", "text/css");
				objScript.setAttribute("href", "/" + strPath);
			}
			try 
			{  
				objJanela.document.getElementsByTagName("head")[0].appendChild(objScript);
			}
			catch(e) 
			{
				try 
				{  
					objJanela.document.getElementsByTagName("body")[0].appendChild(objScript);
				}
				catch(e) 
				{
				}
			}
		}
	}
}

function navegador()
{
	var arrNavegadores=["MSIE","FIREFOX","SAFARI"];
	var strNavegador=navigator.userAgent.toUpperCase();
	for(var i=0;i<arrNavegadores.length;i++)
	{
		if(strNavegador.lastIndexOf(arrNavegadores[i])!=-1)
		{
			return arrNavegadores[i];
		}
	}
}