function semAcentos(oCampo){
	var sValor = new String(oCampo.value);
	sValor = sValor.replace(/ç/g,"c");	
	sValor = sValor.replace(/Ç/g,"C");	
	
	sValor = sValor.replace(/á/g,"a");	
	sValor = sValor.replace(/Á/g,"A");
	sValor = sValor.replace(/à/g,"a");	
	sValor = sValor.replace(/À/g,"A");
	sValor = sValor.replace(/ã/g,"a");	
	sValor = sValor.replace(/Ã/g,"A");

	sValor = sValor.replace(/é/g,"e");	
	sValor = sValor.replace(/É/g,"E");
	sValor = sValor.replace(/è/g,"e");	
	sValor = sValor.replace(/È/g,"E");

	sValor = sValor.replace(/í/g,"i");	
	sValor = sValor.replace(/Í/g,"I");
	sValor = sValor.replace(/ì/g,"i");	
	sValor = sValor.replace(/Ì/g,"I");

	sValor = sValor.replace(/ó/g,"o");	
	sValor = sValor.replace(/Ó/g,"O");
	sValor = sValor.replace(/ò/g,"o");	
	sValor = sValor.replace(/Ó/g,"O");
	sValor = sValor.replace(/õ/g,"o");	
	sValor = sValor.replace(/Õ/g,"O");

	sValor = sValor.replace(/ú/g,"u");	
	sValor = sValor.replace(/Ú/g,"u");	
	sValor = sValor.replace(/ù/g,"u");	
	sValor = sValor.replace(/Ù/g,"u");	
	sValor = sValor.replace(/ü/g,"u");	
	sValor = sValor.replace(/Ü/g,"u");	

	sValor = sValor.replace(/ç/g,"c");	
	sValor = sValor.replace(/Ç/g,"C");	
	sValor = sValor.replace(/ç/g,"c");	
	sValor = sValor.replace(/Ç/g,"C");	
	
	oCampo.value = sValor;
}


function FormataData(oCampo, eTecla){
	var iTecla = eTecla.keyCode;            //Captura o codigo da tecla pressionada

	var sValor = new String(oCampo.value);  //Pega o valor do campo
	sValor = sValor.replace("/", "");       //Tira as barras do valor do campo
	sValor = sValor.replace("/", "");
	iTamanhoValor = sValor.length + 1;      // Armazena o tamanho do campo
	
	if (iTecla != 9 && iTecla != 8 && iTecla != 111){   //Verifica se a tecla pressionada não for TAB, BKSP, DELETE
		if (iTamanhoValor > 2 && iTamanhoValor < 5)
			oCampo.value = sValor.substr(0, 2) + '/' + sValor.substr(2, iTamanhoValor);
		if (iTamanhoValor >= 5 && iTamanhoValor <=10)
			oCampo.value = sValor.substr(0,2) + '/' + sValor.substr(2,2) + '/' + sValor.substr(4,4);
	}
}

/*-----------------------------------------------------------------------------------------
	Nome:			FormataCPF
	Descrição:	Função usada para utilizar uma máscara na digitação de CPF
	Utilização:	onKeydown="javascript:FormataCPF(this,event);"
	Recebe:
		Objeto		oCampo				Campo a ser tratado
		Evento		eTecla				Tecla pressionada no campo pelo usuário
	RETORNA:
		Campo formatado
-------------------------------------------------------------------------------------------*/
function FormataCPF(oCampo, eTecla){
	// var iTecla = eTecla.keyCode;

	eTecla = (eTecla) ? eTecla : event;
	var iTecla = (eTecla.charCode) ? eTecla.charCode : ((eTecla.keyCode) ? eTecla.keyCode : 
        ((eTecla.which) ? eTecla.which : 0));            //Captura o codigo da tecla pressionada

	// alert(iTecla);
	
	var sValor = new String(oCampo.value);
	
		if (window.event)
		   key = window.event.keyCode;
		else if (e)
		   key = eTecla.which;

	var keychar = String.fromCharCode(key);

	if (!((key==null) || (key==0) || (key==8) || (key==9) || (key==13) || (key==27) || (key==46) || (key==37) || (key==39) || (key>=96 && key<=105)))
		if (!(("0123456789").indexOf(keychar) > -1))
			   return false;
		   
	sValor = sValor.replace(".", "");
	sValor = sValor.replace(".", "");
	sValor = sValor.replace("-", "");

	iTamanhoValor = sValor.length + 1;
	if (iTecla != 9 && iTecla != 8 && iTecla != 46 && iTecla!=37 && iTecla!=39){
		if (iTamanhoValor > 3 && iTamanhoValor < 7)
			oCampo.value = sValor.substr(0, 3) + '.' + sValor.substr(3, iTamanhoValor);
		if (iTamanhoValor >= 7 && iTamanhoValor <10)
			oCampo.value = sValor.substr(0,3) + '.' + sValor.substr(3,3) + '.' + sValor.substr(6,iTamanhoValor-6);
		if (iTamanhoValor >= 10 && iTamanhoValor < 12)
			oCampo.value = sValor.substr(0,3) + '.' + sValor.substr(3,3) + '.' + sValor.substr(6,3) + '-' + sValor.substr(9,iTamanhoValor-9);
	}
}

