/*--------------------------------------------------------------------------------
Objetivo: Framework JS  
Criação: Leandro Elias
Data de Criação: 15/03/2005     Data da ultima modificação: 06/12/2007
--------------------------------------------------------------------------------*/
function LEBJSFrameWork( _strConteudoInicial ){
    /*----------------------------------------------------------------------------
    Declaração de Constantes;
    -----------------------------------------------------------------------------*/
    var cstTipoData = "Data";
    var cstTipoTexto = "Texto";
    var cstTipoMemorando = "Memorando";
    var cstTipoNumero = "Número"
    var cstTipoDocumento = "Documento";
    var cstTipoObjeto = "Objeto"
    var cstTipoMoeda = "Moeda"
    var cstTipoIndefinido = null;
    
    /*----------------------------------------------------------------------------
    Declaração de Propriedades;
    -----------------------------------------------------------------------------*/
    this.Value = (( _strConteudoInicial != null )? _strConteudoInicial : "" );
    
    /*----------------------------------------------------------------------------
    Declaração de Méthodos;
    -----------------------------------------------------------------------------*/
    //Retorna true se o conteudo for vazio ou nulo
    this.IsEmpty = function(){ 
        return this.pIsEmpty( this.Value );
    }
    this.pIsEmpty = function( _strConteudo ){ 
        var blnRetorno = false;
        try{
            blnRetorno = ( _strConteudo == null || this.pLength(_strConteudo) == 0 )? true : false; 
        }catch(e){
        }finally{
            return blnRetorno;
        }
    }
    
    //Retorna true se o contéudo for um CPF
    this.IsCPF = function(){
        return this.pIsCPF( this.Value );
    }
    this.pIsCPF = function( _strConteudo, _blnRemoverMascara ){
        var blnRetorno = false;
        //Preenchendo parametro opcional
        _blnRemoverMascara = ( _blnRemoverMascara != true ) ? false: true;
        
        try{
			//Convertendo conteudo para string
			_strConteudo = this.pToString( _strConteudo );

            if( _blnRemoverMascara ){
                _strConteudo = this.pOnlyNumber(_strConteudo);
            }
            if( _strConteudo.length == 11 ){
                var strItemNegado = "";
                for( var i=1; i <= 9; i++ ){
                    strItemNegado = "";
                    for( var j=1; j <= 11; j++ ){                        
                        strItemNegado += i.toString(); 
                    } 
                    if( _strConteudo == strItemNegado ){
                        return blnRetorno;
                        break;
                    }
                }
                var strParte1 = _strConteudo.substring(0, 9);
                var strParte2 = _strConteudo.substring(9, 11);
                var dblSoma = 0;
                var dblDigito1 = 0;
                var dblDigito2 = 0;
                for( var i=0; i <= strParte1.length; i++ ){
                    dblSoma += strParte1.substring(i, i+1 ) * (11 - (i+1) );
                }
                dblSoma *= 10;
                dblDigito1 = ((dblSoma % 11)== 10)? 0: dblSoma % 11;
                strParte1 = strParte1 + parseInt(dblDigito1);
                
                dblSoma = 0;
                for( var i=0; i <= strParte1.length; i++ ){
                    dblSoma += strParte1.substring(i, i+1 ) * (12 - (i+1) );
                }
                
                dblSoma *= 10;
                dblDigito2 = ((dblSoma % 11)== 10)? 0: dblSoma % 11;
                if( strParte2.substring(0,1) == dblDigito1.toString() && strParte2.substring(1,2) == dblDigito2.toString() ){
                    blnRetorno = true;
                }
            }
            
        }catch(e){
        }finally{
            return blnRetorno;
        }
    }

    //Retorna true se o contéudo for um CNPJ
    this.IsCNPJ = function(){
        return this.pIsCNPJ( this.Value );
    }
    this.pIsCNPJ = function( _strConteudo ){
        var blnRetorno = false;
        try{
			//Convertendo conteudo para string
			_strConteudo = this.pToString( _strConteudo );

            _strConteudo = this.pOnlyNumber( _strConteudo );
            if( _strConteudo.length == 14 ){
                var strFluxo = "543298765432";
                var strParte1 = _strConteudo;
                var strParte2 = _strConteudo.substring(12, 14);
                var dblSoma = 0;
                var dblDigito1 = 0;
                var dblDigito2 = 0;
                
                for( var i=0; i <= strParte1.length; i++ ){
                    dblSoma += strParte1.substring(i, i+1 ) * strFluxo.substring(i, i+1 );
                }
                dblSoma *= 10;
                dblDigito1 = ((dblSoma % 11)== 10)? 0: dblSoma % 11;
                strParte1 = strParte1 + parseInt(dblDigito1);
                
                dblSoma = 0;
                strFluxo = "6543298765432";
                for( var i=0; i <= strParte1.length; i++ ){
                    dblSoma += strParte1.substring(i, i+1 ) * strFluxo.substring(i, i+1 );
                }
                
                dblSoma *= 10;
                dblDigito2 = ((dblSoma % 11)== 10)? 0: dblSoma % 11;
                if( strParte2.substring(0,1) == dblDigito1.toString() && strParte2.substring(1,2) == dblDigito2.toString() ){
                    blnRetorno = true;
                }
            }
        }catch(e){
        }finally{
            return blnRetorno;
        }    
    }
    
    //Função que converte um valor string ou numérico em boolean
    this.CBool = function(){
        this.Value = this.pCBool( this.Value );
        return this;
    }
    
    this.pCBool = function ( _vrtValorBoolean ){        
        
        //Possíveis valores verdadeiros
        var cstStrTrue  = "TRUE";
        var cstStrSim   = "S";
        var cstStrVerdadeiro = "VERDADEIRO";
        var cstStrVerdade = "V";
        var blnFinal    = false;
        
        //Se o valor informado for numérico, converte-se para inteiro e verifica se é verdadeiro
        if (this.pIsNumeric(_vrtValorBoolean)){
            _vrtValorBoolean = parseInt(_vrtValorBoolean);
            if (_vrtValorBoolean == 1){
                blnFinal = true;
            }
        }else{ //Se o valor for string, verifica se é verdadeiro            
            var strValor = this.pTrim(this.pToUpper(_vrtValorBoolean));

            switch (strValor){
                case cstStrTrue:
                case cstStrSim:
                case cstStrVerdadeiro:
                case cstStrVerdade:
                    blnFinal = true;
                    break;
            }
        }
        return blnFinal;
    }
    
    //Função que recebe uma data tipo string e retorna um obj tipo date
    this.CDate = function( _blnValidarIdioma ){
        this.Value = this.pCDate( this.Value, _blnValidarIdioma );
        return this;
    }
    
    this.pCDate = function( _strDataHora, _blnValidarIdioma ){        
        
        var dtmDataInvalida = new Date("1/1/1900 00:00:00");
        var dtmData = new Date(); //Objeto data a ser preenchido e retornado        
        var arrHora = new Array(); //Array que contem os valores da hora
        var arrData = new Array(); //Array que contem os valores da data        
        
        var strPadraoHoraIngles     = "HH:MM:SS AM/PM";
        var strPadraoHoraPortugues  = "HH:MM:SS";
        var strPadraoDataPortugues  = "D/M/A";
        
        if (_blnValidarIdioma != false){
            _blnValidarIdioma = true;
        }
        
        var strPadraoData = (_blnValidarIdioma) ? this.pToString(this.pToUpper(this.pGetLanguageParams("Idioma_FormatoData"))) : strPadraoDataPortugues;
        var strPadraoHora = (_blnValidarIdioma) ? this.pToString(this.pToUpper(this.pGetLanguageParams("Idioma_FormatoHora"))) : strPadraoHoraPortugues;
		
		try{		    
		    if (this.pIsObject(_strDataHora)){
		        dtmData = _strDataHora;
		        return;
		    }
		    
		    //Substitui os parâmetros por coringas para selecionar o separador utilizado
		    var strSeparador = this.pToUpper(strPadraoData);		
		    strSeparador = strSeparador.replace("D","@#").replace("M","@#").replace("A","@#").split("@#");
		    strSeparador = strSeparador[1];
			
			var strPossivelSeparador = strPadraoData.replace(strSeparador,"");
			strPossivelSeparador = strPossivelSeparador.replace(strSeparador,"");
			strPossivelSeparador = strPossivelSeparador.replace("D","");
			strPossivelSeparador = strPossivelSeparador.replace("M","");
			strPossivelSeparador = strPossivelSeparador.replace("A","");
            
            //Expressões RegEx            
            var objRegExp = new RegExp("[ ]*[0-9]{1,2}:[0-9]{1,2}[:]*[0-9]*[ ]*[(AM)(PM)]*[ ]*");
	        var strHora = objRegExp.exec(_strDataHora);
    	    
	        var objRegExp = new RegExp("[ ]*[0-9]+\\" + strSeparador + "[0-9]+\\" + strSeparador + "[0-9]+[ ]*");        	        
	        var strData = objRegExp.exec(_strDataHora);
	        
	        //Condição que garante (defesa) que a data será encontrada mesmo quando o separador 
	        //usado for diferente do utilizado no padrão cadastrado
	        if (this.pIsEmpty(strData)){
	            var objRegExp = new RegExp("[ ]*[0-9]+[/]+[0-9]+[/]+[0-9]+[ ]*");
	            var strData = objRegExp.exec(_strDataHora);
	        }
            
	        if(!this.pIsEmpty(strData)){
                
                var lngPosicaoDia = new Number();
                var lngPosicaoMes = new Number();
                var lngPosicaoAno = new Number();
                var arrPadraoData = new Array();                
                
                lngPosicaoDia = 0;
                lngPosicaoMes = 1;
                lngPosicaoAno = 2;
    	    
	            arrPadraoData = strPadraoData.toString().split(strSeparador);
	            arrData = strData.toString().split(strSeparador);
    	          
	            //Varre o padrão para definir as posições de d, m e a
	            for (i=0; i < arrPadraoData.length; i++){                
                    switch(this.pTrim(this.pToUpper(arrPadraoData[i])))                        
                    {
                    case "D":
                        lngPosicaoDia = i;
                        break;
                    case "D" + strPossivelSeparador:
                        lngPosicaoDia = i;
                        break;
                    case "M":
                        lngPosicaoMes = i;
                        break;
                    case "M" + strPossivelSeparador:
                        lngPosicaoMes = i;
                        break;
                    case "A":
                        lngPosicaoAno = i;
                        break;
                    case "A" + strPossivelSeparador:
                        lngPosicaoAno = i;
                        break;
                    }
                }
                
                var strDia = arrData[lngPosicaoDia];
                var strMes = arrData[lngPosicaoMes];
                var strAno = arrData[lngPosicaoAno];
        	    
    	        //Adiciona um 0 caso o valor não tenha 2 dígitos
	            strDia = this.pTrim(strDia);
	            if (strDia.length == 1)
	                strDia = "0" + strDia;
    	            
	            //Adiciona um 0 caso o valor não tenha 2 dígitos
                strMes = this.pTrim(strMes);
                if (strMes.length == 1)
	                strMes = "0" + strMes;
    	        
	            //Adiciona 20 caso o valor não tenha 4 dígitos
                strAno = this.pTrim(strAno);
                if (strAno.length == 2)
                    strAno = "20" + strAno;
                
                var strDataMontada = strPadraoData.replace("D",strDia).replace("M",strMes).replace("A",strAno);
                
                if (this.pIsDate(strDataMontada, _blnValidarIdioma)){
                    dtmData.setFullYear(strAno,strMes-1,strDia);
                }else{
                    throw "O valor "+ this.pToString(strData) +" não é uma data válida";
                }
            }else{ //Não informou a data
                dtmData = new Date(1900,00,01,00,00,00);
            }            
            
            
            if(!this.pIsEmpty(strHora)){                
                
                //Array que contem o ultimo valor da hora e AM/PM caso exista
                var arrAuxiliarHora = new Array();
                var strPadraoHoraAtual = new String();
            
                //O separador da hora não é configurável. O ":" é um separador internacional de hora
                //Vide ISO 8601 (http://www.w3.org/TR/NOTE-datetime)
                
                arrHora = strHora.toString().split(":");
                var strHoras = this.pTrim(arrHora[0]);
	            var strMinuto = this.pTrim(arrHora[1]);
	            
	            // Verifica o auxiliar (AM/PM) nos segundos e se não encontrar, procura nos minutos
	            if (!this.pIsEmpty(arrHora[2])){
	                arrAuxiliarHora = arrHora[2].split(" ");	                
	                
	                var strSegundo = this.pTrim(arrAuxiliarHora[0]);
	                if (!this.pIsEmpty(arrAuxiliarHora[1]))
	                    strPadraoHoraAtual = strPadraoHoraIngles;
	                else
	                    strPadraoHoraAtual = strPadraoHoraPortugues;
	            }else{	                
	                arrAuxiliarHora = arrHora[1].split(" ");
	                var strMinuto = this.pTrim(arrAuxiliarHora[0]);
	                if (!this.pIsEmpty(arrAuxiliarHora[1]))
	                    strPadraoHoraAtual = strPadraoHoraIngles;
	                else
	                    strPadraoHoraAtual = strPadraoHoraPortugues;
	            
	                var strSegundo = "00";
	            }
    	        
	            // Caso tenha sido informado PM, verificar a necessidade de ajustar as horas de acordo.
	            // Se não foi informado AM/PM ou equivalente, não há necessidade de ajuste nas horas.
	            if (arrAuxiliarHora.length > 1)
	            {
				    if (this.pCheckHourPrefix(arrAuxiliarHora[1], true) && strHoras>=0 && strHoras<12)	            
				        strHoras = Number(strHoras) + 12;	            
				    else if (this.pCheckHourPrefix(arrAuxiliarHora[1], true) && strHoras==12)	                
				        strHoras = "12";
				    else if (strHoras==0 || strHoras==12)
				      strHoras = "00";
			    }
                
	            //Valida a hora	            
                if (this.pIsHour(strHoras + ":" + strMinuto + ":" + strSegundo, false)){
                    dtmData.setHours(strHoras);
                    dtmData.setMinutes(strMinuto);
                    dtmData.setSeconds(strSegundo);                    
                }else{                      
                    throw "O valor "+ this.pToString(strHora) +" não é uma hora válida";
                }
                
    	    
	        }else{ //Não informou a hora
    	    
	            dtmData.setHours(00);
                dtmData.setMinutes(00);
                dtmData.setSeconds(00);
	        }
	        
	    }catch(e){	           
	        this.Message(e);
	        dtmData = dtmDataInvalida;
	    }finally{	        
	        dtmData.setMilliseconds(0);
            return dtmData;
        }
	}
	    
    //Retorna true ou false para a busca do auxiliar de hora PM
    this.pCheckHourPrefix = function(_strAuxiliarHora, _blnApenasPM){
        var blnRetorno = new Boolean();
        var strAuxiliarAM;
        
        if (_blnApenasPM != true){
            strAuxiliarAM = "|am|a\.m\.";
        }
        
        var objRegExp = new RegExp("^(pm|md|nm|p\.m\." + strAuxiliarAM + "){1}");
        blnRetorno = false;        
        
        if (!this.pIsEmpty(_strAuxiliarHora) && objRegExp.test(this.pToLower(_strAuxiliarHora))){
            blnRetorno = true;
        }
        
        return blnRetorno;    
    }
    //Retorna os parâmetros do idioma
    this.pGetLanguageParams = function(_strNomeCookie){
        var NomeCookie = this.pURLEncode(_strNomeCookie) + "=";        
	    var TamanhoNomeCookie = NomeCookie.length;
	    var TamanhoCookie = document.cookie.length;
	    var strRetorno;
	    var i = 0;
	    
	    while ( i < TamanhoCookie ){
		    var j = i + TamanhoNomeCookie;
		    if (document.cookie.substring( i, j ) == NomeCookie){
			    var lngString = document.cookie.indexOf(";", j);
			    if ( lngString == -1 ){
				    lngString = document.cookie.length;
			    }			    
			    strRetorno = this.pURLDecode(document.cookie.substring(j, lngString));
			    break;
		    }
		    i = document.cookie.indexOf(" ", i ) + 1;
		    if ( i == 0 ) {
			    break;
		    }
	    }

	    if (this.pIsEmpty(strRetorno)){
            // Se não encontrar o cookie desejado, tenta recarregar os cookies do idioma atual
            // Caso não seja possível recarregar o idioma atual, a função pChangeLanguage chama o PT-BR
            // Após alterar o idioma, chama recursivamente a função para que retorne o valor do cookie
            var strSiglaIdiomaAtual = this.pGetLanguageAbbreviation();
            this.pChangeLanguage(strSiglaIdiomaAtual);
            return this.pGetLanguageParams(_strNomeCookie);
        }
	    
	    return strRetorno;
    }
    
    /*
    Esta função existe especificamente para retornar a sigla do idioma atual para a função pGetLanguageParams
    que não pode chamá-la a si mesmo de forma recursiva pois dá um erro de Out of Stack Space 
    e Stack Overflow caso o cookie não exista.
    */
    this.pGetLanguageAbbreviation = function(){
        
        var strNomeCookie = "Idioma";
        var NomeCookie = this.pURLEncode(strNomeCookie) + "=";        
	    var TamanhoNomeCookie = NomeCookie.length;
	    var TamanhoCookie = document.cookie.length;
	    var strRetorno;
	    var i = 0;
	    while ( i < TamanhoCookie ){
		    var j = i + TamanhoNomeCookie;
		    if (document.cookie.substring( i, j ) == NomeCookie){
			    var lngString = document.cookie.indexOf(";", j);
			    if ( lngString == -1 ){
				    lngString = document.cookie.length;
			    }			    
			    strRetorno = this.pURLDecode(document.cookie.substring(j, lngString));
			    break;
		    }
		    i = document.cookie.indexOf(" ", i ) + 1;
		    if ( i == 0 ) {
			    break;
		    }
	    }
	    
	    return strRetorno;
    }
    
    //Função que cria um cookie no ASP, pois os cookies criado via JS não são acessados via ASP    
    this.pSetCookie = function (_strNomeCookie, _strValorCookie, _strExpiracao, _strCaminho, _strDominio, _strSeguro){
        var strURL = "/rpcSetCookie.asp?NomeCookie=" + escape(_strNomeCookie) + "&ValorCookie=" + escape(_strValorCookie) +
	    ((_strExpiracao) ? "&DataExpira=" + _strExpiracao : "") +
	    ((_strCaminho) ? "&Caminho=" + _strCaminho : "") +
	    ((_strDominio) ? "&Dominio=" + _strDominio : "") +
	    ((_strSeguro) ? "&Seguro=" + _strSeguro : "");
        this.pRPC(strURL);        
        return false;
    }
    
    //Função que cria todos os cookies necessários para o funcionamento da aplicação no idioma português-brasil
    this.pSetLanguageDefault = function (){    
        var strURL = "/rpcSetLanguageDefault.asp";
        this.pRPC(strURL);
        return false;
    }

    //Função que altera o idioma para a sigla informada
    this.pChangeLanguage = function (_strSigla){    
        
        var strRetorno;
        var cstStatusRpc = "FALHOU";
        
        if (!this.pIsEmpty(_strSigla)){
            var strURL = "/rpcMudarIdioma.asp?Sigla=" + _strSigla;
            strRetorno = this.pRPC(strURL);
            cstStatusRpc = "SUCESSO";
        }
        
        //Se houve alguma falha, alterar os cookies na mão
        if (this.pToUpper(strRetorno) != cstStatusRpc){
            this.pSetLanguageDefault();
        }
        return false;
    }
    
    //Retorna true se for uma data válida
    this.IsDate = function( _blnValidarIdioma ){
        return this.pIsDate( this.Value, _blnValidarIdioma );
    }
    this.pIsDate = function( _strConteudo, _blnValidarIdioma ) {
        
        if (this.pIsObject(_strConteudo)){
            var dtmDataInvalida = new Date(1900,00,01,00,00,00);            
            if (_strConteudo.getTime() <= dtmDataInvalida.getTime()){
                return false;
            }else{
                return true;
            }
        }
        
        //String que contém o padrão informado no cadastro do idioma        
        var strPadraoData = new String();
        var blnRetorno = false;
        var strPadraoData = "D/M/A";
        
        if (_blnValidarIdioma != false){
            _blnValidarIdioma = true;
        }
        
        strPadraoData = (_blnValidarIdioma) ? this.pToString(this.pToUpper(this.pGetLanguageParams("Idioma_FormatoData"))): strPadraoData;
        var objRegExp = new RegExp("[^0-9]","ig");

        try { 
			//Convertendo conteudo para string
			_strConteudo = this.pToString( _strConteudo );		
		    
		    //Substitui os parâmetros por coringas para selecionar o separador utilizado			
		    strSeparador = this.pToUpper(strPadraoData);
		    strSeparador = strSeparador.replace("D","@#").replace("M","@#").replace("A","@#").split("@#");		    
		    strSeparador = strSeparador[1];
		
			var strPossivelSeparador = strPadraoData.replace(strSeparador,"");
			strPossivelSeparador = strPossivelSeparador.replace(strSeparador,"");
			strPossivelSeparador = strPossivelSeparador.replace("D","");
			strPossivelSeparador = strPossivelSeparador.replace("M","");
			strPossivelSeparador = strPossivelSeparador.replace("A","");			

            if( _strConteudo.indexOf(strSeparador) != -1 ){
                
                //Retira os caracteres que não sejam numérico
                var arrConteudoData = _strConteudo.split(strSeparador);                
                for (a = 0; a < arrConteudoData.length; a++){                    
                    arrConteudoData[a] = arrConteudoData[a].replace(objRegExp, "");
                }
                
                var lngPosicaoDia = new Number();
                var lngPosicaoMes = new Number();
                var lngPosicaoAno = new Number();
                lngPosicaoDia = 0;
                lngPosicaoMes = 1;
                lngPosicaoAno = 2;                
                
                //Validação da data de acordo com o idioma do cookie
                var arrPadraoData = new Array();
                arrPadraoData = strPadraoData.split(strSeparador);
                
                for (i=0; i < arrPadraoData.length; i++){
                    //Pega as posições de acordo com o padrão e monta a data
                    switch(this.pTrim(this.pToUpper(arrPadraoData[i])))                        
                    {
                    case "D":
                        lngPosicaoDia = i;
                        break;
                    case "D" + strPossivelSeparador:
                        lngPosicaoDia = i;
                        break;
                    case "M":
                        lngPosicaoMes = i;
                        break;
                    case "M" + strPossivelSeparador:
                        lngPosicaoMes = i;
                        break;
                    case "A":
                        lngPosicaoAno = i;
                        break;
                    case "A" + strPossivelSeparador:
                        lngPosicaoAno = i;
                        break;
                    }
                }              
                
                var intDiaInformado = this.pTrim(arrConteudoData[lngPosicaoDia]);
                var intMesInformado = this.pTrim(arrConteudoData[lngPosicaoMes]);
                var intAnoInformado = this.pTrim(arrConteudoData[lngPosicaoAno]);
                
                if (intDiaInformado == 1 && intMesInformado == 1 && intAnoInformado == 1900){
                    return false;
                }
                
                var strDataTestar = strPadraoData.replace("D",intDiaInformado.replace(strPossivelSeparador,""));                
                strDataTestar = strDataTestar.replace("M",intMesInformado);
                strDataTestar = strDataTestar.replace("A",intAnoInformado.replace(strPossivelSeparador,""));                
                if (strDataTestar != _strConteudo && _blnValidarIdioma){
                    return false;
                }
                
    
                //Início - Verificação para ano bisexto
		        var intUltimoDiaFevereiro = 28;
		        if(intMesInformado == 2) {
			        if(intAnoInformado%400 == 0) {
				        intUltimoDiaFevereiro = 29;
			        }
			        else {
				        if(intAnoInformado%4 == 0 && intAnoInformado%100 != 0) {
                            intUltimoDiaFevereiro = 29;
	    		        }
			        }
		        }
		        //Fim - Verificação para ano bisexto
		        
		        var arrUltimoDia = new Array(11);
		        arrUltimoDia[0] = 31;
		        arrUltimoDia[1] = intUltimoDiaFevereiro;
		        arrUltimoDia[2] = 31;
		        arrUltimoDia[3] = 30;
		        arrUltimoDia[4] = 31;
		        arrUltimoDia[5] = 30;
		        arrUltimoDia[6] = 31;
		        arrUltimoDia[7] = 31;
		        arrUltimoDia[8] = 30;
		        arrUltimoDia[9] = 31;
		        arrUltimoDia[10] = 30;
		        arrUltimoDia[11] = 31;

                if( arrConteudoData.length > 2 ) {
                    if( intDiaInformado > 0 && intDiaInformado <= arrUltimoDia[parseFloat(intMesInformado - 1)] &&	
                        intMesInformado > 0 && intMesInformado <= 12 &&
                        intAnoInformado >= 1900 ) {
                        var objData = new Date();
                        objData.setFullYear(intAnoInformado, parseFloat(intMesInformado - 1), intDiaInformado);
                        if( this.pIsNumeric(objData.getDate()) && this.pIsNumeric(objData.getMonth()) && this.pIsNumeric(objData.getFullYear()) ) {
                            blnRetorno = true;
                        }
                    }
                }
            }
        }catch(e){
        }finally{            
            return blnRetorno;
        }
    }    
    
    // Retorna true ou false na validação entre a hora informada e o padrão definido
    this.IsHour = function( _blnValidarIdioma ){
        return this.pIsHour( this.Value, _blnValidarIdioma );
    }
    
    this.pIsHour = function( _strConteudo, _blnValidarIdioma ) {
        
        if (this.pIsObject(_strConteudo)){
            return true;
        }
        
        if (_blnValidarIdioma != false){
            _blnValidarIdioma = true;
        }
        
        var blnRetorno = true;        
        var arrHora = new Array();        
        var strPadraoHoraIngles = "HH:MM:SS AM/PM";
        var strPadraoHoraPortugues = "HH:MM:SS";
        var strParametroHora = new String();
        var strPadraoHoraAtual = new String();
        var strPadraoHora = (_blnValidarIdioma) ? this.pToString(this.pToUpper(this.pGetLanguageParams("Idioma_FormatoHora"))) : strPadraoHoraPortugues;        
               
        if (strPadraoHora == "HH24:MI"){ //Padrão 24h usado antigamente
            strPadraoHora = strPadraoHoraPortugues;
        }else if (strPadraoHora == "HH:MI"){ //Padrão 12h usado antigamente
            strPadraoHora = strPadraoHoraIngles;
        }else if (this.pIsEmpty(strPadraoHora)){
            strPadraoHora = strPadraoHoraPortugues;
        }
        
        try {
			_strConteudo = this.pToString(_strConteudo);
			
			if( _strConteudo.indexOf(":") != -1 ){//":" é o separador internacional de horas            
            
                var arrHora = _strConteudo.split(":");                
                
                if(arrHora.length == 2){
                    arrHora[2] = "00";
                }                
                
                /*if (arrHora[2].toUpperCase().indexOf("M") != -1){
                    strPadraoHora = strPadraoHoraIngles; //Define o padrão da data informada                        
                }else{
                    strPadraoHora = strPadraoHoraPortugues; //Define o padrão da data informada
                }*/
                
                
                //Verifica se o parâmetro AM/PM foi informado, o separa e atualiza o array na posição ss                
                //Verifica caso o usuário tenha informado um separador diferente de ":"
                if (arrHora[2].length!=0){                    
                    if (arrHora[2].indexOf(" ") != -1){
                        strParametroHora = arrHora[2].split(" ");
                        if (!this.pCheckHourPrefix(strParametroHora[1]) && !this.pIsEmpty(strParametroHora[1])){
                            blnRetorno = false;
                            return;                                
                        }
                        if (arrHora[0] > 12 && strParametroHora.length > 0){                            
                            blnRetorno = false;
                            return;
                        }
                        arrHora[2] = strParametroHora[0];
                    }
                }
                
                if (blnRetorno){
                
                    for (i=0; i < arrHora.length; i++){
                        
                        //Caso algum dos valores (h,m,s) não seja númerico retorna false
                        if (!this.pIsNumeric(arrHora[i])){                        
                            
                            blnRetorno = false;
                            
                        }else{
                        
                            if (i==0){//Valida as horas
                                if (strPadraoHora == strPadraoHoraPortugues){
                                    if (Number(arrHora[i]) < 0 || Number(arrHora[i]) > 23)
                                        blnRetorno = false;
                                        
                                }else{
                                    if (Number(arrHora[i]) < 1 || Number(arrHora[i]) > 12)
                                        blnRetorno = false;
                                    
                                }
                            }else{//Valida os minutos e segundos
                                if (Number(arrHora[i]) < 0 || Number(arrHora[i]) > 59)
                                   blnRetorno = false;
                            }
                        }
                    }
                }
                
            }else{
                blnRetorno = false;
            }
                
        }catch(e){
        }finally{
            return blnRetorno;            
        }
    }
    
    //Retorna true se o contéudo form um e-mail válido
    this.IsEmail = function(){
        return this.pIsEmail( this.Value );
    }
    this.pIsEmail = function( _strConteudo ){
        var blnRetorno = false;
        try{
			//Convertendo conteudo para string
			_strConteudo = this.pToString( _strConteudo );

            blnRetorno = /^([\w\.\-])+\@(([\w\-])+\.)+([\w ]{2,4})$/.test( _strConteudo );
        }catch(e){
            this.Message(e);
        }finally{
            return blnRetorno;
        }
    }
    
    //Retorna true se o conteudo for numérico
    this.IsNumeric = function( ){
        return this.pIsNumeric( this.Value );
    }        
    this.pIsNumeric = function( _strConteudo ){
        var blnRetorno = false;        
        var objRegExp = new RegExp("[0-9]","ig");
        try{
            if (objRegExp.test(_strConteudo) && !this.pIsEmpty(_strConteudo)){            
                blnRetorno = true;
            }
        }catch(e){
        }finally{
            return blnRetorno;
        }
    }
    
    //Retorna true se o conteudo for objeto
    this.IsObject = function(){
        return this.pIsObject( this.Value );
    }
    this.pIsObject = function( _strConteudo ){
        var blnRetorno = false;
        try{
            blnRetorno = (typeof _strConteudo == "object" );
        }catch(e){
        }finally{
            return blnRetorno;
        }
    }
    
    //Retorna true se o conteudo for uma função
    this.IsFunction = function(){
        return this.pIsFunction( this.Value );
    }
    this.pIsFunction = function( _strConteudo ){
        var blnRetorno = false;
        try{
            blnRetorno = (typeof _strConteudo == "function" );
        }catch(e){
        }finally{
            return blnRetorno;
        }
    }

    //Função que recebe obj data e a formata de acordo com o padrão do idioma
    this.FormatDate = function( _strFormatoDataHora, _blnValidarIdioma){
	    this.Value = this.pFormatDate( this.Value, _strFormatoDataHora, _blnValidarIdioma );
	    return this;
	}
	
    this.pFormatDate = function( _dtmDataInicial, _strFormatoDataHora, _blnValidarIdioma ){
    
        var strData = new String();
        var strAuxiliarHora = "";
        var strPadraoHoraIngles = "HH:MM:SS AM/PM";
        var strPadraoHoraPortugues = "HH:MM:SS";
        var strPadraoDataPortugues = "D/M/A";

        if (_blnValidarIdioma != false){
            _blnValidarIdioma = true;
        }
        
        var strPadraoData = (_blnValidarIdioma) ? this.pToString(this.pToUpper(this.pGetLanguageParams("Idioma_FormatoData"))) : strPadraoDataPortugues;
        var strPadraoHora = (_blnValidarIdioma) ? this.pToString(this.pToUpper(this.pGetLanguageParams("Idioma_FormatoHora"))) : strPadraoHoraPortugues;
        
        if(!this.pIsObject(_dtmDataInicial)){
            this.Message("A data/hora (" + _dtmDataInicial + ") não é do tipo date.");
            return false;
        }
        
        var strDia = this.pToString(_dtmDataInicial.getDate());
        var strMes = this.pToString(_dtmDataInicial.getMonth()+1);
        var strAno = this.pToString(_dtmDataInicial.getFullYear());
        var strHora = this.pToString(_dtmDataInicial.getHours());
        var strMinuto = this.pToString(_dtmDataInicial.getMinutes());
        var strSegundo = this.pToString(_dtmDataInicial.getSeconds());
        var cstFormatoData = "FORMATODATA";
        var cstFormatoHora = "FORMATOHORA";
        var cstFormatoHoraCompleta = "FORMATOHORACOMPLETA";
        var cstFormatoDataHora = "FORMATODATAHORA";
        var cstFormatoDataHoraCompleta = "FORMATODATAHORACOMPLETA";
        var lngPosicaoDia = new Number();
        var lngPosicaoMes = new Number();
        var lngPosicaoAno = new Number();
        var arrPadraoData = new Array();
        var arrMontaData = new Array(2);
        
        //Caso o padrão informado não seja válido, define padrão como Data/Hora
        if (_strFormatoDataHora != cstFormatoData && _strFormatoDataHora != cstFormatoDataHora && _strFormatoDataHora != cstFormatoHora && _strFormatoDataHora != cstFormatoDataHoraCompleta && _strFormatoDataHora != cstFormatoHoraCompleta){
            _strFormatoDataHora == cstFormatoDataHora;
        }
        
        if (strDia.length==1)
	        strDia = "0" + strDia;
        if (strMes.length==1)
	        strMes = "0" + strMes;
	    if (strAno.length==2)
	        strAno = "20" + strAno;
	        
	    if (strHora.length==1)
	        strHora = "0" + strHora;
        if (strMinuto.length==1)
	        strMinuto = "0" + strMinuto;
	    if (strSegundo.length==1)
	        strSegundo = "0" + strSegundo;
	        
	    if (strPadraoHora == "HH24:MI") //Padrão 24h usado antigamente
            strPadraoHora = strPadraoHoraPortugues;
        else if (strPadraoHora == "HH:MI") //Padrão 12h usado antigamente
            strPadraoHora = strPadraoHoraIngles;
        
        try{
            
            if (_strFormatoDataHora==cstFormatoData || _strFormatoDataHora==cstFormatoDataHora || _strFormatoDataHora == cstFormatoDataHoraCompleta){
                var strSeparador = this.pToUpper(strPadraoData);
		        strSeparador = strSeparador.replace("D","@#").replace("M","@#").replace("A","@#").split("@#");
		        strSeparador = strSeparador[1];
                
                lngPosicaoDia = 0;
                lngPosicaoMes = 1;
                lngPosicaoAno = 2;       
                
                arrPadraoData = strPadraoData.split(strSeparador);                
                strData = this.pToUpper(strPadraoData);
                strData = strData.replace("D",strDia);
                strData = strData.replace("M",strMes);
                strData = strData.replace("A",strAno);               
                
                if (!this.pIsDate(strData, _blnValidarIdioma)){                    
                    throw "Data inválida";
                }
            
            }
                        
            if (_strFormatoDataHora==cstFormatoHora || _strFormatoDataHora==cstFormatoDataHora || _strFormatoDataHora == cstFormatoDataHoraCompleta || _strFormatoDataHora == cstFormatoHoraCompleta){
                //Formata hora de acordo com o padrão do cookie
                if (strPadraoHora==strPadraoHoraIngles){
                    if (Number(strHora)>12){
                        strHora = Number(strHora) - 12;
                        if (this.pToString(strHora).length==1)
	                        strHora = "0" + strHora;
                        strAuxiliarHora = " PM";
                    }else if (Number(strHora)==0 || Number(strHora)==12){
                        strHora = "12";
                        strAuxiliarHora = " AM";
                    }else
                        strAuxiliarHora = " AM";
                        
                    strSegundo += strAuxiliarHora;            
                }
                
                if (!this.pIsHour(strHora + ":" + strMinuto + ":" + strSegundo, _blnValidarIdioma))
                    throw "Hora inválida";
                
                if (_strFormatoDataHora == cstFormatoDataHoraCompleta || _strFormatoDataHora == cstFormatoHoraCompleta){
                    strData += " " + strHora + ":" + strMinuto + ":" + strSegundo;
                }else{
                    strData += " " + strHora + ":" + strMinuto + strAuxiliarHora;
                }
            }
                            
        }catch(e){            
            this.Message(e); 
        }finally{ 
            return this.pTrim(strData); 
        }
    }    
    
    //Retorna o tipo do conteudo
    this.GetType = function(){
        return this.pGetType( this.toString() );
    }
    this.pGetType = function( _strConteudo ){
        var strTipoRetorno = cstTipoIndefinido;
        try{
            if( this.pIsDate( _strConteudo ) ){
                strTipoRetorno = cstTipoData;
            }else if( this.pIsCPF( _strConteudo ) || this.pIsCNPJ( _strConteudo ) ){
                strTipoRetorno = cstTipoDocumento;
            }else if( this.pIsNumeric( _strConteudo ) ){
                strTipoRetorno = cstTipoNumero;
            }else if( this.pIsObject( _strConteudo ) ){
                strTipoRetorno = cstTipoObjeto;
            }else{
                strTipoRetorno = cstTipoTexto;
            }
        }catch(e){
            this.Message(e);
        }finally{
            return strTipoRetorno;
        }
    }


    //Retorna o contéudo decodificado do padrão HTML
    this.HTMLDecode = function(){
        this.Value = this.pHTMLDecode( this.toString() );
        return this;
    }
    this.pHTMLDecode = function( _strConteudo ){
        try{
			//Convertendo conteudo para string
			_strConteudo = this.pToString( _strConteudo );

            _strConteudo = _strConteudo.replace(/&quot;/g, String.fromCharCode(34));
            _strConteudo = _strConteudo.replace(/&lt;/g  , String.fromCharCode(60));
            _strConteudo = _strConteudo.replace(/&gt;/g  , String.fromCharCode(62));
            _strConteudo = _strConteudo.replace(/&amp;/g , String.fromCharCode(38));
            _strConteudo = _strConteudo.replace(/&nbsp;/g, String.fromCharCode(32));
            for (var i=192; i <= 255; i++){
	            objRegExp = new RegExp("&#" + i + ";","g");
	            _strConteudo = _strConteudo.replace(objRegExp, String.fromCharCode(i));
            }
        }catch(e){
            this.Message(e);	        
        }finally{
            return _strConteudo;
        }
    }
    
    //Retorna o conteudo codificado no padrão HTML
    this.HTMLEncode = function(){
        this.Value = this.pHTMLEncode( this.toString() );
        return this;
    }
    this.pHTMLEncode = function( _strConteudo ){
        try{                
			//Convertendo conteudo para string
			_strConteudo = this.pToString( _strConteudo );

            var strRegExp = "";

            strRegExp = new RegExp(String.fromCharCode(38), "g");
            _strConteudo = _strConteudo.replace(strRegExp, "&amp;" );

            strRegExp = new RegExp(String.fromCharCode(34), "g");
            _strConteudo = _strConteudo.replace(strRegExp, "&quot;" );

            strRegExp = new RegExp(String.fromCharCode(60), "g");
            _strConteudo = _strConteudo.replace(strRegExp, "&lt;" );

            strRegExp = new RegExp(String.fromCharCode(62), "g");
            _strConteudo = _strConteudo.replace(strRegExp, "&gt;" );

            strRegExp = new RegExp(String.fromCharCode(32), "g");
            _strConteudo = _strConteudo.replace(strRegExp, "&nbsp;" );

            for ( var i=192; i <= 255; i++ ){
                strRegExp = new RegExp(String.fromCharCode(i), "g");
                _strConteudo = _strConteudo.replace(strRegExp, "&#" + i + ";" );
            }
        }catch(e){
            this.Message(e);	        
        }finally{
            return _strConteudo;
        }
    }

    //Retorna uma quantidade x de caracteres a esquerda do conteudo;
    //_Quantidade --> Quantidade de carateres a ser capturado
    this.Left = function( _Quantidade ){ 
        this.Value = this.pLeft( this.toString(), _Quantidade );
        return this;
    }
    this.pLeft = function( _strConteudo, _Quantidade ){ 
        try{
			//Convertendo conteudo para string
			_strConteudo = this.pToString( _strConteudo );

            _strConteudo = _strConteudo.substring(0,_Quantidade);
        }catch(e){
            this.Message(e);
        }finally{                
            return _strConteudo; 
        }
    }

    //Retorna o Tamanho do conteudo;
    this.Length = function( ){ 
        return this.pLength( this.toString() );
    }
    this.pLength = function( _strConteudo ){ 
        try{
			//Convertendo conteudo para string
			_strConteudo = this.pToString( _strConteudo );

            _strConteudo = _strConteudo.toString();
            return _strConteudo.length;
        }catch(e){
            return 0;
        }                 
    }

    //Exibe uma Messagem como alert    
    this.Message = function(_vrtMessagem){
        if(this.pIsObject(_vrtMessagem)){
            alert( "Mensagem: " + _vrtMessagem.message );
        }else{
            alert(_vrtMessagem);
        }
    }

    //Retorna o conteudo entre Inicio e Fim
    //_Inicio --> Define o ínicio do conteudo que será capturado
    //_Fim --> Define o Fim do conteudo que será capturado
    this.Mid = function( _Inicio, _Fim, _blnQuantiade ){
        this.Value = this.pMid( this.toString(), _Inicio, _Fim );
        return this;
    }
    this.pMid = function( _strConteudo, _Inicio, _Fim ){
        try{ 
			//Convertendo conteudo para string
			_strConteudo = this.pToString( _strConteudo );

            _strConteudo = _strConteudo.substring(_Inicio, _Fim + 1 );
        }catch(e){
            this.Message(e);
        }finally{                
            return _strConteudo; 
        }
    }

    //Retorna apenas numeros do conteudo
    this.OnlyNumber = function(){
        this.Value = this.pOnlyNumber( this.Value );
        return this;
    }
    this.pOnlyNumber = function( _strConteudo ){
        var strConteudoAlterado = "";
        var strCaracter = "";
        try{
			//Convertendo conteudo para string
			_strConteudo = this.pToString( _strConteudo );

            for(var i=0; i < this.pLength(_strConteudo); i++ ){
                strCaracter = _strConteudo.substring( i, i+1 );
                if( ! isNaN( strCaracter ) && strCaracter != " " && strCaracter != "" && strCaracter != null ){
                    strConteudoAlterado += strCaracter.toString();
                }
            }
        }catch(e){
            strCaracter = "";
        }finally{
            return strConteudoAlterado;
        }
    }
    
    //Retorna o valor informado caso o valor testado seja vazio
    this.ReplaceEmpty = function( _strTextoASubstituir ){
        this.Value = this.pReplaceEmpty( this.Value, _strTextoASubstituir );
        return this;
    }
    
    this.pReplaceEmpty = function( _strTextoATestar, _strTextoASubstituir ){
        try{
            return (! this.pIsEmpty(_strTextoATestar) ) ? _strTextoATestar : _strTextoASubstituir;
        }catch(e){
            this.Message(e);
        }
    } 
    
    
    //Retorna um conteudo com parte dele substituido por outro
    this.Replace = function( _strTextoASubstituir, _strTextoUtilizadoParaSubstituicao ){
        this.Value = this.pReplace( this.toString(), _strTextoASubstituir, _strTextoUtilizadoParaSubstituicao );
        return this;
    }
	this.pReplace = function( _strConteudo, _strTextoASubstituir, _strTextoUtilizadoParaSubstituicao ){
        try{
            //Convertendo conteudo para string
            _strConteudo = this.pToString( _strConteudo );                        
                        
            if(_strTextoASubstituir.indexOf(';') == -1 && _strTextoASubstituir.indexOf('/') == -1 && _strTextoASubstituir.indexOf('\\') == -1 && _strTextoASubstituir.indexOf('[') == -1 && _strTextoASubstituir.indexOf('(') == -1 && _strTextoASubstituir.indexOf('*') == -1 && _strTextoASubstituir.indexOf('$') == -1 && _strTextoASubstituir.indexOf('.') == -1 && _strTextoASubstituir.indexOf('+') == -1)
            {                            
                _strConteudo = _strConteudo.replace(eval('/' + _strTextoASubstituir + '/ig'), _strTextoUtilizadoParaSubstituicao);                           
            }
            else
            {
                var lngNumRepeticoes = _strConteudo.toUpperCase().split(_strTextoASubstituir.toUpperCase()).length;
                
                for(var x = 0; x < lngNumRepeticoes; x++){
                   _strConteudo = _strConteudo.replace(_strTextoASubstituir, _strTextoUtilizadoParaSubstituicao);               
                   _strConteudo = _strConteudo.replace(_strTextoASubstituir.toLowerCase(), _strTextoUtilizadoParaSubstituicao);               
                   _strConteudo = _strConteudo.replace(_strTextoASubstituir.toUpperCase(), _strTextoUtilizadoParaSubstituicao);               
                }
            }                
        }catch(e){
            this.Message(e);
        }finally{                
            return _strConteudo; 
        }
    }

    //Retorna uma quantidade x de caracteres a direita do conteudo;
    //_Quantidade --> Quantidade de carateres a ser capturado
    this.Right = function( _Quantidade ){
        this.Value = this.pRight( this.toString(), _Quantidade );
        return this;
    } 
    this.pRight = function( _strConteudo, _Quantidade ){ 
        try{
			//Convertendo conteudo para string
			_strConteudo = this.pToString( _strConteudo );

            _strConteudo = _strConteudo.substring(_strConteudo.length - _Quantidade, _strConteudo.length );
        }catch(e){
            this.Message(e);
        }finally{                
            return _strConteudo; 
        }
    }
    
    //Retorna o conteudo de uma url acessada
    this.RPC = function( _strURL ){
        this.Value = this.pRPC( _strURL );
        return this;
    } 
    this.pRPC = function( _strURL, _Handle, _MethodPost, _Conteudo ){
        //Variáveis internas
        var strRetornoURL;
        var oXMLHTTP;
        var strTipoFunction = "function";
        var strStatusHTTP = "complete";        
        var blnModoAssincrono = ( ! this.pIsEmpty( _Handle ) ? true : false );
        var Method = ( _MethodPost != true )? "GET" : "POST";
        
        try{
            //Criando instância de objeto xmlhttp
            try
            { oXMLHTTP = new ActiveXObject("Msxml2.XMLHTTP"); }catch(e1){   
                try
                { oXMLHTTP = new ActiveXObject("Microsoft.XMLHTTP"); }catch(e2){   
                    try 
                    { oXMLHTTP = new XMLHttpRequest(); }catch(e3){ 
                        oXMLHTTP = null; 
                    }
                }
            }
            
            if ( this.pIsObject( oXMLHTTP ) )
            {
                //Executando a url informada
                oXMLHTTP.open( Method, _strURL, blnModoAssincrono );                
                oXMLHTTP.setRequestHeader('Content-Type',"application/x-www-form-urlencoded; charset=iso-8859-1");
                    
                //Verifica se o modo solicitado é o Assíncrono
                if(blnModoAssincrono) {
                    oXMLHTTP.onreadystatechange = function (){
                        if( oXMLHTTP.readyState == 4 || oXMLHTTP.readyState == strStatusHTTP ){
					        if( oXMLHTTP.status == 200 ){
					            strRetornoURL = oXMLHTTP.responseText;
						        //Verificando necessidade de codificação dos dados
						        if( (typeof _Handle == strTipoFunction) ){
							        eval( _Handle(strRetornoURL) );
						        }
	                        }
                        }
                    }
                    oXMLHTTP.send( _Conteudo );
                }
                else
                {
                    oXMLHTTP.send( _Conteudo );
                    if( oXMLHTTP.status == 200 )
                    {
                        strRetornoURL = oXMLHTTP.responseText;
                    }
                }
            }
        }catch(e){}
        finally{
            return strRetornoURL;
        }
    }

    //Retorna conteudo em maiusculo
    this.ToLower = function(){ 
        this.Value = this.pToLower( this.toString() );
        return this;
    }
    this.pToLower = function( _strConteudo ){ 
        try{
			//Convertendo conteudo para string
			_strConteudo = this.pToString( _strConteudo );

            _strConteudo = _strConteudo.toLowerCase();
        }catch(e){
            this.Message(e);
        }finally{                
            return _strConteudo; 
        }
    }

    //Retorna o conteudo como string (este metódo deve ser chamada toString() com t em minusculo mesmo
    this.ToString = function(){
        return this.toString();
    }
    this.pToString = function ( _strConteudo ){
        return this.ptoString( _strConteudo );
    }
    //Início - Funções necessárias para serem executadas de forma implícita
    this.toString = function(){ 
        //return = this.ptoString( this.Value );
        return this.ptoString( this.Value );
    }
    this.ptoString = function( _strConteudo ){ 
        try{
            _strConteudo = _strConteudo.toString(); 
        }catch(e){
            _strConteudo = "";
        }finally{                
            return _strConteudo; 
        }
    }
    //Fim - Funções necessárias para serem executadas de forma implícita
    
    //Retorna conteudo em maiusculo
    this.ToUpper = function(){
        this.Value = this.pToUpper( this.toString() );
        return this;
    } 
    this.pToUpper = function( _strConteudo ){ 
        try{
			//Convertendo conteudo para string
			_strConteudo = this.pToString( _strConteudo );

            _strConteudo = _strConteudo.toUpperCase();
        }catch(e){
            this.Message(e);
        }finally{                
            return _strConteudo; 
        }
    }

    //Retorna o conteudo sem espaços antes e depois
    this.Trim = function(){
        this.Value = this.pTrim( this.toString() );
        return this;
    }
    this.pTrim = function( _strConteudo ){
        try{
			//Convertendo conteudo para string
			_strConteudo = this.pToString( _strConteudo );

            if( _strConteudo.length > 0 ){
                while( _strConteudo.charAt(0) == " " || this.pURLEncode(_strConteudo.charAt(0)) == "%0A" || this.pURLEncode(_strConteudo.charAt(0)) == "%09" ){
                    _strConteudo = _strConteudo.substring(1, _strConteudo.length);
                }
                while( _strConteudo.charAt(_strConteudo.length-1) == " " || this.pURLEncode(_strConteudo.charAt(_strConteudo.length-1)) == "%0A" || this.pURLEncode(_strConteudo.charAt(_strConteudo.length-1)) == "%09" ){
                    _strConteudo = _strConteudo.substring(0, _strConteudo.length-1);
                }
            }
        }catch(e){ 
            this.Message(e) 
        }
        finally{ 
            return _strConteudo; 
        }
    }
    
    //Retorna o conteudo formatado no modelo URL
    this.URLEncode = function( _blnUTF8 ){
        this.Value = this.pURLEncode( this.toString(), _blnUTF8 );
        return this;
    }
    this.pURLEncode = function( _strConteudo, _blnUTF8 ){
		if( _blnUTF8 != true ){ _blnUTF8 = false }
        try{
			//Convertendo conteudo para string
			_strConteudo = this.pToString( _strConteudo );

			if( ! _blnUTF8 ){
				_strConteudo = escape( _strConteudo );
				_strConteudo = _strConteudo.replace( /\+/g, "%2B"); //Não pode mudar a ordem deste item
				_strConteudo = _strConteudo.replace( /%20/g, "+");
				_strConteudo = _strConteudo.replace( /\*/g, "%2A");
				_strConteudo = _strConteudo.replace( /-/g, "%2D");
				_strConteudo = _strConteudo.replace( /\./g, "%2E");
				_strConteudo = _strConteudo.replace( /\//g, "%2F");
				_strConteudo = _strConteudo.replace( /\@/g, "%40");
				_strConteudo = _strConteudo.replace( /_/g, "%5F");
            }else{
				_strConteudo = encodeURI(_strConteudo);
	        }
        }catch(e){
            this.Message(e);
        }finally{              
          return _strConteudo; 
        }
    }
    
    //Retorna o conteudo descodificado do padrão URL
    this.URLDecode = function( _blnUTF8){
        this.Value = this.pURLDecode( this.toString(), _blnUTF8 );
        return this;
    }           
    this.pURLDecode = function( _strConteudo, _blnUTF8 ){
		if( _blnUTF8 != true ){ _blnUTF8 = false }
        try{
			//Convertendo conteudo para string
			_strConteudo = this.pToString( _strConteudo );

			if( ! _blnUTF8 ){
				var strRegularExpression = /\+/g;
				_strConteudo = unescape(String(_strConteudo).replace(strRegularExpression, " ")); 
            }else{
				_strConteudo = decodeURI(_strConteudo);
            }
        }catch(e){
            this.Message(e);
        }finally{              
          return _strConteudo; 
        }
    }
    

    //Retorno o caracter separador das casas decimais
    this.pCaracterDecimais = function(){    
        strCarecterDecimais = this.pToString(this.pGetLanguageParams("Idioma_SeparadorDecimal"));
        return strCarecterDecimais;
    }
    
    //Retorno o caracter separador de milhar
    this.pCaracterMilhar = function(){    
        strCaracterMilhar = this.pToString(this.pGetLanguageParams("Idioma_SeparadorMilhar"));
        return strCaracterMilhar;
    }
    
    //Retorna a mascara para montagem da moeda
    this.pMascaraMoeda = function(){    
        strMascaraMoeda = this.pURLDecode(this.pToString(this.pGetLanguageParams("Idioma_MascaraMoeda")));
        return strMascaraMoeda;
    }
    
    //Formata valor informado no padrão numerico com x numeros de casas decimais,
    //Máscara de moeda e definição de caracter de centavos.
    this.FormatNumber = function( lngCasasDecimais, blnTipoMoeda, blnForcarDecimaisComPontos ) {
        this.Value = this.pFormatNumber( this.Value, lngCasasDecimais, blnTipoMoeda, blnForcarDecimaisComPontos, blnMascararSaida );
        return this;
    }
    this.pFormatNumber = function( vrtValorOrigem, lngCasasDecimais, blnTipoMoeda, blnForcarDecimaisComPontos, blnMascararSaida ) {        
	    try{
	        var strCarecterSeparador;
	        var strCarecterSeparadorErrado;
            var strValorOrigem = vrtValorOrigem.toString();
	        var strValorDecimal = "";
	        
	        if( ! this.pIsNumeric( lngCasasDecimais ) ){
	            lngCasasDecimais = 2;
	        }
	        //************************************************************************
	        // Tratamento da moeda
	        //************************************************************************
	        strMascara = this.pMascaraMoeda();
            var strSeparadorMilhar = strMascara.substr(strMascara.indexOf("[MILHAR]")+8,1);
            if(strSeparadorMilhar == '['){
                strSeparadorMilhar = '';
            }
            if(strMascara.indexOf("[DECIMAL]") >= 0){
                strSeparadorDecimal = strMascara.substr(strMascara.indexOf("[DECIMAL]")-1,1);
                if(strSeparadorDecimal == '['){
                    strSeparadorDecimal = '';
                }
            }
            var strMascaraTemp = strMascara.replace('[MILHAR]' + strSeparadorMilhar + '[CENTENA]' + strSeparadorDecimal + '[DECIMAL]', '');                
            strValorOrigem = strValorOrigem.replace(strMascaraTemp,"");
	        //************************************************************************
	        
            if( blnTipoMoeda != true ){
                strCarecterSeparador = this.pCaracterDecimais();
	            strCarecterSeparadorErrado = this.pCaracterMilhar();
                blnTipoMoeda = false;
            }else{
                strCarecterSeparador = strSeparadorDecimal;
	            strCarecterSeparadorErrado = strSeparadorMilhar;
                strMascara = strMascara.replace('[MILHAR]' + strCarecterSeparadorErrado + '[CENTENA]', '[VALOR]');
                blnMascararSaida = true;
            }
            
            if( blnForcarDecimaisComPontos != true ){
                blnForcarDecimaisComPontos = false;
            }
            
            if( blnMascararSaida != true ){
                blnMascararSaida = false;
            }        
            
            var strCaracter = '';
            var strValorTemporario = strValorOrigem;
            var strRegExp = new RegExp("[^0-9]+");
            var arrCaracteres = new Array();
            
            while (strRegExp.test(strValorTemporario))
            {   
                strCaracter = strRegExp.exec(strValorTemporario); 
                strValorTemporario = this.pReplace(strValorTemporario, strCaracter[0], '');
                arrCaracteres[arrCaracteres.length] = strCaracter[0];
            }
            
	        if( arrCaracteres.length > 1 ){
		        if( strValorOrigem.indexOf(arrCaracteres[0]) < strValorOrigem.indexOf(arrCaracteres[1]) ){
		            strValorOrigem = this.pReplace(strValorOrigem, arrCaracteres[0], "");
		            strValorOrigem = this.pReplace(strValorOrigem, arrCaracteres[1], strCarecterSeparador);		            
		        }else{
		            strValorOrigem = this.pReplace(strValorOrigem, arrCaracteres[1], "");
		            strValorOrigem = this.pReplace(strValorOrigem, arrCaracteres[0], strCarecterSeparador);
		        }
	        }else if(arrCaracteres.length == 1){
	            strValorOrigem = this.pReplace(strValorOrigem, arrCaracteres[0], strCarecterSeparador);		        
	        }	        
        	
	        if (strValorOrigem.indexOf(strCarecterSeparador) != -1){
		        strValorDecimal = strValorOrigem.split(strCarecterSeparador)[1];
		        strValorOrigem = strValorOrigem.split(strCarecterSeparador)[0];
	        }
	        if( this.pIsEmpty(strValorOrigem) ){
	            strValorOrigem = "0";
	        }
	        strValorOrigem = parseFloat(strValorOrigem);
	        
	        var lngTamanhoDecimal = this.pLength(strValorDecimal);
    	    var lngTamanhoInteiro = this.pLength(strValorOrigem);
    	    var strValorParteInteira = "";

            if( blnMascararSaida ){
    	        if( lngTamanhoInteiro > 3 ){
    	            for(var i=0; i < lngTamanhoInteiro; i++ ){
    	                strValorParteInteira = this.pMid(strValorOrigem, (lngTamanhoInteiro - i) - 1, (lngTamanhoInteiro - i) - 1) + strValorParteInteira;
        	            if( ( (i+1) % 3 == 0 ) && ( (i+1) != lngTamanhoInteiro ) ){
        	                strValorParteInteira = (blnForcarDecimaisComPontos ? "," : strCarecterSeparadorErrado) + strValorParteInteira;
        	            }
    	            }
    	            strValorOrigem = strValorParteInteira;
    	        }
    	    }
    	    
	        if(lngTamanhoDecimal > lngCasasDecimais){
		        var lngArredondamentoCasas = 0;
		        var lngDecimalAMais = parseFloat(strValorDecimal.substring(lngCasasDecimais, lngCasasDecimais+1));
		        var strBaseCalculoArredondamentoCasaAdicional = ".";
		        
		        if(  lngDecimalAMais >=5 ){
		            lngArredondamentoCasas = 1;
		        }
		        
		        if( lngCasasDecimais == 0 ){
					strValorOrigem = strValorOrigem + lngArredondamentoCasas;
					strValorDecimal = "";
		        }else{
					//Necessário a inclusão da concatenação do "1" para evitar calculo de dizima pelo javascript
					//Não deverá ser removido.
					strValorDecimal = parseFloat("." + strValorDecimal.substring(0, lngCasasDecimais) + "1");
					for( j=0; j < lngCasasDecimais-1; j++ ){
						strBaseCalculoArredondamentoCasaAdicional += "0";
					}
					strValorDecimal += parseFloat(strBaseCalculoArredondamentoCasaAdicional + lngArredondamentoCasas + "1");
					strValorDecimal = strValorDecimal.toString();
					strValorDecimal = strValorDecimal.substring(2, lngCasasDecimais + 2 );
		        }
		        lngTamanhoDecimal = this.pLength(strValorDecimal);
	        }
    	    
	        for(var i=0; i < parseInt(lngCasasDecimais)-lngTamanhoDecimal; i++){
		        strValorDecimal += "0";
	        }
    	    
            if( blnForcarDecimaisComPontos ){
	            strCarecterSeparador = ".";
	            strCarecterSeparadorErrado = ",";
            }
    	    
	        if(blnTipoMoeda == false ){
    			strValorOrigem += strCarecterSeparador + strValorDecimal;	             
	        }else if(blnTipoMoeda == true){	        	            
	            strMascara = strMascara.replace('[VALOR]', strValorOrigem);
	            strValorOrigem = strMascara.replace('[DECIMAL]', strValorDecimal);
	        }
        }catch(e){
            strValorOrigem = vrtValorOrigem;
        }finally{
	        return strValorOrigem;
	    }
    }
}