/**
 * Método que valida se o conteúdo de um objeto (objeto.value) é válido como
 * nome de arquivo e se contém a extensão desejada. A comparação entre a
 * extensão do nome do arquivo e as extensões permitidas non-case-sensitive.
 * 
 * 
 * @param varField -
 *            objeto que contém o texto a ser validado.
 * @param strFieldName -
 *            nome do objeto que será exibido nos alerts, em caso de conteúdo
 *            inválido.
 * @param blnRequired -
 *            boolean que determina a obrigatoriedade do campo.
 * @param arrayDeExtensoesValidasSemPonto -
 *            um Array de Strings que contém a lista de extensões válidas.
 *            Exemplo de como este parâmetro deve ser passado: new Array("jpg",
 *            "png", "jpeg")
 * 
 * @return - true: campo válido; false: campo inválido.
 */
function validaExtensao(varField, strFieldName, blnRequired, arrayDeExtensoesValidasSemPonto){
	// varField.value = trim(varField.value);
	if(blnRequired && varField.value.length == 0){
		alert("O campo \"" + strFieldName + "\" é obrigatorio!");
		selectValue(varField);
		setFocus(varField);
		return false;
	}else if(varField.value.length > 0 && varField.value.lastIndexOf(".") == -1){
		alert("A extensão do arquivo no campo \"" + strFieldName + "\" deve estar separada por um ponto!");
		selectValue(varField);
		setFocus(varField);
		return false;
	}else if(varField.value.length > 0){
		var fieldExtension = varField.value.substr(varField.value.lastIndexOf(".")).toLowerCase();
		
		// Se a extensão do arquivo for igual a alguma das extensões do ARRAY
        // retorna "TRUE".
		for(var i = 0; i < arrayDeExtensoesValidasSemPonto.length; i++){
			var validExtension = ("." + arrayDeExtensoesValidasSemPonto[i]).toLowerCase();
			if(fieldExtension == validExtension){
				return true;
			}
		}
		
		// Se a extensão do arquivo não for igual a nenhuma das extensões do
        // ARRAY, o "FOR" acima não retornará
		// "TRUE" e o bloco abaixo será executado.
		alert("Extensão inválida para o arquivo no campo \"" + strFieldName + "\"!");
		selectValue(varField);
		setFocus(varField);
		return false;
	}else{// ocorre apenas quando o campo não é obrigatório e está vazio.
		return true;
	}
}

/**
 * Método que valida se o conteúdo de um objeto (objeto.value) é um endereço de
 * domínio válido. Caracteres inválidos para o endereço e caracteres inválidos
 * para o banco de dados são bloqueados. Protocolo "https://" ou "http://"
 * obrigatório.
 * 
 * @param varField -
 *            objeto que contém o texto a ser validado.
 * @param strFieldName -
 *            nome do objeto que será exibido nos alerts, em caso de conteúdo
 *            inválido.
 * @param blnRequired -
 *            boolean que determina a obrigatoriedade do campo.
 * @param maxlength -
 *            inteiro que determina qual o número máximo de caracteres do campo.
 * @return - true: texto válido; false: texto inválido.
 */
function validaDominioWeb(varField, strFieldName, blnRequired, maxlength, protocolo){
	varField.value = trim(varField.value);
	if(blnRequired && varField.value.length == 0){
		alert("O campo \"" + strFieldName + "\" é obrigatorio.");
		selectValue(varField);
		setFocus(varField);
		return false;
	}else if(maxlength != null && varField.value.length > maxlength){
		alert("O tamanho maximo do campo \"" + strFieldName + "\" é de " + maxlength + " caracteres (tamanho atual:" + trim(varField.value).length + ").");
		selectValue(varField);
		setFocus(varField);
		return false;
	
	// valida a existencia de caracteres inválidos para o banco de dados...
	}else if(varField.value.indexOf("&") != -1){
		alert("Não é permitido o uso do caractere \"&\" no campo \"" + strFieldName + "\".");
		selectValue(varField);
		setFocus(varField);
		return false;
	}else if(varField.value.indexOf("\"") != -1){
		alert("Não é permitido o uso de aspas no campo \"" + strFieldName + "\".");
		selectValue(varField);
		setFocus(varField);
		return false;
	}else if(varField.value.indexOf("'") != -1){
		alert("Não é permitido o uso de aspas simples no campo \"" + strFieldName + "\".");
		selectValue(varField);
		setFocus(varField);
		return false;
	
	// verifica se o endereço tem um protocolo...
	}else if(varField.value.length > 0 && varField.value.indexOf("://") == -1){
		alert("O endereço deve ter um protocolo no campo \"" + strFieldName + "\".");
		selectValue(varField);
		setFocus(varField);
		return false;
	
	// se o protocolo foi passado como parâmetro, verifica se o mesmo esta no
    // começo da string...
	}else if(protocolo != null && varField.value.length > 0 && varField.value.indexOf(protocolo + "://") != 0){
		alert("O protocolo \"" + protocolo + "\" deve ser citado no início do endereço no campo \"" + strFieldName + "\".");
		selectValue(varField);
		setFocus(varField);
		return false;
		
	// valida a existencia de caracteres inválidos para o endereço web...
	}else if(varField.value.length > 0 && varField.value.substring(varField.value.indexOf("://")+3).indexOf("/") != -1){
		alert("Não é permitido o uso de \"/\", após o protocolo, no campo \"" + strFieldName + "\".");
		selectValue(varField);
		setFocus(varField);
		return false;
	}else if(varField.value.length > 0 && varField.value.substring(varField.value.indexOf("://")+3).indexOf(":") != -1){
		alert("Não é permitido o uso de \":\", após o protocolo, no campo \"" + strFieldName + "\".");
		selectValue(varField);
		setFocus(varField);
		return false;
	
	// valida a existencia de caracteres após o protocolo, para impedir que seja
    // enviado apenas parte do endereço...
	}else if(varField.value.length > 0 && varField.value.substring(varField.value.indexOf("://")+3).length == 0){
		alert("Deve ser informado um domínio, após o protocolo, no campo \"" + strFieldName + "\".");
		selectValue(varField);
		setFocus(varField);
		return false;
	
	}else{
		return true;
	}
}

/**
 * Método que valida se o conteúdo de um objeto (objeto.value) é um endereço de
 * domínio válido. Caracteres inválidos para o endereço e caracteres inválidos
 * para o banco de dados são bloqueados. Protocolo "https://" ou "http://"
 * obrigatório.
 * 
 * @param varField -
 *            objeto que contém o texto a ser validado.
 * @param strFieldName -
 *            nome do objeto que será exibido nos alerts, em caso de conteúdo
 *            inválido.
 * @param blnRequired -
 *            boolean que determina a obrigatoriedade do campo.
 * @param maxlength -
 *            inteiro que determina qual o número máximo de caracteres do campo.
 * @return - true: texto válido; false: texto inválido.
 */
function validaDominioWebComBarraEDoisPontosAposBarra(varField, strFieldName, blnRequired, maxlength, protocolo){
	varField.value = trim(varField.value);
	if(blnRequired && varField.value.length == 0){
		alert("O campo \"" + strFieldName + "\" é obrigatorio.");
		selectValue(varField);
		setFocus(varField);
		return false;
	}else if(maxlength != null && varField.value.length > maxlength){
		alert("O tamanho maximo do campo \"" + strFieldName + "\" é de " + maxlength + " caracteres (tamanho atual:" + trim(varField.value).length + ").");
		selectValue(varField);
		setFocus(varField);
		return false;
	
	// valida a existencia de caracteres inválidos para o banco de dados...
	}else if(varField.value.indexOf("&") != -1){
		alert("Não é permitido o uso do caractere \"&\" no campo \"" + strFieldName + "\".");
		selectValue(varField);
		setFocus(varField);
		return false;
	}else if(varField.value.indexOf("\"") != -1){
		alert("Não é permitido o uso de aspas no campo \"" + strFieldName + "\".");
		selectValue(varField);
		setFocus(varField);
		return false;
	}else if(varField.value.indexOf("'") != -1){
		alert("Não é permitido o uso de aspas simples no campo \"" + strFieldName + "\".");
		selectValue(varField);
		setFocus(varField);
		return false;
	
	// verifica se o endereço tem um protocolo...
	}else if(varField.value.length > 0 && varField.value.indexOf("://") == -1){
		alert("O endereço deve ter um protocolo no campo \"" + strFieldName + "\".");
		selectValue(varField);
		setFocus(varField);
		return false;
	
	// se o protocolo foi passado como parâmetro, verifica se o mesmo esta no
    // começo da string...
	}else if(protocolo != null && varField.value.length > 0 && varField.value.indexOf(protocolo + "://") != 0){
		alert("O protocolo \"" + protocolo + "\" deve ser citado no início do endereço no campo \"" + strFieldName + "\".");
		selectValue(varField);
		setFocus(varField);
		return false;
	
	// valida a existencia de caracteres após o protocolo, para impedir que seja
    // enviado apenas parte do endereço...
	}else if(varField.value.length > 0 && varField.value.substring(varField.value.indexOf("://")+3).length == 0){
		alert("Deve ser informado um domínio, após o protocolo, no campo \"" + strFieldName + "\".");
		selectValue(varField);
		setFocus(varField);
		return false;
	
	}else{
		return true;
	}
}