/*-----------------------------------------------------------------------------------------
	Nome:		FormataCnpj
	Descrição:	Função usada para utilizar uma máscara na digitação de CNPJ
	Utilização:	onKeydown="javascript:FormataCnpj(this,event);"
	Recebe:
		Objeto		oCampo				Campo a ser tratado
		Evento		eTecla				Tecla pressionada no campo pelo usuário
	RETORNA:
		Campo formatado
-------------------------------------------------------------------------------------------*/
function FormataCnpj(Campo, teclapres){

   var tecla = teclapres.keyCode;

   var vr = new String(Campo.value);
   vr = vr.replace(".", "");
   vr = vr.replace(".", "");
   vr = vr.replace("/", "");
   vr = vr.replace("-", "");

   tam = vr.length + 1 ;

   
   if (tecla != 9 && tecla != 8){
      if (tam > 2 && tam < 6)
         Campo.value = vr.substr(0, 2) + '.' + vr.substr(2, tam);
      if (tam >= 6 && tam < 9)
         Campo.value = vr.substr(0,2) + '.' + vr.substr(2,3) + '.' + vr.substr(5,tam-5);
      if (tam >= 9 && tam < 13)
         Campo.value = vr.substr(0,2) + '.' + vr.substr(2,3) + '.' + vr.substr(5,3) + '/' + vr.substr(8,tam-8);
      if (tam >= 13 && tam < 15)
         Campo.value = vr.substr(0,2) + '.' + vr.substr(2,3) + '.' + vr.substr(5,3) + '/' + vr.substr(8,4)+ '-' + vr.substr(12,tam-12);
      }
}

/*---------------------------------------------------------------------------------------------------------------
	Nome:			FormataCEP
	Descrição:	Função usada para utilizar uma máscara na digitação de CEP
	Utilização:	onKeydown="javascript:FormataCEP(this,event);"
	Recebe:
		Objeto		objCampo				Campo a ser tratado
		Evento		eTecla				Tecla pressionada no campo pelo usuário
	RETORNA:
		Campo formatado
---------------------------------------------------------------------------------------------------------------*/
function FormataCEP(objCampo, eTecla){

	eTecla = (eTecla) ? eTecla : event;
	var iTecla = (eTecla.charCode) ? eTecla.charCode : ((eTecla.keyCode) ? eTecla.keyCode : 
        ((eTecla.which) ? eTecla.which : 0));            //Captura o codigo da tecla pressionada

	// alert(iTecla);
		if (window.event)
		   key = window.event.keyCode;
		else if (e)
		   key = eTecla.which;

		var keychar = String.fromCharCode(key);
		
		if (!((key==null) || (key==0) || (key==8) || (key==9) || (key==13) || (key==27) || (key==46) || (key==37) || (key==39) || (key>=96 && key<=105)))
			if (!(("0123456789").indexOf(keychar) > -1))
				   return false;
		   

if(document.all) // Internet Explorer
				var sTecla = event.keyCode;
			else if(document.layers) // Nestcape
				var sTecla = eTecla.which;

		if(objCampo.value.length > 9){
			return false;	
		}
		if(sTecla != 8 && iTecla != 46 && iTecla!=37 && iTecla!=39){
			if(objCampo.value.length == 5){
				objCampo.value += '-';
			}
		}
		return true;
}

/*---------------------------------------------------------------------------------------------------------------
	Nome:			FormataDecimal
	Descrição:	Função para tratar campos numéricos que possuem casas decimais, podendo ser 
	            sinalizado ou não.
 
	OBS.:       Quando não existe a necessidade de casas decimais,  passar o valor do parametro 
  		         asCasasInteiras < 1
	
	Utilização:	onkeyup="javascript:FormataDecimal(document.nome_do_form.nome_do_campo,5,2)"
               onblur="javascript:FormataDecimal(document.nome_do_form.nome_do_campo,5,2)"
 
	Recebe:
		Object		asObjeto 			Objeto que será verificado * Obrigatório
 		Inteiro		asCasasDecimais   Numero de casas decimais * não é Obrigatório
 		Inteiro		asCasasInteiras	Número de casas inteiras * não é Obrigatório
 		Boolean		asSinalizado 		Permite ou não o caracter "-", indicando número negativo * não é Obrigatório
 
  RETORNA:
 		String		Valor do objeto formatado
---------------------------------------------------------------------------------------------------------------*/
function FormataDecimal( asObjeto , asCasasInteiras, asCasasDecimais, asSinalizado )
{
	if(!window.event)return;
	// Verifico se o carcter digitado é <TAB> se for retorno
	if ( event.keyCode == 9 ) return;
	
	// Verifico se os caracteres digitados são as setas dos teclados, se for retorno
	if ( event.keyCode > 33 && event.keyCode < 41) return;
	// Verifico os argumentos passados
	// Verifico se foi passado o número de casas Inteiras
	if ( !arguments[1] ) asCasasInteiras = 0;
	
	// Verifico se foi passado o número de casas Decimais
	if ( !arguments[2] ) asCasasDecimais = 0;
	
	// Verifico se foi passado o parametro asSinalizado
	if ( !arguments[3] ) asSinalizado = false;
		
	// Para corrigir bug encontrado quando o número de casas inteiras é livre e é um número sinalizado
	// Limito o máximo em 40
	if ( asSinalizado && ( asCasasInteiras == 0 ) ) asCasasInteiras = 40;
	
	
	iNumCaracter = 0;// Conta o número de ocorrências do caracter ","
	
   sValor = asObjeto.value;// Armazeno o valor do objeto
	
	sValor = sValor.replace(".",",");// Altero a ocorrencia do caracter "." por ","
		
	sDigitos = "0123456789,";// Caracteres possíveis no value do objeto
	
	iVirgulaPosicao = 0;// Variável que guarda a primeira ocorrência do caracter ","
	
	iEncontrou = 0;// Varíavel que diz se foi encontrado o primeiro caracter ",";
	
	// Verifico se o campo foi preenchido, caso o campo foi preenhchido o mesmo será tratado
	if ( sValor.length > 0){
		// Verifico todos os caracteres existentes
		for ( i = sValor.length; i >= 0 ; i--){	
			// Verifico se os caracteres não existem dentro da string sDigitos, que contém, somente, caracteres válidos
			if ( sDigitos.indexOf( sValor.charAt(i),0) < 0){
				//alert( asSinalizado )
				// Verifico se é um número sinalizado
				if ( asSinalizado && ( sValor.charAt(i)== "-" ) ){
					// Verifico se o caracter "-" é o primeiro caracter
					if ( sValor.lastIndexOf( "-" ) > 0 ){
						// Retiro o caracter inválido da string
						sAntes  = sValor.substring(0, sValor.lastIndexOf( "-" ) )
						sDepois = sValor.substring(sValor.lastIndexOf( "-" ) + 1 , sValor.length )
						sValor  = sAntes + sDepois
					}
					else{
						if ( sValor.indexOf('-') == 0 ){
							asCasasInteiras++;
						}
					}
				}
				else
				{
					// Retiro o caracter inválido da string
					sValor = sValor.replace( sValor.charAt(i),"" );
				}
			}
		}
	}
	
	asObjeto.value = sValor;// Altero o valor do campo	

	// Verifico se o primeiro caracter é um ponto, se for adiciono o caracter "0" antes da vírgula
	if ( sValor.indexOf(",") == 0 ){
		asObjeto.value = "0" + ",";	
	}
	 
	// Verifico se existem caracteres "," em sValor
	if ( sValor.indexOf(",") == -1 ){ // não existe
		// Verifico se existe um limite de casas inteiras
		if ( asCasasInteiras > 0 ){
			// Limito o numero de caracteres para asCasasInteiras	
			asObjeto.value = sValor.substring( 0, asCasasInteiras ); 
		}
	}
	else // Existe algum caracter ","
	{
		
		// Verifico se existe um limite de casas inteiras
		if ( asCasasInteiras > 0 ){
			// Verifico o número de caracteres antes da virgula, se existir será retirado o último caracter antes da virgula
			// Este tratamento foi feito para garantir que o limite de casas inteiras seja respeitado
			if ( sValor.indexOf(",") > asCasasInteiras  ){
				
				iVirgula 		= sValor.indexOf(","); // Encontro a ocorrência da vírgula

				sParteInteira 	= sValor.substring( 0, asCasasInteiras ); // Busco a parte inteira
				
				sParteDecimal 	= sValor.substring( iVirgula , sValor.length );// Busco a parte decimal
				
				sValor = sParteInteira + sParteDecimal;// Crio a nova string
				
				asObjeto.value = sValor;// retorno para o objeto
			}
		}

		// Verifico se o número de casas decimaisé igual a zero, ou seja inteiro
		// Retiro a vírgula
		if ( asCasasDecimais < 1){
			sValor = asObjeto.value;// Busco o valor no Objeto

			for ( i = sValor.length; i >= 0 ; i--){// Verifico todos os caracteres existentes
				sValor = asObjeto.value
				if ( sValor.indexOf( ",",0) > 0){
					// Retiro o caracter inválido da string
					asObjeto.value = sValor.replace(sValor.charAt(i),"");
				}	
			}
		}
		else{
			// Verifico as ocorrências do caracter que indica casas decimais
			for ( i = 0 ; i < sValor.length ; i++ ){
				// Verifico se existe algum caracter "," após a primeira ocorrência
				if ( sValor.indexOf( "," , i ) > iVirgulaPosicao ){// Existe pelo menos um ponto
					
					// Verifico o número de caracteres encontrados
					if ( iNumCaracter >= 1 ){// Existe mais de uma vírgula
						// Retiro esta vírgula da string
						sValor = sValor.substring( 0, sValor.indexOf( "," , i ) );	
						// Incremento o número de caracteres
						iNumCaracter++;
					}
					
					// Verifico se o primeiro caracter "," foi encontrado
					if ( iNumCaracter == 0 ){ // É o primeiro caracter
						// Armazendo a posição da ocorrência da virgula
						iVirgulaPosicao = sValor.indexOf( "," , i );
						// Altero os status da variáveis de controle
						iEncontrou = 1;
						iNumCaracter = 1;
					}
				}
			}
			
			if ( iEncontrou == 1){
				// Reescrevo o valor do objero com o número de casa decimais
				asObjeto.value = sValor.substring( 0, iVirgulaPosicao  + asCasasDecimais + 1  );
			}
		}
	}
	
	// Verifico o evento ocorrido para tratar casos passíveis de erros, garantindo sempre zero nos
	// casos descritos abaixo
	if( event.type == "blur" )
	{
		// Testes necessários para evitar textos indesejados
		if ( sValor == "" || sValor == "-" || sValor == "-0" || sValor == "-0," || sValor == "0,"){
			asObjeto.value = "0"
			return
		}
		
		// Verifico se o último caractere é uma virgula, se for retiro da string
		if ( sValor.indexOf(",") == ( sValor.length - 1 )){
			asObjeto.value = sValor.replace(",","");
		}
		
		// Retiro caracteres 0 desnecessários
		sValor = sValor.replace(",",".")
		
		// Verifico se não é numérico, se não for converto para zero
		if (isNaN(parseFloat(sValor))){
			asObjeto.value = "0"
			return
		}
		sValor = parseFloat( sValor )
		sValor = sValor.toString()
		sValor = sValor.replace(".",",")
		asObjeto.value = sValor
		sValor = ""
	}	
}