/**
 * Método que valida se o conteúdo de um textField é um horário válido. Este
 * método permite que o horário validado passe com dois formatos diferentes
 * HH:MM:SS e HH:MM.
 * 
 * @param varField
 *            objeto que contém o texto a ser validado
 * @param strFieldName
 *            nome do objeto que será exibido nos alerts, em caso de conteúdo
 *            inválido
 * @param blnRequired
 *            boolean que determina a obrigatoriedade do campo
 * @return true se a validação não encontrou erros; false se algum erro foi
 *         encontrado.
 */
function validaHora(varField, strFieldName, blnRequired){

	var horarioCompleto = trim(varField.value)
	
	// verifica se o campo está vazio.
	if(horarioCompleto.length == 0){
		if(blnRequired){
			alert("O campo \"" + strFieldName + "\" é obrigatório!");
			varField.select();
			varField.focus();
			return false;
		}
	}else if(horarioCompleto.length == 8 || horarioCompleto.length == 5){
		var hora = horarioCompleto.substr(0,2);
		var minuto = horarioCompleto.substr(3,2);
		var segundo = "";
		if(horarioCompleto.length == 8){// valida a hora como HH:MM:SS
			segundo = horarioCompleto.substr(6,2);
		}

		if(!isNumber(hora) || !isNumber(minuto) || (segundo != "" && !isNumber(segundo))){
			alert("Formato do horário inválido no campo \"" + strFieldName + "\"!");
			varField.select();
			varField.focus();
			return false;
	  	}else if( hora < 0 || hora > 23 || minuto < 0 || minuto > 59 || (segundo != "" && (segundo < 0 || segundo > 59))){
			alert("Horário inválido no campo \"" + strFieldName + "\"!");
			varField.select();
			varField.focus();
			return false;
		}

	}else{// se o tamanho do horário não bater...
		alert("Formato do horário inválido no campo \"" + strFieldName + "\"!");
		varField.select();
		varField.focus();
		return false;
	}
	
	return true;
}

/**
 * @param sValor
 *            texto parâmetro
 * @return texto parâmetro sem espaços laterais
 */

function trim(sValor){
  var indexA = -1;
  var indexB;
  for(i = 0;  i < sValor.length;  i++){
	 if(sValor.charAt(i) != " " && sValor.charCodeAt(i) != 160){
		  indexA = i;
		  break;
	  }
  }
  if (indexA != -1){
	 for (j = sValor.length - 1; j >= indexA; j--){
		 if(sValor.charAt(j) != " " && sValor.charCodeAt(j) != 160){
		    indexB = j;
		    break;
	     }
	  }
	  sValor = sValor.substring(indexA,(indexB + 1));
  }else{
	  sValor = "";
  }
  
  return (sValor);	    
}


/**
 * Método que coloca o focu em um field HTML. Caso o field não permita receber o
 * focu, não faz nada.
 * 
 * @param varField
 *            objeto que receberá o focu.
 */
function setFocus(varField){
	try{
		varField.focus();
	}catch(err){
		// caso não seja possível por o focu em varField, não faz nada.
	}
}

/**
 * Método que seleciona o texto em um field HTML. Caso o field não permita
 * selecionar o texto, não faz nada.
 * 
 * @param varField
 *            objeto que terá o valor selecionado.
 */
function selectValue(varField){
	try{
		varField.select();
	}catch(err){
		// caso não seja possível selecionar o valor em varField, não faz nada.
	}
}


/**
 * Método que valida se o conteúdo de um objeto (objeto.value) é um texto válido
 * e bloqueia as aspas simples e duplas
 * 
 * @param varField -
 *            objeto que contém o texto a ser validado.
 * @param strFieldName -
 *            nome do objeto que será exibido nos alerts, em caso de conteúdo
 *            inválido.
 * @param blnRequired -
 *            boolean que determina a obrigatoriedade do campo.
 * @param maxlength -
 *            inteiro que determina qual o número máximo de caracteres do campo.
 * @return - true: texto válido; false: texto inválido.
 */
function validaTexto(varField, strFieldName, blnRequired, maxlength){
	varField.value = trim(varField.value);
	if(blnRequired && varField.value.length == 0){
		alert("O campo \"" + strFieldName + "\" é obrigatorio.");
		selectValue(varField);
		setFocus(varField);
		return false;
	}else if(maxlength != null && varField.value.length > maxlength){
		alert("O tamanho maximo do campo \"" + strFieldName + "\" é de " + maxlength + " caracteres (tamanho atual:" + trim(varField.value).length + ").");
		selectValue(varField);
		setFocus(varField);
		return false;
	}else if(varField.value.indexOf("&") != -1){
		alert("Nao é permitido o uso do caractere \"&\" no campo \"" + strFieldName + "\".");
		selectValue(varField);
		setFocus(varField);
		return false;
	}else if(varField.value.indexOf("\"") != -1){
		alert("Nao é permitido o uso de aspas no campo \"" + strFieldName + "\".");
		selectValue(varField);
		setFocus(varField);
		return false;
	}else if(varField.value.indexOf("'") != -1){
		alert("Nao é permitido o uso de aspas simples no campo \"" + strFieldName + "\".");
		selectValue(varField);
		setFocus(varField);
		return false;
	}else{
		return true;
	}
}

/**
 * Método que efetua a validação de campos texto, quando estes se encontram em
 * ABAs.
 * 
 * @param varField
 *            objeto que contém o texto a ser validado.
 * @param strFieldName
 *            nome do objeto que será exibido nos alerts, em caso de conteúdo
 *            inválido.
 * @param blnRequired
 *            boolean que determina a obrigatoriedade do campo.
 * @param maxlength
 *            inteiro que identifica o tamanho máximo da string contida em
 *            varField.
 * @param tabName
 *            nome da ABA onde se encontra o campo que está sendo validado.
 * 
 * @return true se a validação estiver ok; false se não.
 */
function validaTextoEmTab(varField, strFieldName, blnRequired, maxlength, tabName){
	return validaTexto(varField, strFieldName + "\" da ABA \"" + tabName, blnRequired, maxlength);
}

/**
 * Método que valida se o conteúdo de um objeto (objeto.value) é um texto válido
 * permitindo as aspas simples e duplas
 * 
 * @param varField
 *            objeto que contém o texto a ser validado
 * @param strFieldName
 *            nome do objeto que será exibido nos alerts, em caso de conteúdo
 *            inválido
 * @param blnRequired
 *            boolean que determina a obrigatoriedade do campo
 * @param maxlength
 *            inteiro que identifica o tamanho máximo da string contida em
 *            varField.
 * @return true: texto válido; false: texto inválido.
 */

function validaTextoPermitindoAspas(varField, strFieldName, blnRequired, maxlength){
	varField.value = trim(varField.value);
	if(blnRequired && varField.value.length == 0){
		alert("O campo \"" + strFieldName + "\" é obrigatorio.");
		selectValue(varField);
		setFocus(varField);
		return false;
	}else if(maxlength != null && varField.value.length > maxlength){
		alert("O tamanho maximo do campo \"" + strFieldName + "\" é de " + maxlength + " caracteres (tamanho atual:" + trim(varField.value).length + ").");
		selectValue(varField);
		setFocus(varField);
		return false;
	}else if(varField.value.indexOf("&") != -1){
		alert("Não é permitido o uso do caractere \"&\" no campo \"" + strFieldName + "\".");
		selectValue(varField);
		setFocus(varField);
		return false;
	}else{
		return true;
	}
}