/*-----------------------------------------------------------------------------------------
	Nome:			FormataTamanhoTextArea
	Descrição:	Limita o tamanho de um campo textarea
	Utilização:	onKeyPress="return FormataTamanhoTextArea(campo,tamanho);"
	Recebe:
		Objeto		objCampo		Campo a ser tratado
		Inteiro     iTamanho    Tamanho do campo
	RETORNA:
		Campo limitado
-------------------------------------------------------------------------------------------*/
function FormataTamanhoTextArea(objCampo,iTamanho){
	if(objCampo.value.length >= iTamanho)
		return false;
	return true;
}
/////////////////////////////////////////////////////////////////////////////////////
//Função para colocar máscara de valor do tipo xxxx,xx só permite digitar números
function FormataValor(campo,tammax,teclapres) {

	eTecla = (teclapres) ? teclapres : event;
	var iTecla = (eTecla.charCode) ? eTecla.charCode : ((eTecla.keyCode) ? eTecla.keyCode : 
        ((eTecla.which) ? eTecla.which : 0));            //Captura o codigo da tecla pressionada

	if (iTecla != 46 && iTecla!=37 && iTecla!=39) {

		if(!tecla(teclapres.keyCode))
			return false;
		
		var stecla = teclapres.keyCode;
		vr = campo.value;
		vr = vr.replace( "/", "" );
		vr = vr.replace( "/", "" );
		vr = vr.replace( ",", "" );
		vr = vr.replace( ".", "" );
		vr = vr.replace( ".", "" );
		vr = vr.replace( ".", "" );
		vr = vr.replace( ".", "" );
		tam = vr.length;
	
		if (tam < tammax && stecla != 8){ tam = vr.length + 1 ; }
	
		if (stecla == 8 ){	tam = tam - 1 ; }
			
			if ( stecla == 8 || stecla >= 48 && stecla <= 57 || stecla >= 96 && stecla <= 105 ){
				if ( tam <= 2 ){ 
					campo.value = vr ; }
				if ( (tam > 2) && (tam <= 5) ){
					campo.value = vr.substr( 0, tam - 2 ) + ',' + vr.substr( tam - 2, tam ) ; }
				if ( (tam >= 6) && (tam <= 8) ){
					campo.value = vr.substr( 0, tam - 5 ) + '.' + vr.substr( tam - 5, 3 ) + ',' + vr.substr( tam - 2, tam ) ; }
				if ( (tam >= 9) && (tam <= 11) ){
					campo.value = vr.substr( 0, tam - 8 ) + '.' + vr.substr( tam - 8, 3 ) + '.' + vr.substr( tam - 5, 3 ) + ',' + vr.substr( tam - 2, tam ) ; }
				if ( (tam >= 12) && (tam <= 14) ){
					campo.value = vr.substr( 0, tam - 11 ) + '.' + vr.substr( tam - 11, 3 ) + '.' + vr.substr( tam - 8, 3 ) + '.' + vr.substr( tam - 5, 3 ) + ',' + vr.substr( tam - 2, tam ) ; }
				if ( (tam >= 15) && (tam <= 17) ){
					campo.value = vr.substr( 0, tam - 14 ) + '.' + vr.substr( tam - 14, 3 ) + '.' + vr.substr( tam - 11, 3 ) + '.' + vr.substr( tam - 8, 3 ) + '.' + vr.substr( tam - 5, 3 ) + ',' + vr.substr( tam - 2, tam ) ;}
			}
	}
	
	return true;
		
}