/**
 * Método que efetua a validação de campos texto, quando estes se encontram em
 * ABAs. Mas, diferente do validaTexto, esta validação permite a inserção de
 * aspas simples e duplas.
 * 
 * @param varField
 *            objeto que contém o texto a ser validado.
 * @param strFieldName
 *            nome do objeto que será exibido nos alerts, em caso de conteúdo
 *            inválido.
 * @param blnRequired
 *            boolean que determina a obrigatoriedade do campo.
 * @param maxlength
 *            inteiro que identifica o tamanho máximo da string contida em
 *            varField.
 * @param tabName
 *            nome da ABA onde se encontra o campo que está sendo validado.
 * 
 * @return true se a validação estiver ok; false se não.
 */
function validaTextoPermitindoAspasEmTab(varField, strFieldName, blnRequired, maxlength, tabName){
	return validaTextoPermitindoAspas(varField, strFieldName + "\" da ABA \"" + tabName, blnRequired, maxlength);
}

/**
 * Método que valida combos
 * 
 * @param varField
 *            objeto que contém o texto a ser validado
 * @param strFieldName
 *            nome do objeto que será exibido nos alerts, em caso de conteúdo
 *            inválido
 * @param blnRequired
 *            boolean que determina a obrigatoriedade do campo
 * @return true: validação ok; false: validação não ok.
 */
    
function validaCombo(varField, strFieldName, blnRequired){
	if(blnRequired && (varField.value == "" || varField.value == null)){
		alert("O campo \"" + strFieldName + "\" é obrigatorio!");
		setFocus(varField);
		return false;
	}
	return true;
}

/**
 * Método que valida combos, quando estes se encontram em ABAs.
 * 
 * @param varField
 *            objeto que contém o texto a ser validado.
 * @param strFieldName
 *            nome do objeto que será exibido nos alerts, em caso de conteúdo
 *            inválido.
 * @param blnRequired
 *            boolean que determina a obrigatoriedade do campo.
 * @param tabName
 *            nome da ABA onde se encontra o campo que está sendo validado.
 * 
 * @return true se a validação estiver ok; false se não.
 */
function validaComboEmTab(varField, strFieldName, blnRequired, tabName){
	return validaCombo(varField, strFieldName + "\" da ABA \"" + tabName, blnRequired);
}


/*******************************************************************************
 * --------------------------
 * 
 * Novo método que valida se o conteúdo de um objeto (objeto.value) é uma DATA
 * VÁLIDA (o antigo método tinha uma falha que não validava o valor "1111111111"
 * no Firefox) os parâmetros são os mesmos do método antigo.
 * 
 * @param varField
 *            objeto que contém o texto a ser validado
 * @param strFieldName
 *            nome do objeto que será exibido nos alerts, em caso de conteúdo
 *            inválido
 * @param blnRequired
 *            boolean que determina a obrigatoriedade do campo
 * @return true: data válida; false: data inválida.
 * 
 * ---------------------------
 ******************************************************************************/

function validaData(varField, strFieldName, blnRequired){
	if(trim(varField.value).length == 0){
		if(blnRequired){
			alert("O campo \"" + strFieldName + "\" é obrigatório!");
			varField.select();
			varField.focus();
			return false;
		}else{
			return true;
		}
	}
	var validformat=/^\d{2}\/\d{2}\/\d{4}$/ 		// Verifica se o formato é
                                                    // dd/mm/aaaa
	if (!validformat.test(varField.value)){
		alert("O campo \"" + strFieldName + "\" deve estar no formato dd/mm/aaaa!");
		varField.select();
		varField.focus();
		return false;
	}else{ 										// Verifica se o valores de DIA,
                                                // MÊS e ANO são válidos.
		if (!Date.isValid(varField.value, 'dd/MM/yyyy')){
			alert("Data inválida no campo \"" + strFieldName + "\"!");
			varField.select();
			varField.focus();
			return false;
		}
	}
	return true;
}

/**
 * Método que valida se o conteúdo de um objeto (objeto.value) é uma data
 * válida, quando este se encontra em ABAs.
 * 
 * @param varField
 *            objeto que contém o texto a ser validado.
 * @param strFieldName
 *            nome do objeto que será exibido nos alerts, em caso de conteúdo
 *            inválido.
 * @param blnRequired
 *            boolean que determina a obrigatoriedade do campo.
 * @param tabName
 *            nome da ABA onde se encontra o campo que está sendo validado.
 * 
 * @return true se a validação estiver ok; false se não.
 */
function validaDataEmTab(varField, strFieldName, blnRequired, tabName){
	return validaData(varField, strFieldName + "\" da ABA \"" + tabName, blnRequired);
}

/**
 * Método que valida se o conteúdo de um objeto (objeto.value) é uma número de
 * telefone válido
 * 
 * @param varField
 *            objeto que contém o texto a ser validado
 * @param strFieldName
 *            nome do objeto que será exibido nos alerts, em caso de conteúdo
 *            inválido
 * @param blnRequired
 *            boolean que determina a obrigatoriedade do campo
 * @return true: data válida; false: data inválida.
 */
    
function validaNumeroTelefone(varField, strFieldName, blnRequired){
	var sTelefone = trim(varField.value);
	var nTelefone = "";
	for(var i=0; i<sTelefone.length; i++){
		if(sTelefone.charAt(i) != "-"){nTelefone += sTelefone.charAt(i);}
	}
	if(blnRequired && trim(varField.value).length == 0){
		alert("O campo \"" + strFieldName + "\" é obrigatorio!");
		selectValue(varField);
		setFocus(varField);
		return false;
	}else if(!isNumber(nTelefone)){
		alert("O campo \"" + strFieldName + "\" deve estar no formato \"0000-0000\"!");
		selectValue(varField);
		setFocus(varField);
		return false;
	}else if(sTelefone.length - nTelefone.length > 1){
		alert("Formato de telefone invalido no campo \"" + strFieldName + "\"!");
		selectValue(varField);
		setFocus(varField);
		return false;
	}
	return true;
} 

/**
 * Método que valida se o conteúdo de um objeto (objeto.value) é um DDD válido
 * 
 * @param varField
 *            objeto que contém o texto a ser validado
 * @param strFieldName
 *            nome do objeto que será exibido nos alerts, em caso de conteúdo
 *            inválido
 * @param blnRequired
 *            boolean que determina a obrigatoriedade do campo
 * @return true: data válida; false: data inválida.
 */
    
function validaDDD(varField, strFieldName, blnRequired){
	var sDDD = trim(varField.value);
	if(blnRequired && sDDD.length == 0){
		alert("O campo \"" + strFieldName + "\" é obrigatorio!");
		selectValue(varField);
		setFocus(varField);
		return false;
	}else if(blnRequired && !isNumber(sDDD)){
		alert("O campo \"" + strFieldName + "\" deve conter apenas números e estar no formato \"##\" ou \"#####\"!");
		selectValue(varField);
		setFocus(varField);
		return false;
	}else if(blnRequired && (sDDD.length != 2 && sDDD.length != 5)){
		alert("O campo \"" + strFieldName + "\" deve conter apenas números e estar no formato \"##\" ou \"#####\"!");
		selectValue(varField);
		setFocus(varField);
		return false;
	}
	return true;
}

function toDate(datastring){
	var data = null;
	if(datastring != null && datastring.length != 0){
		var dia = datastring.substr(0,2);
		var mes = datastring.substr(3,2);
		var ano = datastring.substr(6,4);
		data = new Date(ano, mes-1, dia);
	}
	return data;
}

/**
 * Método que valida se a data de um campo respeita seu limite.
 * 
 * @param varFieldDe
 *            objeto que contém a data inicial
 * @param varFieldAte
 *            objeto que contém a data final
 * @return true: datas válidas; false: datas inválidas.
 */
    