function numbersonly(myfield, e, dec) {
	var key;
	var keychar;

	if (window.event)
	   key = window.event.keyCode;
	else if (e)
	   key = e.which;
	else
	   return true;
	keychar = String.fromCharCode(key);

	// control keys
	if ((key==null) || (key==0) || (key==8) || 
		(key==9) || (key==13) || (key==27) )
	   return true;

	// numbers
	else if ((("0123456789").indexOf(keychar) > -1))
	   return true;
	
	// decimal point jump
	else
	   return false;
	}	

function validate_email(field,alerttxt) {
	with (field) {
		apos=value.indexOf("@")
		dotpos=value.lastIndexOf(".")
		espaco=value.indexOf(" ")
		if (apos<1||dotpos-apos<2||espaco>0) {
			alert(alerttxt);
		  	return false
		} else {
			return true
		}
	}
}
////////////////////////////////////////////////////////////////////////
// Função que impede a digitação de outros caracteres além de números //
function tecla(e) {
	if(document.all) // Internet Explorer
		var tecla = event.keyCode;

	else if(document.layers) // Nestcape
		var tecla = e.which;

	if((tecla > 47 && tecla < 58)||(tecla > 95 && tecla < 106)) // numeros de 0 a 9
		return true;
	else {
		if (tecla != 8) // backspace
		 return false;
		else
		 return true;
	}
}