function validaDataLimite(varFieldData, sNomeCampo, varDataLimite, blnAPartirDe){
	var sData = trim(varFieldData.value);
	var dia = sData.substr(0,2);
	var mes = sData.substr(3,2);
	var ano = sData.substr(6,4);
	var dData = new Date(ano, mes-1, dia);
	var sDataLim = varDataLimite;
	var dial = sDataLim.substr(0,2);
	var mesl = sDataLim.substr(3,2);
	var anol = sDataLim.substr(6,4);
	var dDataLim = new Date(anol, mesl-1, dial);
	if(blnAPartirDe && dData.getTime() < dDataLim.getTime() || !blnAPartirDe && dData.getTime() > dDataLim.getTime()){
		alert("O campo \"" + sNomeCampo + "\" precisa ser " + ((blnAPartirDe)?"posterior":"anterior") + " ou igual a \"" + varDataLimite + "\".");
		varFieldData.value = varDataLimite;
		selectValue(varFieldData);
		setFocus(varFieldData);
		return false;
	}
	return true;
} 

/**
 * Método que valida se o duas datas podem ser utilizadas como inicio e fim
 * 
 * @param varFieldDe
 *            objeto que contém a data inicial
 * @param varFieldAte
 *            objeto que contém a data final
 * @return true: datas válidas; false: datas inválidas.
 */
    
function validaDataDeAte(varFieldDe, varFieldAte){
	if(varFieldDe.value.length != 0 && varFieldAte.value.length != 0){
		var sDataDe = trim(varFieldDe.value);
		var diade = sDataDe.substr(0,2);
		var mesde = sDataDe.substr(3,2);
		var anode = sDataDe.substr(6,4);
		var dDataDe = new Date(anode, mesde-1, diade);
		var sDataAte = trim(varFieldAte.value);
		var diaate = sDataAte.substr(0,2);
		var mesate = sDataAte.substr(3,2);
		var anoate = sDataAte.substr(6,4);
		var dDataAte = new Date(anoate, mesate-1, diaate);
		if(dDataDe > dDataAte){
			alert("A data inicial precisa ser menor ou igual a data final.");
			selectValue(varFieldDe);
			setFocus(varFieldDe);
			return false;
		}
	}
	return true;
}


/**
 * Método que valida se o conteúdo de um objeto (objeto.value) está no formato
 * numérico.
 * 
 * @param varField
 *            objeto que contém o texto a ser validado.
 * @param strFieldName
 *            nome do objeto que será exibido nos alerts, em caso de conteúdo
 *            inválido.
 * @param blnRequired
 *            boolean que determina a obrigatoriedade do campo.
 * @param alllowNegative
 *            TRUE para que a validação aceite números negativos, FALSE para que
 *            não aceite.
 * 
 * @return true se a validação estiver ok; false se não.
 */
function validaNumero(varField, strFieldName, blnRequired, alllowNegative){
	// Caso o número seja decimal (com vírgula),
	// corrige o valor do campo removendo a vírgula e todos os algarismos após a
    // mesma.
	if(trim(varField.value).length != 0){
		if(varField.value.indexOf(",") != -1){
			varField.value = varField.value.substr(0,varField.value.indexOf(","));
		}
	}
	
	var numero = varField.value;
	
	// valida se o número é negativo.
	if(varField.value.indexOf("-")==0){
		if(alllowNegative){
			numero = varField.value.substr(1,varField.value.length-1);
		}else{
			alert("O campo \"" + strFieldName + "\" deve ser maior ou igual a zero.");
			selectValue(varField);
			setFocus(varField);
			return false;
		}
	}else if(blnRequired && trim(numero).length == 0){
		alert("O campo \"" + strFieldName + "\" é obrigatório.");
		selectValue(varField);
		setFocus(varField);
		return false;
	}else if (!isNumber(numero.replace(/\./g, ""))){
		alert("O campo \"" + strFieldName + "\" deve conter somente números.");
		selectValue(varField);
		setFocus(varField);
		return false;
	}
	
	return true;
}

/**
 * Método que valida se o conteúdo de um objeto (objeto.value) está no formato
 * numérico, quando este se encontra em ABAs.
 * 
 * @param varField
 *            objeto que contém o texto a ser validado.
 * @param strFieldName
 *            nome do objeto que será exibido nos alerts, em caso de conteúdo
 *            inválido.
 * @param blnRequired
 *            boolean que determina a obrigatoriedade do campo.
 * @param tabName
 *            nome da ABA onde se encontra o campo que está sendo validado.
 * @param alllowNegative
 *            TRUE para que a validação aceite números negativos, FALSE para que
 *            não aceite.
 * 
 * @return true se a validação estiver ok; false se não.
 */
function validaNumeroEmTab(varField, strFieldName, blnRequired, tabName, alllowNegative){
	return validaNumero(varField, strFieldName + "\" da ABA \"" + tabName, blnRequired, alllowNegative);
}


/**
 * Método que valida se o conteúdo de um objeto (objeto.value) está no formato
 * de número decimal.
 * 
 * @param -
 *            varField objeto que contém o texto a ser validado
 * @param -
 *            strFieldName nome do objeto que será exibido nos alerts, em caso
 *            de conteúdo inválido
 * @param blnRequired -
 *            boolean que determina a obrigatoriedade do campo
 * @param decimalAlgarisms -
 *            número de casas decimais após a vírgula.
 * @param alllowNegative
 *            TRUE para que a validação aceite números negativos, FALSE para que
 *            não aceite.
 * 
 * @return - true: número válido; false: número inválido.
 */

function validaDecimal(varField, strFieldName, blnRequired, decimalAlgarisms, alllowNegative){
	var numero = varField.value;
	
	// remove os pontos e substitui a vírgula.
	for(var i=0; i < numero.length; i++){
		if(numero.charAt(i) == "." || numero.charAt(i) == ","){
			numero = numero.substring(0, i) + numero.substring(i+1, numero.length);
		}
	}
	
	// valida se o número é negativo.
	if(varField.value.indexOf("-")==0){
		if(alllowNegative){
			numero = numero.substr(1,varField.value.length-1);
		}else{
			alert("O campo \"" + strFieldName + "\" deve ser maior ou igual a zero.");
			selectValue(varField);
			setFocus(varField);
			return false;
		}
	}else if(blnRequired && trim(numero).length == 0){
		alert("O campo \"" + strFieldName + "\" é obrigatorio.");
		selectValue(varField);
		setFocus(varField);
		return false;
	}else if (varField.value.indexOf(",") != varField.value.lastIndexOf(",")){
		alert("O campo \"" + strFieldName + "\" não pode conter mais que uma virgula.");
		selectValue(varField);
		setFocus(varField);
		return false;
	}else if (!isNumber(numero)){
		alert("O campo \"" + strFieldName + "\" deve conter somente números.");
		selectValue(varField);
		setFocus(varField);
		return false;
	}
	
	// Caso o número de casas decimais seja diferente do aceito pela validação,
	// corrige o valor do campo.
	if(trim(varField.value).length != 0){
		
		if(varField.value.lastIndexOf(",") == -1){
			varField.value += ",";
		}
		
		// Se o número de algarismos após a vírgula for maior do que o número de
        // algarismos da validação, trunca o valor.
		if(varField.value.substring(varField.value.lastIndexOf(","),varField.value.length-1).length > decimalAlgarisms){
			varField.value = varField.value.substring(0, varField.value.lastIndexOf(",") + decimalAlgarisms + 1)
		
		// Se o número de algarismos após a vírgula for menor do que o número de
        // algarismos da validação, adiciona zeros nas casas decimais.
		}else{ 
			while(varField.value.substring(varField.value.lastIndexOf(","),varField.value.length-1).length < decimalAlgarisms){
				varField.value = varField.value + "0";
			}
		}
	}
	return true;
}

/**
 * Método que valida se o conteúdo de um objeto (objeto.value) está no formato
 * decimal, quando este se encontra em ABAs.
 * 
 * @param varField
 *            objeto que contém o texto a ser validado.
 * @param strFieldName
 *            nome do objeto que será exibido nos alerts, em caso de conteúdo
 *            inválido.
 * @param blnRequired
 *            boolean que determina a obrigatoriedade do campo.
 * @param tabName
 *            nome da ABA onde se encontra o campo que está sendo validado.
 * @param decimalAlgarisms -
 *            número de casas decimais após a vírgula.
 * @param alllowNegative
 *            TRUE para que a validação aceite números negativos, FALSE para que
 *            não aceite.
 * 
 * @return - true: número válido; false: número inválido.
 */
function validaDecimalEmTab(varField, strFieldName, blnRequired, tabName, decimalAlgarisms, alllowNegative){
	return validaDecimal(varField, strFieldName + "\" da ABA \"" + tabName, blnRequired, decimalAlgarisms, alllowNegative);
}

/**
 * Método que valida se o conteúdo de um objeto (objeto.value) está no formato
 * money
 * 
 * @param varField
 *            objeto que contém o texto a ser validado
 * @param strFieldName
 *            nome do objeto que será exibido nos alerts, em caso de conteúdo
 *            inválido
 * @param blnRequired
 *            boolean que determina a obrigatoriedade do campo
 * @param alllowNegative
 *            TRUE para que a validação aceite números negativos, FALSE para que
 *            não aceite.
 * 
 * @return true: número válido; false: número inválido.
 */

function validaMoney(varField, strFieldName, blnRequired, alllowNegative){
	return validaDecimal(varField, strFieldName, blnRequired, 2, alllowNegative);
}

/**
 * Método que valida se o conteúdo de um objeto (objeto.value) está no formato
 * de moeda, quando este se encontra em ABAs.
 * 
 * @param varField
 *            objeto que contém o texto a ser validado.
 * @param strFieldName
 *            nome do objeto que será exibido nos alerts, em caso de conteúdo
 *            inválido.
 * @param blnRequired
 *            boolean que determina a obrigatoriedade do campo.
 * @param tabName
 *            nome da ABA onde se encontra o campo que está sendo validado.
 * @param alllowNegative
 *            TRUE para que a validação aceite números negativos, FALSE para que
 *            não aceite.
 * 
 * @return true se a validação estiver ok; false se não.
 */
function validaMoneyEmTab(varField, strFieldName, blnRequired, tabName, alllowNegative){
	return validaMoney(varField, strFieldName + "\" da ABA \"" + tabName, blnRequired, alllowNegative);
}

/**
 * Método que valida se o conteúdo de um objeto (objeto.value) é um e-mail
 * válido
 * 
 * @param varField
 *            objeto que contém o texto a ser validado
 * @param strFieldName
 *            nome do objeto que será exibido nos alerts, em caso de conteúdo
 *            inválido
 * @param blnRequired
 *            boolean que determina a obrigatoriedade do campo
 * @param maxLength
 *            Numero máximo de caracteres do campo.
 * @return true: número válido; false: número inválido.
 */

function validaEmail(varField, strFieldName, blnRequired, maxLength){
	var valchars = "_-@.";
	var email = trim(varField.value);
	if(!validaTexto(varField, strFieldName, blnRequired, maxLength)){
		return false;
	}else{
		if(varField.value != "" && varField.value != null && getFirstSpecialChar(email, valchars) != ""){
			alert(strFieldName +": O caractere especial \"" + getFirstSpecialChar(email, valchars) + "\" não é válido para emails.");
			selectValue(varField);
			setFocus(varField);
			return false;
		}else if(varField.value != "" && varField.value != null && email.indexOf("@") == -1){
			alert(strFieldName +": Um email válido precisa conter um caractere \"@\".");
			selectValue(varField);
			setFocus(varField);
			return false;
		}else if(varField.value != "" && varField.value != null && email.indexOf("@") != email.lastIndexOf("@")){
			alert(strFieldName +": Endereços de email não podem conter mais que um caractere \"@\".");
			selectValue(varField);
			setFocus(varField);
			return false;
		}else if(varField.value != "" && varField.value != null && email.indexOf("@") == 0){
			alert(strFieldName +": Endereços de email precisam conter uma conta antes do caractere \"@\".");
			selectValue(varField);
			setFocus(varField);
			return false;
		}else if(varField.value != "" && varField.value != null && email.indexOf("@") == email.length-1){
			alert(strFieldName +": Endereços de email precisam conter um dominio após o caractere \"@\".");
			selectValue(varField);
			setFocus(varField);
			return false;
		}
	}
	return true;
}

function validaEmailEmTab(varField, strFieldName, blnRequired, TabName){
	var valchars = "_-@.";
	var email = trim(varField.value);
	if(!validaTexto(varField, strFieldName, blnRequired)){
		return false;
	}else{
		if(varField.value != "" && varField.value != null && getFirstSpecialChar(email, valchars) != ""){
			alert("O caractere especial \"" + getFirstSpecialChar(email, valchars) + "\" não é válido para e-mails.");
			return false;
		}else if(varField.value != "" && varField.value != null && email.indexOf("@") == -1){
			alert("Um e-mail válido precisa conter um caractere \"@\".");
			return false;
		}else if(varField.value != "" && varField.value != null && email.indexOf("@") != email.lastIndexOf("@")){
			alert("Endereços de e-mail não podem conter mais que um caractere \"@\".");
			return false;
		}else if(varField.value != "" && varField.value != null && email.indexOf("@") == 0){
			alert("Endereços de e-mail precisam conter uma conta antes do caractere \"@\".");
			return false;
		}else if(varField.value != "" && varField.value != null && email.indexOf("@") == email.length-1){
			alert("Endereços de e-mail precisam conter um domínio após o caractere \"@\".");
			return false;
		}
	}
	return true;
}

function getFirstSpecialChar(string, acceptable){
	var checkOK = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789" + acceptable;
	for(i = 0;  i < string.length;  i++){
		for (j = 0;  j < checkOK.length;  j++){
			if (string.charAt(i) == checkOK.charAt(j)){
				break;
			}
		}
		if (j == checkOK.length){
			return string.charAt(i);
		}
	}
	return "";
}


/**
 * Método que valida se o valor passado como parâmetro é um número válido
 * 
 * @param number
 *            valor a ser validado
 * @return true: número válido; false: número inválido.
 */

function isNumber(number){
	var checkOK = "0123456789";
	var ch;
	var allValid = true;
	var allNum = "";
	for (i = 0;  i < number.length;  i++){
		ch = number.charAt(i);
		for (j = 0;  j < checkOK.length;  j++){
			if (ch == checkOK.charAt(j)){
				break;
			}
		}
		if (j == checkOK.length){
			allValid = false;
			break;
		}
		allNum += ch;
	}
	return allValid;
}



/**
 * Método impede a inserção de caracteres inválidos para o formato de dados
 * "Time".
 * 
 * @param varField
 *            objeto que contém o texto a ser validado.
 * @param triggeredEvent
 *            Evento acionado na chamada deste método. Não utilizado pelo
 *            Internet Explorer.
 * @return false se o caractere for inválido, true caso contrario.
 */
function timeMask(varField, triggeredEvent, showSeconds){
	var char;
	var keyNum;
	
	if(window.event){ // Internet Explorer
		keyNum = window.event.keyCode;
		
	}else if(triggeredEvent.which){ // Netscape/Firefox/Opera
		keyNum = triggeredEvent.which;
	}
	
	char = String.fromCharCode(keyNum);
	
	if(keyNum == 13 || keyNum == 8 || keyNum == undefined){// ENTER, BACKSPACE
                                                            // e outras teclas
                                                            // são permitidas.
		return true;
	}else if(!isNumber(char)){// caracteres não numéricos não são permitidos.
		return false;
	}else if(varField.value.length == 2 || (varField.value.length == 5 && showSeconds)){// adiciona
                                                                                        // separadores.
		varField.value += ":";
		return true;
	}else{// caracteres numéricos são permitidos.
		return true;
	}
}

/**
 * Método impede a inserção de caracteres inválidos para o formato de dados
 * "Date".
 * 
 * @param varField
 *            objeto que contém o texto a ser validado.
 * @param triggeredEvent
 *            Evento acionado na chamada deste método. Não utilizado pelo
 *            Internet Explorer.
 * @return false se o caractere for inválido, true caso contrario.
 */
function dateMask(varField, triggeredEvent){
	var char;
	var keyNum;
	
	if(window.event){ // Internet Explorer
		keyNum = window.event.keyCode;
		
	}else if(triggeredEvent.which){ // Netscape/Firefox/Opera
		keyNum = triggeredEvent.which;
	}
	
	char = String.fromCharCode(keyNum);
	
	if(keyNum == 13 || keyNum == 8 || keyNum == undefined){// ENTER, BACKSPACE
                                                            // e outras teclas
                                                            // são permitidas.
		return true;
	}else if(!isNumber(char)){// caracteres não numéricos não são permitidos.
		return false;
	}else if(varField.value.length == 2 || varField.value.length == 5){// adiciona
                                                                        // separadores.
		varField.value += "/";
		return true;
	}else{// caracteres numéricos são permitidos.
		return true;
	}
}