function isCnpj(pCnpj) {
	var numero = formatCpfCnpj(pCnpj, false, true);
	var base = numero.substring(0, NUM_DGT_CNPJ_BASE);
	var ordem = numero.substring(NUM_DGT_CNPJ_BASE, 12);
	var digitos = dvCpfCnpj(base + ordem, true);
	var algUnico;

	// Valida dígitos verificadores
	if (numero != base + ordem + digitos) return false;

	/* Não serão considerados válidos os CNPJ com os seguintes números BÁSICOS:
	 * 11.111.111, 22.222.222, 33.333.333, 44.444.444, 55.555.555,
	 * 66.666.666, 77.777.777, 88.888.888, 99.999.999.
	 */
	algUnico = numero.charAt(0) != '0';
	for (i=1; i<NUM_DGT_CNPJ_BASE; i++)
	{
		algUnico = algUnico && (numero.charAt(i-1) == numero.charAt(i));
	}
	if (algUnico) return false;

	/* Não será considerado válido CNPJ com número de ORDEM igual a 0000.
	 * Não será considerado válido CNPJ com número de ORDEM maior do que 0300
	 * e com as três primeiras posições do número BÁSICO com 000 (zeros).
	 * Esta crítica não será feita quando o no BÁSICO do CNPJ for igual a 00.000.000.
	 */
	if (ordem == "0000") return false;
	return (base == "00000000"
		|| parseInt(ordem, 10) <= 300 || base.substring(0, 3) != "000");
} //isCnpj
/**
 * @author Márcio d'Ávila
 * @version 1.01, 2004
 *
 * PROTÓTIPOS:
 * método String.lpad(int pSize, char pCharPad)
 * método String.trim()
 *
 * String unformatNumber(String pNum)
 * String formatCpfCnpj(String pCpfCnpj, boolean pUseSepar, boolean pIsCnpj)
 * String dvCpfCnpj(String pEfetivo, boolean pIsCnpj)
 * boolean isCpf(String pCpf)
 * boolean isCnpj(String pCnpj)
 * boolean isCpfCnpj(String pCpfCnpj)
 */


var NUM_DIGITOS_CPF  = 11;
var NUM_DIGITOS_CNPJ = 14;
var NUM_DGT_CNPJ_BASE = 8;


/**
 * Adiciona método lpad() à classe String.
 * Preenche a String à esquerda com o caractere fornecido,
 * até que ela atinja o tamanho especificado.
 */
String.prototype.lpad = function(pSize, pCharPad)
{
	var str = this;
	var dif = pSize - str.length;
	var ch = String(pCharPad).charAt(0);
	for (; dif>0; dif--) str = ch + str;
	return (str);
} //String.lpad


/**
 * Adiciona método trim() à classe String.
 * Elimina brancos no início e fim da String.
 */
String.prototype.trim = function()
{
	return this.replace(/^\s*/, "").replace(/\s*$/, "");
} //String.trim


/**
 * Elimina caracteres de formatação e zeros à esquerda da string
 * de número fornecida.
 * @param String pNum
 *      String de número fornecida para ser desformatada.
 * @return String de número desformatada.
 */
function unformatNumber(pNum)
{
	return String(pNum).replace(/\D/g, "").replace(/^0+/, "");
} //unformatNumber


/**
 * Formata a string fornecida como CNPJ ou CPF, adicionando zeros
 * à esquerda se necessário e caracteres separadores, conforme solicitado.
 * @param String pCpfCnpj
 *      String fornecida para ser formatada.
 * @param boolean pUseSepar
 *      Indica se devem ser usados caracteres separadores (. - /).
 * @param boolean pIsCnpj
 *      Indica se a string fornecida é um CNPJ.
 *      Caso contrário, é CPF. Default = false (CPF).
 * @return String de CPF ou CNPJ devidamente formatada.
 */
function formatCpfCnpj(pCpfCnpj, pUseSepar, pIsCnpj)
{
	if (pIsCnpj==null) pIsCnpj = false;
	if (pUseSepar==null) pUseSepar = true;
	var maxDigitos = pIsCnpj? NUM_DIGITOS_CNPJ: NUM_DIGITOS_CPF;
	var numero = unformatNumber(pCpfCnpj);

	numero = numero.lpad(maxDigitos, '0');
	if (!pUseSepar) return numero;

	if (pIsCnpj)
	{
		reCnpj = /(\d{2})(\d{3})(\d{3})(\d{4})(\d{2})$/;
		numero = numero.replace(reCnpj, "$1.$2.$3/$4-$5");
	}
	else
	{
		reCpf  = /(\d{3})(\d{3})(\d{3})(\d{2})$/;
		numero = numero.replace(reCpf, "$1.$2.$3-$4");
	}
	return numero;
} //formatCpfCnpj


/**
 * Calcula os 2 dígitos verificadores para o número-efetivo pEfetivo de
 * CNPJ (12 dígitos) ou CPF (9 dígitos) fornecido. pIsCnpj é booleano e
 * informa se o número-efetivo fornecido é CNPJ (default = false).
 * @param String pEfetivo
 *      String do número-efetivo (SEM dígitos verificadores) de CNPJ ou CPF.
 * @param boolean pIsCnpj
 *      Indica se a string fornecida é de um CNPJ.
 *      Caso contrário, é CPF. Default = false (CPF).
 * @return String com os dois dígitos verificadores.
 */
function dvCpfCnpj(pEfetivo, pIsCnpj)
{
	if (pIsCnpj==null) pIsCnpj = false;
	var i, j, k, soma, dv;
	var cicloPeso = pIsCnpj? NUM_DGT_CNPJ_BASE: NUM_DIGITOS_CPF;
	var maxDigitos = pIsCnpj? NUM_DIGITOS_CNPJ: NUM_DIGITOS_CPF;
	var calculado = formatCpfCnpj(pEfetivo, false, pIsCnpj);
	calculado = calculado.substring(2, maxDigitos);
	var result = "";

	for (j = 1; j <= 2; j++)
	{
		k = 2;
		soma = 0;
		for (i = calculado.length-1; i >= 0; i--)
		{
			soma += (calculado.charAt(i) - '0') * k;
			k = (k-1) % cicloPeso + 2;
		}
		dv = 11 - soma % 11;
		if (dv > 9) dv = 0;
		calculado += dv;
		result += dv
	}

	return result;
} //dvCpfCnpj


/**
 * Testa se a String pCpf fornecida é um CPF válido.
 * Qualquer formatação que não seja algarismos é desconsiderada.
 * @param String pCpf
 *      String fornecida para ser testada.
 * @return <code>true</code> se a String fornecida for um CPF válido.
 */
function isCpf(pCpf)
{
	var numero = formatCpfCnpj(pCpf, false, false);
	var base = numero.substring(0, numero.length - 2);
	var digitos = dvCpfCnpj(base, false);
	var algUnico, i;

	// Valida dígitos verificadores
	if (numero != base + digitos) return false;

	/* Não serão considerados válidos os seguintes CPF:
	 * 000.000.000-00, 111.111.111-11, 222.222.222-22, 333.333.333-33, 444.444.444-44,
	 * 555.555.555-55, 666.666.666-66, 777.777.777-77, 888.888.888-88, 999.999.999-99.
	 */
	algUnico = true;
	for (i=1; i<NUM_DIGITOS_CPF; i++)
	{
		algUnico = algUnico && (numero.charAt(i-1) == numero.charAt(i));
	}
	return (!algUnico);
}