/**
 * Método impede a inserção de caracteres inválidos para o formato de dados
 * "Integer".
 * 
 * @param varField
 *            objeto que contém o texto a ser validado.
 * @param triggeredEvent
 *            Evento acionado na chamada deste método. Não utilizado pelo
 *            Internet Explorer.
 * @param allowNegative
 *            Boolean que undica se a mascara permitirá ou não a insersão do
 *            sinal "-".
 * @return false se o caractere for inválido, true caso contrario.
 */
function integerMask(varField, triggeredEvent, allowNegative){
	var char;
	var keyNum;
	
	if(window.event){ // Internet Explorer
		keyNum = window.event.keyCode;
		
	}else if(triggeredEvent.which){ // Netscape/Firefox/Opera
		keyNum = triggeredEvent.which;
	}
	
	char = String.fromCharCode(keyNum);
	
	if(keyNum == 13 || keyNum == 8 || keyNum == undefined){// ENTER, BACKSPACE
                                                            // e outras teclas
                                                            // são permitidas.
		return true;
	}else if(allowNegative && char == "-"){// "-" é permitido caso a mascara
                                            // permita números negativos.
		return true;
	}else if(!isNumber(char)){// caracteres não numéricos não são permitidos.
		return false;
	}else{// caracteres numéricos são permitidos.
		return true;
	}
}

/**
 * Método impede a inserção de caracteres inválidos para o formato de dados de
 * moeda.
 * 
 * @param varField
 *            objeto que contém o texto a ser validado.
 * @param triggeredEvent
 *            Evento acionado na chamada deste método. Não utilizado pelo
 *            Internet Explorer.
 * @param allowNegative
 *            Boolean que indica se a mascara permitirá ou não a insersão do
 *            sinal "-".
 * @return false se o caractere for inválido, true caso contrario.
 */
function moneyMask(varField, triggeredEvent, allowNegative){
	return decimalMask(varField, triggeredEvent, allowNegative);
}

/**
 * Método impede a inserção de caracteres inválidos para o formato de dados
 * decimais.
 * 
 * @param varField
 *            objeto que contém o texto a ser validado.
 * @param triggeredEvent
 *            Evento acionado na chamada deste método. Não utilizado pelo
 *            Internet Explorer.
 * @param allowNegative
 *            Boolean que indica se a mascara permitirá ou não a insersão do
 *            sinal "-".
 * @return false se o caractere for inválido, true caso contrario.
 */
function decimalMask(varField, triggeredEvent, allowNegative){
	var char;
	var keyNum;
	
	if(window.event){ // Internet Explorer
		keyNum = window.event.keyCode;
		
	}else if(triggeredEvent.which){ // Netscape/Firefox/Opera
		keyNum = triggeredEvent.which;
	}
	
	char = String.fromCharCode(keyNum);
	
	if(keyNum == 13 || keyNum == 8 || keyNum == undefined){// ENTER, BACKSPACE
                                                            // e outras teclas
                                                            // são permitidas.
		return true;
	}else if(allowNegative && char == "-"){// "-" é permitido caso a mascara
                                            // permita números negativos.
		return true;
	}else if( (keyNum == 44 && varField.value.indexOf(",") == -1) || keyNum == 46 ){// uma
                                                                                    // vírgulas
                                                                                    // e
                                                                                    // pontos
                                                                                    // são
                                                                                    // permitidos.
		return ;
	}else if(!isNumber(char)){// caracteres não numéricos não são permitidos.
		return false;
	}else{// caracteres numéricos são permitidos.
		return true;
	}
}



function getSelectedText(){
	return document.selection.createRange().text;
} 
function isChar(ascii){

	if((ascii>=32 && ascii<=47) || (ascii>=58 && ascii<=126)){
		return true;
	}else{
		return false;
	}
}

function toNumber(text){
	if(text == ""){
		return 0;
	}else{
		while(text.indexOf(".") != -1){
			text = text.substring(0, text.indexOf(".")) + text.substring(text.indexOf(".")+1, text.length);
		}
		if(text.indexOf(",") != -1){
			text = text.substring(0, text.indexOf(",")) + "." + text.substring(text.indexOf(",")+1, text.length);
		}
		return text*1;
	}
}
/*
 * '[================================================================================================
 * '[= Nome : verificaCpfCnpj '[= Descrição : valida um CPF ou CNPJ de um campo
 * ou string. '[= Entrada : str - objeto CPF ou CNPJ '[= Saida : true - se o CPF
 * ou CNPJ for válido '[= false - caso contrário '[= Exemplo :
 * if(fgVerificaCpfCnpj(text3)) '[= OBS :
 * '[================================================================================================
 */
function verificaCpfCnpj(str, strFieldName, blnRequired){
	if(!validaTexto(str, strFieldName, blnRequired)){
		return false;
	}else{
		/*
         * * Compara o tamanho para saber o tipo...
         */
		switch (str.value.length) {
			case 0: {// se for vazio, retorna true
				return true;
			}
			case 11: {
				if (!checkCPF(str.value))
				{
					alert("CPF: "+ str.value + "\n\rCPF Inválido. Favor digitá-lo corretamente.");
					setFocus(str);
					return false; 
				}
				return true;
			}
			case 14: { 
				if (!checkCNPJ(str.value))
				{
					alert("CNPJ: "+ str.value + " Inválido. Favor digitá-lo corretamente.");
					setFocus(str);
					return false; 
				}
				return true;
			}
			// Quando o CNPJ tiver 15 caracteres a validação de desconsiderar o
            // primeiro caractere (que é zero).
			// Se o primeiro caractere não for zero significa que o usuário
            // digitou o CNPJ com um caractere a mais e
			// a validação deverá indicar o erro ao usuário.
			case 15: {
				if (!checkCNPJ(str.value.substring(1,15)) && str.value.substring(0,1))
				{
					alert("CNPJ: "+ str.value + " Inválido. Favor digitá-lo corretamente.");
					setFocus(str);
					return false; 
				}
				return true;
			}
			default: {
					alert("CNPJ/CPF: "+ str.value + " Inválido. Favor digitá-lo corretamente.");
					setFocus(str);
				return false;
			}
		}
	}
}
/*
 * '[================================================================================================
 * '[= Nome : checkCNPJ '[= Descrição : Efetua a validação de CNPJ '[= Entrada :
 * CNPJ - CNPJ a ser validado '[= Saida : true - se o CNPJ for válido '[= false -
 * caso contrário '[= OBS :
 * '[================================================================================================
 */
function checkCNPJ(psCNPJ) 
{
	var liPeso = 2;
	var liSoma = 0;
	var lsAux  = '';
	var liTemp = 0;
	var liDigito = 0;
	var lsCNPJ = '';
	
	/*
     * * Verifica se recebeu um objeto
     */
	if (psCNPJ == '[object]'){lsCNPJ = psCNPJ.value
} else {lsCNPJ = psCNPJ;}
	
	var liPos  = 0;

	/*
     * * Remove qualquer caracter que não seja número
     */
	for (liPos = lsCNPJ.length - 1; liPos >= 0; liPos--) {
        if (!isNaN(lsCNPJ.charAt(liPos))){lsAux = lsCNPJ.charAt(liPos) + lsAux;}
    }
			
	/*
     * * Cálculo do 1º dígito
     */
	for (liPos = lsAux.length - 3; liPos >= 0; liPos--)
	{
		liSoma += parseInt(lsCNPJ.charAt(liPos)) * liPeso;
		liPeso  = fgIIf((liPeso == 9), 2, liPeso + 1);
	}
	
	liTemp   = (liSoma % 11);
	liDigito = fgIIf((liTemp < 2), 0, (11 - liTemp));
	
	/*
     * * Compara o 1º dígito
     */
	if (parseInt(lsCNPJ.charAt(lsCNPJ.length - 2)) != liDigito) {
        return (false);
    }
	
	/*
     * * Limpa as Variáveis
     */
	liPeso = 2;
	liSoma = 0;

	/*
     * * Cálculo do 2º dígito
     */
	for (liPos = lsAux.length - 2; liPos >= 0; liPos--)
	{
		liSoma += parseInt(lsCNPJ.charAt(liPos)) * liPeso;
		liPeso  = fgIIf((liPeso == 9), 2, liPeso + 1);
	}
	
	liTemp   = (liSoma % 11);
	liDigito = fgIIf((liTemp < 2), 0, (11 - liTemp));
	
	/*
     * * Compara o 2º dígito
     */
	if (parseInt(lsCNPJ.charAt(lsCNPJ.length - 1)) != liDigito) {
        return (false);
    }
	
	return (true);
}

/*
 * '[================================================================================================
 * '[= Nome : fgCheckCPF '[= Descrição : Efetua a validação de CPF '[= Entrada :
 * cpf - CPF a ser validado '[= Saida : true - se o CPF for válido '[= false -
 * caso contrário '[= OBS :
 * '[================================================================================================
 */
function  checkCPF(psCPF) 
{
	var lsAux    = '';
	var lsCPF    = '';
	var liPeso   = 2;
	var liSoma   = 0;
	var liTemp   = 0;
	var liDigito = 0;
	

	/*
     * * Verifica se recebeu um objeto
     */
	if (psCPF == '[object]'){lsCPF = psCPF.value
} else {lsCPF = psCPF;}
	
	var liPos  = 0;

	/*
     * * Remove qualquer caracter que não seja número
     */
	for (liPos = lsCPF.length - 1; liPos >= 0; liPos--) {
        if (!isNaN(lsCPF.charAt(liPos))){lsAux = lsCPF.charAt(liPos) + lsAux;}
    }
			
	/*
     * * Cálculo do 1º dígito
     */
	for (liPos = lsAux.length - 3; liPos >= 0; liPos--)
	{
		liSoma += parseInt(lsCPF.charAt(liPos)) * liPeso;
		liPeso++;
	}
	
	liTemp   = (liSoma % 11);
	liDigito = fgIIf((liTemp < 2), 0, (11 - liTemp));
	
	/*
     * * Compara o 1º dígito
     */
	if (parseInt(lsCPF.charAt(lsCPF.length - 2)) != liDigito) {
        return (false);
    }
	
	/*
     * * Limpa as Variáveis
     */
	liPeso = 2;
	liSoma = 0;

	/*
     * * Cálculo do 2º dígito
     */
	for (liPos = lsAux.length - 2; liPos >= 0; liPos--)
	{
		liSoma += parseInt(lsCPF.charAt(liPos)) * liPeso;
		liPeso++;
	}
	
	liTemp   = (liSoma % 11);
	liDigito = fgIIf((liTemp < 2), 0, (11 - liTemp));
	
	/*
     * * Compara o 2º dígito
     */
	if (parseInt(lsCPF.charAt(lsCPF.length - 1)) != liDigito) {
        return (false);
    }
	
	return (true);
}

/*
 * '[======================================================================================
 * '[= Nome : fgIIf '[= Descrição : Caso a condição seja verdadeira assume o
 * primeiro valor, senão o segundo. '[= Entrada : pbCond - Condição a ser
 * avaliada '[= pvValueTrue - Valor caso pbCond for verdadeiro '[= pvValueFalse -
 * Valor caso contrário '[= Saida : pvValueTrue ou pvValueFalse '[= Exemplo :
 * text4.value = fgIIf(text3.value == 'Teste', 'fgIIf true', 'fgIIf false') '[=
 * OBS :
 * '[======================================================================================
 */
function fgIIf(pbCond, pvValueTrue, pvValueFalse){
	if (pbCond) {
        return (pvValueTrue)

    } else {
        return (pvValueFalse);
    }
}

/**
 * Copyright (c)2005-2009 Matt Kruse (javascripttoolbox.com)
 * 
 * Dual licensed under the MIT and GPL licenses. This basically means you can
 * use this code however you want for free, but don't claim to have written it
 * yourself! Donations always accepted: http://www.JavascriptToolbox.com/donate/
 * 
 * Please do not link to the .js files on javascripttoolbox.com from your site.
 * Copy the files locally to your server instead.
 * 
 */
/*
 * Date functions
 * 
 * These functions are used to parse, format, and manipulate Date objects. See
 * documentation and examples at http://www.JavascriptToolbox.com/lib/date/
 * 
 */
Date.$VERSION = 1.02;

// Utility function to append a 0 to single-digit numbers
Date.LZ = function(x) {return(x<0||x>9?"":"0")+x};
// Full month names. Change this for local month names
Date.monthNames = new Array('January','February','March','April','May','June','July','August','September','October','November','December');
// Month abbreviations. Change this for local month names
Date.monthAbbreviations = new Array('Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec');
// Full day names. Change this for local month names
Date.dayNames = new Array('Sunday','Monday','Tuesday','Wednesday','Thursday','Friday','Saturday');
// Day abbreviations. Change this for local month names
Date.dayAbbreviations = new Array('Sun','Mon','Tue','Wed','Thu','Fri','Sat');
// Used for parsing ambiguous dates like 1/2/2000 - default to preferring
// 'American' format meaning Jan 2.
// Set to false to prefer 'European' format meaning Feb 1
Date.preferAmericanFormat = true;

// If the getFullYear() method is not defined, create it
if (!Date.prototype.getFullYear) { 
  Date.prototype.getFullYear = function() { var yy=this.getYear(); return (yy<1900?yy+1900:yy); } ;
} 