function verifica(){

	if(form1.field_nome.value==""){
		alert("É preciso informar o seu nome.");
		form1.field_nome.focus();
		return false;
	}
	if(form1.field_doc.value==""){
		alert("É preciso informar o seu CPF.");
		form1.field_doc.focus();
		return false;
	}
	if(!isCpf(form1.field_doc.value)){
		alert("Este não é um CPF válido.");
		form1.field_doc.focus();
		return false;
	}
	if(form1.field_logradouro.value==""){
		alert("É preciso informar o seu endereço.");
		form1.field_logradouro.focus();
		return false;
	}
	if(form1.field_cidade.value==""){
		alert("É preciso informar a sua cidade.");
		form1.field_cidade.focus();
		return false;
	}
	if(form1.field_uf.value=="-"){
		alert("É preciso informar o seu estado.");
		form1.field_uf.focus();
		return false;
	}
	if(form1.field_cep.value==""){
		alert("É preciso informar o seu CEP.");
		form1.field_cep.focus();
		return false;
	}
	if(form1.field_cep.value.length < 9){
		alert("O CEP informado não é válido.");
		form1.field_cep.focus();
		return false;
	}
	if(form1.field_comercial.value=="" && form1.field_residencial.value==""){
		alert("É preciso informar seu telefone comercial ou o residencial.");
		form1.field_comercial.focus();
		return false;
	}
	if(form1.field_comercial.value!="" || form1.field_residencial.value!="" || form1.field_celular.value!="" || form1.field_fax.value!=""){
		if(form1.field_ddd.value==""){
			alert("É preciso informar o DDD de seus telefones.");
			form1.field_ddd.focus();
			return false;
		}
	}
	if(form1.field_email.value==""){
		alert("É preciso informar um e-mail de contato.");
		form1.field_email.focus();
		return false;
	}

	if (validate_email(form1.field_email,"O e-mail informado parece não ser válido.")==false){
		form1.field_email.focus();
		return false;
	}

	if(form1.field_valor1.value==""){
		alert("É preciso informar o valor a ser investido.");
		form1.field_valor1.focus();
		return false;
	}
	if(form1.field_valor1.value.replace(".","").replace(",","")>1000000){
		alert("Nosso sistema só permite doações de até R$10.000,00 (dez mil reais) por cada boleto bancário gerado.\n\nCaso deseje contribuir com valor superior a este, por favor emita mais de um boleto.\n\nObrigado.");
		form1.field_valor1.focus();
		return false;
	}
	
	if((!form1.prestacao[0].checked) && (!form1.prestacao[1].checked) && (!form1.prestacao[2].checked)){
		alert("É preciso escolher a forma de pagamento da seu investimento.");
		form1.prestacao[0].focus();
		return false;
	}
	
	if(form1.prestacao[0].checked){
		if(form1.field_projeto.value=="-- Escolha um Projeto --"){
			alert("É preciso escolher um projeto para receber o seu investimento.");
			form1.field_projeto.focus();
			return false;
		}
	}

	if(form1.prestacao[1].checked){
		if((!form1.field_projeto1[0].checked) && (!form1.field_projeto1[1].checked)){
			alert("É preciso escolher pelo menos\num projeto para receber a sua doação.");
			form1.field_projeto1[0].focus();
			return false;
		}
	}
	
	form1.pfm_button_submit.style.display='none'; 
	form1.pfm_button_reset.style.display='none'; 
	return true;
}

function iniciando(){

//	var now = new Date("2008/02/15");
//	var now = new Date();
//	var today = new Date(now.getYear(),now.getMonth(),now.getDate());
//	var date1 = new Date(now.getYear(),"11","01");
//	var date2 = new Date(now.getYear(),"11","31");
//	var date3 = new Date(now.getYear(),"00","01");
//	var date4 = new Date(now.getYear(),"01","01");

//	if(	((today>date1) && (today<=date2)) ||  ((today>=date3) && (today<=date4))  ){
//		temporario.style.display='none'; 
//		projetos.style.display="none";
//		projetos2.style.display="none";
//	}
//	else{
//		temporario.style.display='inline'; 
//		projetos.style.display="none";
//		projetos2.style.display="inline";
//	}
//	exibeProjetos();
			
	//hoje = new Date("2008/02/15");
	hoje = new Date();
	//alert(hoje.getDate());
	mes = hoje.getMonth()+1;
	dia = hoje.getDate();
	if(dia<26)
		prestacoes = 12 - mes + 1;
	else
		prestacoes = 12 - mes;
	
	document.getElementById('parcela').innerHTML = prestacoes;
	document.getElementById('form1').field_parcelas.value = prestacoes;
			
}
	function exibeProjetos(){
		if(form1.prestacao[1].checked==true){
			projetos.style.display="inline";
			projetos2.style.display="none";
		}	
		else{
			projetos.style.display="none";
			projetos2.style.display="inline";
		}
	}
	
	function moeda2float(moeda){
		   moeda = moeda.replace(".","");
		   moeda = moeda.replace(",",".");
		   return parseFloat('0'+moeda);
	}