// Parse a string and convert it to a Date object.
// If no format is passed, try a list of common formats.
// If string cannot be parsed, return null.
// Avoids regular expressions to be more portable.
Date.parseString = function(val, format) {
  // If no format is specified, try a few common formats
  if (typeof(format)=="undefined" || format==null || format=="") {
    var generalFormats=new Array('y-M-d','MMM d, y','MMM d,y','y-MMM-d','d-MMM-y','MMM d','MMM-d','d-MMM');
    var monthFirst=new Array('M/d/y','M-d-y','M.d.y','M/d','M-d');
    var dateFirst =new Array('d/M/y','d-M-y','d.M.y','d/M','d-M');
    var checkList=new Array(generalFormats,Date.preferAmericanFormat?monthFirst:dateFirst,Date.preferAmericanFormat?dateFirst:monthFirst);
    for (var i=0; i<checkList.length; i++) {
      var l=checkList[i];
      for (var j=0; j<l.length; j++) {
        var d=Date.parseString(val,l[j]);
        if (d!=null) { 
          return d; 
        }
      }
    }
    return null;
  };

  this.isInteger = function(val) {
    for (var i=0; i < val.length; i++) {
      if ("1234567890".indexOf(val.charAt(i))==-1) { 
        return false; 
      }
    }
    return true;
  };
  this.getInt = function(str,i,minlength,maxlength) {
    for (var x=maxlength; x>=minlength; x--) {
      var token=str.substring(i,i+x);
      if (token.length < minlength) { 
        return null; 
      }
      if (this.isInteger(token)) { 
        return token; 
      }
    }
  return null;
  };
  val=val+"";
  format=format+"";
  var i_val=0;
  var i_format=0;
  var c="";
  var token="";
  var x,y;
  var year=new Date().getFullYear();
  var month=1;
  var date=1;
  var hh=0;
  var mm=0;
  var ss=0;
  var ampm="";
  while (i_format < format.length) {
    // Get next token from format string
    c=format.charAt(i_format);
    token="";
    while ((format.charAt(i_format)==c) && (i_format < format.length)) {
      token += format.charAt(i_format++);
    }
    // Extract contents of value based on format token
    if (token=="yyyy" || token=="yy" || token=="y") {
      if (token=="yyyy") { 
        x=4;y=4; 
      }
      if (token=="yy") { 
        x=2;y=2; 
      }
      if (token=="y") { 
        x=2;y=4; 
      }
      year=this.getInt(val,i_val,x,y);
      if (year==null) { 
        return null; 
      }
      i_val += year.length;
      if (year.length==2) {
        if (year > 70) { 
          year=1900+(year-0); 
        }
        else { 
          year=2000+(year-0); 
        }
      }
    }
    else if (token=="MMM" || token=="NNN"){
      month=0;
      var names = (token=="MMM"?(Date.monthNames.concat(Date.monthAbbreviations)):Date.monthAbbreviations);
      for (var i=0; i<names.length; i++) {
        var month_name=names[i];
        if (val.substring(i_val,i_val+month_name.length).toLowerCase()==month_name.toLowerCase()) {
          month=(i%12)+1;
          i_val += month_name.length;
          break;
        }
      }
      if ((month < 1)||(month>12)){
        return null;
      }
    }
    else if (token=="EE"||token=="E"){
      var names = (token=="EE"?Date.dayNames:Date.dayAbbreviations);
      for (var i=0; i<names.length; i++) {
        var day_name=names[i];
        if (val.substring(i_val,i_val+day_name.length).toLowerCase()==day_name.toLowerCase()) {
          i_val += day_name.length;
          break;
        }
      }
    }
    else if (token=="MM"||token=="M") {
      month=this.getInt(val,i_val,token.length,2);
      if(month==null||(month<1)||(month>12)){
        return null;
      }
      i_val+=month.length;
    }
    else if (token=="dd"||token=="d") {
      date=this.getInt(val,i_val,token.length,2);
      if(date==null||(date<1)||(date>31)){
        return null;
      }
      i_val+=date.length;
    }
    else if (token=="hh"||token=="h") {
      hh=this.getInt(val,i_val,token.length,2);
      if(hh==null||(hh<1)||(hh>12)){
        return null;
      }
      i_val+=hh.length;
    }
    else if (token=="HH"||token=="H") {
      hh=this.getInt(val,i_val,token.length,2);
      if(hh==null||(hh<0)||(hh>23)){
        return null;
      }
      i_val+=hh.length;
    }
    else if (token=="KK"||token=="K") {
      hh=this.getInt(val,i_val,token.length,2);
      if(hh==null||(hh<0)||(hh>11)){
        return null;
      }
      i_val+=hh.length;
      hh++;
    }
    else if (token=="kk"||token=="k") {
      hh=this.getInt(val,i_val,token.length,2);
      if(hh==null||(hh<1)||(hh>24)){
        return null;
      }
      i_val+=hh.length;
      hh--;
    }
    else if (token=="mm"||token=="m") {
      mm=this.getInt(val,i_val,token.length,2);
      if(mm==null||(mm<0)||(mm>59)){
        return null;
      }
      i_val+=mm.length;
    }
    else if (token=="ss"||token=="s") {
      ss=this.getInt(val,i_val,token.length,2);
      if(ss==null||(ss<0)||(ss>59)){
        return null;
      }
      i_val+=ss.length;
    }
    else if (token=="a") {
      if (val.substring(i_val,i_val+2).toLowerCase()=="am") {
        ampm="AM";
      }
      else if (val.substring(i_val,i_val+2).toLowerCase()=="pm") {
        ampm="PM";
      }
      else {
        return null;
      }
      i_val+=2;
    }
    else {
      if (val.substring(i_val,i_val+token.length)!=token) {
        return null;
      }
      else {
        i_val+=token.length;
      }
    }
  }
  // If there are any trailing characters left in the value, it doesn't match
  if (i_val != val.length) { 
    return null; 
  }
  // Is date valid for month?
  if (month==2) {
    // Check for leap year
    if ( ( (year%4==0)&&(year%100 != 0) ) || (year%400==0) ) { // leap year
      if (date > 29){ 
        return null; 
      }
    }
    else { 
      if (date > 28) { 
        return null; 
      } 
    }
  }
  if ((month==4)||(month==6)||(month==9)||(month==11)) {
    if (date > 30) { 
      return null; 
    }
  }
  // Correct hours value
  if (hh<12 && ampm=="PM") {
    hh=hh-0+12; 
  }
  else if (hh>11 && ampm=="AM") { 
    hh-=12; 
  }
  return new Date(year,month-1,date,hh,mm,ss);
};

// Check if a date string is valid
Date.isValid = function(val,format) {
  return (Date.parseString(val,format) != null);
};

// Check if a date object is before another date object
Date.prototype.isBefore = function(date2) {
  if (date2==null) { 
    return false; 
  }
  return (this.getTime()<date2.getTime());
};

// Check if a date object is after another date object
Date.prototype.isAfter = function(date2) {
  if (date2==null) { 
    return false; 
  }
  return (this.getTime()>date2.getTime());
};

// Check if two date objects have equal dates and times
Date.prototype.equals = function(date2) {
  if (date2==null) { 
    return false; 
  }
  return (this.getTime()==date2.getTime());
};

// Check if two date objects have equal dates, disregarding times
Date.prototype.equalsIgnoreTime = function(date2) {
  if (date2==null) { 
    return false; 
  }
  var d1 = new Date(this.getTime()).clearTime();
  var d2 = new Date(date2.getTime()).clearTime();
  return (d1.getTime()==d2.getTime());
};

// Format a date into a string using a given format string
Date.prototype.format = function(format) {
  format=format+"";
  var result="";
  var i_format=0;
  var c="";
  var token="";
  var y=this.getYear()+"";
  var M=this.getMonth()+1;
  var d=this.getDate();
  var E=this.getDay();
  var H=this.getHours();
  var m=this.getMinutes();
  var s=this.getSeconds();
  var H;
  // Convert real date parts into formatted versions
  var value=new Object();
  if (y.length < 4) {
    y=""+(+y+1900);
  }
  value["y"]=""+y;
  value["yyyy"]=y;
  value["yy"]=y.substring(2,4);
  value["M"]=M;
  value["MM"]=Date.LZ(M);
  value["MMM"]=Date.monthNames[M-1];
  value["NNN"]=Date.monthAbbreviations[M-1];
  value["d"]=d;
  value["dd"]=Date.LZ(d);
  value["E"]=Date.dayAbbreviations[E];
  value["EE"]=Date.dayNames[E];
  value["H"]=H;
  value["HH"]=Date.LZ(H);
  if (H==0){
    value["h"]=12;
  }
  else if (H>12){
    value["h"]=H-12;
  }
  else {
    value["h"]=H;
  }
  value["hh"]=Date.LZ(value["h"]);
  value["K"]=value["h"]-1;
  value["k"]=value["H"]+1;
  value["KK"]=Date.LZ(value["K"]);
  value["kk"]=Date.LZ(value["k"]);
  if (H > 11) { 
    value["a"]="PM"; 
  }
  else { 
    value["a"]="AM"; 
  }
  value["m"]=m;
  value["mm"]=Date.LZ(m);
  value["s"]=s;
  value["ss"]=Date.LZ(s);
  while (i_format < format.length) {
    c=format.charAt(i_format);
    token="";
    while ((format.charAt(i_format)==c) && (i_format < format.length)) {
      token += format.charAt(i_format++);
    }
    if (typeof(value[token])!="undefined") { 
      result=result + value[token]; 
    }
    else { 
      result=result + token; 
    }
  }
  return result;
};

// Get the full name of the day for a date
Date.prototype.getDayName = function() { 
  return Date.dayNames[this.getDay()];
};

// Get the abbreviation of the day for a date
Date.prototype.getDayAbbreviation = function() { 
  return Date.dayAbbreviations[this.getDay()];
};

// Get the full name of the month for a date
Date.prototype.getMonthName = function() {
  return Date.monthNames[this.getMonth()];
};

// Get the abbreviation of the month for a date
Date.prototype.getMonthAbbreviation = function() { 
  return Date.monthAbbreviations[this.getMonth()];
};

// Clear all time information in a date object
Date.prototype.clearTime = function() {
  this.setHours(0); 
  this.setMinutes(0);
  this.setSeconds(0); 
  this.setMilliseconds(0);
  return this;
};

// Add an amount of time to a date. Negative numbers can be passed to subtract
// time.
Date.prototype.add = function(interval, number) {
  if (typeof(interval)=="undefined" || interval==null || typeof(number)=="undefined" || number==null) { 
    return this; 
  }
  number = +number;
  if (interval=='y') { // year
    this.setFullYear(this.getFullYear()+number);
  }
  else if (interval=='M') { // Month
    this.setMonth(this.getMonth()+number);
  }
  else if (interval=='d') { // Day
    this.setDate(this.getDate()+number);
  }
  else if (interval=='w') { // Weekday
    var step = (number>0)?1:-1;
    while (number!=0) {
      this.add('d',step);
      while(this.getDay()==0 || this.getDay()==6) { 
        this.add('d',step);
      }
      number -= step;
    }
  }
  else if (interval=='h') { // Hour
    this.setHours(this.getHours() + number);
  }
  else if (interval=='m') { // Minute
    this.setMinutes(this.getMinutes() + number);
  }
  else if (interval=='s') { // Second
    this.setSeconds(this.getSeconds() + number);
  }
  return this;
};