// funções para todas as páginas do site
//*****************************************************************************************************


// exibe uma mensagem com aspas simples
// *****************************************************************************************************
function mensagemAlerta(alerta) {
	alert(alerta.replace(/\|/g,"'"));
	window.focus();
}


// *****************************************************************************************************
// Objeto utilizado para calcular, mostrar e limitar o tamanho de campos textarea e input
// para aplicar, colocar a classe "mostraTamanho" no campo e garantir que ele tenha id
// o tamanho máximo do campo é definido pelo atributo "maximo" colocado no objeto (senão o default é 4000)
//*************************************************************************************************
var mostraTamanho = {
	// método eventos: passa pelos objetos textarea e input e verifica se tem a classe "mostraTamanho"
	eventos: function(objeto) {
		if (objeto && objeto.tagName) {
			mostraTamanho.colocaEventos(objeto);
		} else {
			var campos = document.getElementsByTagName('textarea');
			for (var i=0; i<campos.length; i++) if (temClasse(campos[i], 'mostraTamanho')) mostraTamanho.colocaEventos(campos[i]);
			var campos = document.getElementsByTagName('input');
			for (var i=0; i<campos.length; i++) if (temClasse(campos[i], 'mostraTamanho')) mostraTamanho.colocaEventos(campos[i]);
		}
	},
	
	// método colocaEventos: coloca os tratadores de evento para calcular o tamanho e já verifica o tamanho do campo
	colocaEventos: function(objeto) {
		colocaEvent(objeto, 'keyup', mostraTamanho.calcula);
		colocaEvent(objeto, 'change', mostraTamanho.calcula);
		mostraTamanho.calcula(objeto);
	},
	
	// método calcula: verifica a quantidade de caracteres digitados. Mostra e limita essa quantidade.
	calcula: function(elem) {
		if (!elem || !elem.tagName) var elem = this;
		var tamanho = elem.value.length;
		var maximo = elem.getAttribute('maximo');
		if (!maximo) maximo = 4000;
		if (tamanho > maximo) {
			elem.value = elem.value.substring(0, maximo);
			tamanho = maximo;
		}
		var areaTexto = obj(elem.id + '_tamanho');
		if (!areaTexto) {
			var areaTexto = elem.parentNode.insertBefore(cria('div', { id: elem.id + '_tamanho', className: 'tamanhoTexto' }), elem.nextSibling);					
			areaTexto.style.top = elem.offsetTop + elem.offsetHeight;
			areaTexto.style.left = elem.offsetLeft;
		} else limpaConteudo(areaTexto);
		//se existe o atributo tamanho e máximo no elemento é a tradução da palavra tamanho e máximo
		//utilizados pela página cont_acomp, então usa essas traduções, caso não exista, coloca em português
		txt_tamanho = (elem.getAttribute('tamanho')) ? elem.getAttribute('tamanho') : 'tamanho';
		txt_maximo = (elem.getAttribute('max')) ? elem.getAttribute('max') : 'max';
		var txt = areaTexto.appendChild(cria('txt', txt_tamanho +  ': ' + tamanho + ' (' +  txt_maximo + ' ' +   maximo + ')'));
	}
};
colocaEvent(window, 'load', mostraTamanho.eventos);

// transforma decimal em hora:minuto (hh:mm)
// *****************************************************************************************************

function dec_hor(numdec) {
	numdec = numdec.toString();
	if (numdec.length == 0) return '';
	numdec = numdec.replace(/,/g,'.');
	var pos = numdec.indexOf('.');
	if (pos < 1) return numdec + ':00';
	var hh = numdec.substring(0,pos);
	if (hh.length == 0) hh = '0';
	var mm = numdec.substring(pos+1,numdec.length) + '00';
	mm = parseInt(mm.substring(0,2));
	mm = Math.round(60 * mm / 100) + '00';
	var hhmm = hh  + ':' + mm.substring(0,2);
	return hhmm;
}
// *****************************************************************************************************


// abre e fecha as colunas
//*****************************************************************************************************
function coluna(num,menu) {
	if (menu>0) {nome = 'menu'} else {nome = 'dir'}
	colunas = document.getElementsByTagName('tr');
	for (i=0;i<colunas.length;i++)	{
		if (colunas[i].id.indexOf('col'+nome)>=0)	{ colunas[i].style.display = 'none'; }
		if (colunas[i].id == ('col'+nome+num))	{ colunas[i].style.display = ''; }
	}
	as = document.getElementsByTagName('a');
	for (i=0;i<as.length;i++)	{
		if (as[i].id.indexOf('acol'+nome)>=0)	{ as[i].style.display = ''; }
		if (as[i].id == ('acol'+nome+num))	{ as[i].style.display = 'none'; }
	}
	divs = document.getElementsByTagName('div');
	for (i=0;i<divs.length;i++)	{
		if (divs[i].id.indexOf('divcol'+nome)>=0)	{ divs[i].style.display = 'none'; }
		if (divs[i].id == ('divcol'+nome+num))	{ divs[i].style.display = ''; }
	}
}
//*****************************************************************************************************


// mudaPagina levando os parametros
//*****************************************************************************************************
function mudaPag(parametros) {	
	path = location.href.substring(0,location.href.indexOf('.asp')+4);
	//retirar...
	//quais = ""
	//imagens = document.getElementsByTagName('img');
	//for (i=0; i< imagens.length; i++) {
	//	img = imagens[i].id;
	//	if (imagens[i].src.indexOf('2.gif') >= 0 && img.length > 3 && img.indexOf("img") >= 0) 
	//		quais += img.substring(3,img.length) + ",";
	//}	
	var ref = parametros;
	//if (ref.indexOf('abertos=') < 0) ref += "&abertos=" + quais.substring(0,quais.length-1);
	ref += '&abertos=' + menu.abertos();
	
	if (ref.indexOf('plsid=') < 0) {
		var plsid = location.search.split('plsid=');
		if (plsid.length > 1) ref += '&plsid=' + plsid[1].split('&')[0];
	}
	window.location.href = path + "?" + ref;
}
//*****************************************************************************************************




// funcoes para a combo que é substituída por uma caixa de texto
//****************************************************************************************************
function tiraLista(qual, sel) {
	qual.value = sel;
	qual.style.display = 'none';
	document.all('novo'+qual.name).style.display = '';
	document.all('qual'+qual.name).value = 1;
}

function voltaLista(qual) {
	document.all(qual).style.display = '';
	document.all('novo'+qual).style.display = 'none';
	document.all('qual'+qual).value = 0;
}
//****************************************************************************************************




// funcao para abrir uma nova instância do browser
//*****************************************************************************************************
function novaJanela(url, largura, altura) {
	var parametros = 'toolbar=no,location=no,status=no,menubar=no,scrollbars=no,resizable=no,width=' + largura + ',height=' + altura;
	var janela = window.open(url, '', parametros);
}
//*****************************************************************************************************




// funcao para abrir uma nova instância do browser para impressao do conteudo
//*****************************************************************************************************
function impressao(url) {
	janela = window.open(url,'','toolbar=no,location=no,status=no,menubar=no,scrollbars=yes,resizable=no,width=600,height=500');
}
//*************************************************************************************************




// Formata números com separação de milhar (.) e dois algarismos após a vírgula.
// Recebe parâmetro numérico e retorna String.
//*************************************************************************************************
function formataNumero(num,sepMilhar,casas) {
	if (num == undefined || num == null) return '';
	if (sepMilhar == null || sepMilhar == undefined) sepMilhar = '.';
	if (casas == null || casas == undefined) casas = 2;
	var mult = Math.pow(10,casas);
	var zeros = '';
	for (var i=0; i<casas; i++) zeros += '0';
	
	if (num.toString().length > 0) {
		num = (Math.round(num.toString().replace(',','.')*mult)/mult).toString();
		num += (num.indexOf('.') > 0) ? zeros : '.' + zeros;
		if (casas > 0) casas++;
		num = num.substring(0,num.indexOf('.')+casas).replace('.',',');
				
		if (sepMilhar) {
			var inv = num.split('').reverse().join('');
			num = inv.substring(0,casas);
			for (var i=0; i<inv.length-casas; i++) {
				num += inv.charAt(i+casas);
				if (i%3 == 2 && i<inv.length-casas-1) num += sepMilhar;
			}
			num = num.split('').reverse().join('');
		}
	}
	return num;
}
//*************************************************************************************************




// Formata números como dinheiro (usando separador de milhar e duas casas decimais
//*************************************************************************************************
function formataDinheiro(valor) {
	return formataNumero(valor,'.',2);
}
//*************************************************************************************************



// Formata datas para dd/mm/yy, utilizando a função valida_data.
// se não tiver sep, não retorna a hora
// se tiver sep e a data enviada for completa, retorna DD/MM/YY hh:mm, com sep separando a data do horário
//*************************************************************************************************
function formataData(dt, sep, anomesdia) {
	var datahora = dt.split(' ');
	dt = datahora[0];
	var hora = (datahora.length > 1) ? datahora[1] : '';
	
	if (anomesdia) dt = dt.replace(/[\.\\\-]/g,'/').split('/').reverse().join('/');
	dt = valida_data(dt);
	if (dt.length == 0 || dt == -1) {	
		return dt
	} else {
		dt[0] = '00' + dt[0].toString(); dt[0] = dt[0].substring(dt[0].length-2,dt[0].length);
		dt[1] = '00' + dt[1].toString(); dt[1] = dt[1].substring(dt[1].length-2,dt[1].length);
		dt[2] = dt[2].toString(); dt[2] = dt[2].substring(dt[2].length-2,dt[2].length);
		var novadata = dt[0] + '/' + dt[1] + '/' + dt[2];
		dt = novadata;
	}
	
	if (hora.length > 0 && sep) {
		dt += sep + hora.substring(0,5);
	}
	
	return dt;
}
//*************************************************************************************************



// verifica se uma data é uma data válida.
// se for válida, retorna um array com dia, mes, ano
// senão retorna vazio se for vazia ou -1 se for inválida
//*************************************************************************************************
function valida_data(dt) {
	if (dt && dt.length > 0) {
		dt = dt.replace(/[\.\\\-]/g,'/');
		dt = dt.split('/');
		if (dt.length < 2) { datavalida = 0 } else {
			datavalida = 1;
			if (dt.length == 2 || dt[2].length == 0) { dtano = new Date(); dt[2] = dtano.getFullYear(); }
			if (dt.length != 3) { datavalida = 0 } else {
				dt[0] = Number(dt[0]); dt[1] = Number(dt[1]); dt[2] = Number(dt[2]);
				if (dt[2] < 0 || dt[2] > 3000 || isNaN(dt[2])) { datavalida = 0 } else {
					if (dt[1] < 1 || dt[1] > 12 || isNaN(dt[1])) { datavalida = 0 } else {
						var dias = [31,28,31,30,31,30,31,31,30,31,30,31];
						diasdomes = dias[dt[1]-1];
						if (dt[1] == 2 && (dt[2]%400 == 0 || (dt[2]%4 == 0 && dt[2]%100 != 0))) diasdomes = 29;
						if (dt[0] < 1 || dt[0] > diasdomes || isNaN(dt[0])) { datavalida = 0 }
					}
				}
			}
		}
		if (datavalida == 1) {
			if (dt[2] < 40) { dt[2] += 2000 } else { if (dt[2] < 100) { dt[2] += 1900 } }
			return dt
		} else { return -1 }
	} else { return '' }
}
//*************************************************************************************************




// converte a data de um valor calculado (12*ano+mes) para um formato com mês e ano
// o parâmetro "formato" é composto por:
//		- letras "m" indicando a quantidade de algarismos do mês ou letras "M" indicando a quantidade de letras do mês por extenso (se for só um "M" é o nome do mês inteiro)
//		- separador a ser usado entre mês e ano (o separador não deve conter "m", "M" ou "a")
//		- letras "a" indicando a quantidade de algarismos do ano
//		Obs: também pode ser solicitado no formato apenas o mês ou o ano (neste caso o separador é ignorado)
//		Exemplos:	"mm/aa" = 02/10 (padrão, se não for informado o formato)
//					"MMM, aaaa" = fev, 2010
//					"M-aaaa" = fevereiro-2010
//					", de aaaa" = 2010
//*************************************************************************************************
function convDataCalc(dtCalc, formato) {
	if (dtCalc.length == 0) return '';
	dtCalc = parseInt(dtCalc);
	if (isNaN(dtCalc)) return '';
	if (!formato || formato.length == 0) var formato = 'mm/aa';
	
	var ano = Math.floor(dtCalc / 12);
	var mes = dtCalc - (12 * ano);
	
	var separador = formato.replace(/[mMa]/gi, '');
	var formaMes = formato.split(separador)[0];
	var formaAno = formato.split(separador)[1];
	
	if (formaMes.length > 0) {
		var tipoMes = formaMes.substring(0,1);
		if (tipoMes == 'M') {
			mes = calend.meses[mes];
			if (formaMes.length > 1) mes = mes.substring(0, formaMes.length);
		} else {
			var zeros = '0';
			for (var i=0; i<formaMes.length; i++) zeros += '0';
			mes = mes + 1; // porque o mês que vem do cálculo vai de 0 a 11, então para mostrar o número tem que somar 1
			mes = zeros + mes.toString();
			mes = mes.substring(mes.length - formaMes.length);
		}
	}
	
	ano = ano.toString();
	if (formaAno.length > 0) ano = ano.substring(ano.length - formaAno.length);
	
	var dataTxt = ''
	if (formaMes.length > 0) dataTxt += mes;
	if (formaMes.length > 0 && formaAno.length > 0) dataTxt += separador;
	if (formaAno.length > 0) dataTxt += ano;
	return dataTxt;
}
//*************************************************************************************************



// funcões para o menu
// ************************************************************************************************
	function MM_reloadPage(init) {  //reloads the window if Nav4 resized
		if (init==true) with (navigator) {if ((appName=="Netscape")&&(parseInt(appVersion)==4)) {
			document.MM_pgW=innerWidth; document.MM_pgH=innerHeight; onresize=MM_reloadPage; }}
		else if (innerWidth!=document.MM_pgW || innerHeight!=document.MM_pgH) location.reload();
	}
	MM_reloadPage(true);
	
	function MM_findObj(n, d) { //v4.01
		var p,i,x;  if(!d) d=document; if((p=n.indexOf("?"))>0&&parent.frames.length) {
			d=parent.frames[n.substring(p+1)].document; n=n.substring(0,p);}
		if(!(x=d[n])&&d.all) x=d.all[n]; for (i=0;!x&&i<d.forms.length;i++) x=d.forms[i][n];
		for(i=0;!x&&d.layers&&i<d.layers.length;i++) x=MM_findObj(n,d.layers[i].document);
		if(!x && d.getElementById) x=d.getElementById(n); return x;
	}
	
	function MM_showHideLayers() { //v6.0
		var i,p,v,obj,args=MM_showHideLayers.arguments;
		for (i=0; i<(args.length-2); i+=3) if ((obj=MM_findObj(args[i]))!=null) { v=args[i+2];
			if (obj.style) { obj=obj.style; v=(v=='show')?'visible':(v=='hide')?'hidden':v; }
			obj.visibility=v; }
		selfiltros();
	}
	
	function MM_preloadImages() { //v3.0
		var d=document; if(d.images){ if(!d.MM_p) d.MM_p=new Array();
			var i,j=d.MM_p.length,a=MM_preloadImages.arguments; for(i=0; i<a.length; i++)
			if (a[i].indexOf("#")!=0){ d.MM_p[j]=new Image; d.MM_p[j++].src=a[i];}}
	}
	
	function MM_swapImgRestore() { //v3.0
		var i,x,a=document.MM_sr; for(i=0;a&&i<a.length&&(x=a[i])&&x.oSrc;i++) x.src=x.oSrc;
	}
	
	function MM_swapImage() { //v3.0
		var i,j=0,x,a=MM_swapImage.arguments; document.MM_sr=new Array; for(i=0;i<(a.length-2);i+=3)
		 if ((x=MM_findObj(a[i]))!=null){document.MM_sr[j++]=x; if(!x.oSrc) x.oSrc=x.src; x.src=a[i+2];}
	}
	
	function selfiltros() {
		txt = (window.event.type == 'mouseover') ? 'hidden' : '';
		sel = document.getElementsByTagName('SELECT');
		for (i=0; i<sel.length; i++) {
			if (sel[i].name.substring(0,7) == 'ftvalue') sel[i].style.visibility = txt;
		}
	}
//*****************************************************************************************************

// ********** função para a ordenação (algoritmo quicksort) **********
// origem = uma array linear
// limMin = 0
// limMax = array.length
// col = indice da coluna pelo qual será ordenado
function troca (arei, a, b) {
	temp = arei[a];
	arei[a] = arei[b];
	arei[b] = temp;
}

function quicksort(origem, limMin, limMax, col) {
	var pivo, corteInf, corteSup;
	// dois itens para ordenar
	if (limMax - limMin == 1) {
		if (origem[limMin][col] > origem[limMax][col]) troca(origem, limMin, limMax);
		return;
	}

//	// três ou mais itens para ordenar
	pivo = origem[parseInt((limMin + limMax) / 2)][col];
	origem[parseInt((limMin + limMax) / 2)][col] = origem[limMin][col];
	origem[limMin][col] = pivo;
	corteInf = limMin + 1;
	corteSup = limMax;

	do {
		while (corteInf <= corteSup && origem[corteInf][col] <= pivo) corteInf++; // encontra o corteInf
		while (origem[corteSup][col] > pivo) corteSup--; // encontra o corteSup
		if (corteInf < corteSup) troca(origem, corteInf, corteSup);
	} while (corteInf < corteSup);

	origem[limMin][col] = origem[corteSup][col];
	origem[corteSup][col] = pivo;

	// 2 ou mais itens na primeira sessão
	if (limMin < corteSup - 1) quicksort(origem, limMin, corteSup - 1, col);
	// 2 ou mais itens na segunda sessão
	if (corteSup + 1 < limMax) quicksort(origem, corteSup + 1, limMax, col);
}





// Só deixa digitar valor numérico 0-9.
// se não for numérico retorna false.
function sonum(e) {
	var tecla;
	if (!e) var e = window.event;
	tecla = e.keyCode || e.which;
	if (!tecla) return true;
	if ( 
			(tecla >= 48 && tecla <= 57) || 
			(tecla >= 96 && tecla < 106) || 
			(tecla == 109 ) || (tecla == 189) ||
			(tecla == 8) || 
			(tecla == 46) || 
			(tecla >= 37 && tecla <= 40) || 
			(tecla == 188) || (tecla == 110) ||
			(tecla == 9)
		) return true;
		
	var elemento = origemEvento('input', e);
	if(elemento.deixarDigitar == 'hora') {
		if (tecla == 191) return true;
	}
	
	return false;
}

// Só deixa digitar valor numérico (0 a 9)
// ou outro(s) caracter(es) que estiver(em) no atributo "pode" do objeto
// função colocada no keyup, para tirar o caracter depois de digitado
function tiraNaoNum(e) {
	if (!e) var e = window.event;
	var elem = (e.srcElement) ? e.srcElement : e.target;
	if (elem.value.length == 0) return;
	var digitos = elem.value.split('');
	// monta a lista de caracteres possíveis: números + os que estão no atributo "pode"
	var possiveis = '0123456789'.split('');
	var pode = elem.getAttribute('pode');
	var caracteres = (pode.length > 0) ? pode.split('') : [];
	for (var i=0; i<caracteres.length; i++) possiveis.push(caracteres[i]);
	// se algum digito do campo nao esta entre os possiveis, tira
	//var valorFinal = '';
	for (var i=0; i<digitos.length; i++) {
		var podeTer = false;
		for (var j=0; j<possiveis.length; j++) {
			if (digitos[i] == possiveis[j]) {
				podeTer = true;
				break;
			}
		}
		if (!podeTer) {
			digitos.splice(i,1);
			i--;
			elem.value = digitos.join('');
		}
	}
	//elem.value = valorFinal;
}

// transforma uma string em numérico inteiro
//*************************************************************************************************
function strInt(num) {
	num = num.toString();
	if (num.length == 0) return 0;
	return parseInt(num.replace(/^0/g,''));
}
//*************************************************************************************************

// retorna um valor inteiro com o cálculo absoluto da data:
// a data deve ser dia/mes/ano
// 31*12*ano + 31*mes + dia (se o parâmetro de precisao for 'dia')
// 12*ano + mes (se o parâmetro de precisao for 'mes' - ou vazio)
//*************************************************************************************************
function dataCalc(dt, precisao) {
	if (dt.length < 3) return '';
	try { dt = dt.replace(/[\.\\\-]/g,'/'); } catch(e) { alert(e + ', dt = ' + dt); }
	var areiData = dt.split('/');
	if (areiData[2].length == 2) areiData[2] = '20' + areiData[2];
	
	var calc = (precisao == 'dia') ? (31*12*strInt(areiData[2]) + 31*strInt(areiData[1]) + strInt(areiData[0])) : (12*strInt(areiData[2]) + strInt(areiData[1]));
	return calc;
}
//*************************************************************************************************

// retorna uma data (dia/mes/ano) baseada em um número inteiro que representa 31*12*ano + 31*mes + dia
//*************************************************************************************************
function dataDesCalcDia(num) {
	if (num == 0) return '';
	var ano = Math.floor(num / 12 / 31);
	var mes = num - (12 * 31 * ano);
	mes = Math.floor(mes / 31);
	var dia = num - (12 * 31 * ano) - (31 * mes);
	ano = ano.toString();
	ano = ano.substring(ano.length - 2);
	mes = mes.toString();
	mes = '0' + mes;
	mes = mes.substring(mes.length - 2);
	dia = dia.toString();
	dia = '0' + dia;
	dia = dia.substring(dia.length - 2);
	return formataData(dia + '/' + mes + '/' + ano);
}


//*************************************************************************************************

// retorna uma data (dia/mes/ano) baseada em um número inteiro que representa 12*ano + mes
//*************************************************************************************************
function dataDesCalcMes(num) {
	if (num == 0) return '';
	var ano = Math.floor(num / 12);
	var mes = num - (12 * ano);
	ano = ano.toString();
	ano = ano.substring(ano.length - 2);
	mes = mes.toString();
	mes = '0' + mes;
	mes = mes.substring(mes.length - 2);
	return formataData(mes + '/' + ano);
}
//*************************************************************************************************

// Formata datas como SQL aaaa-mm-dd, a partir de um objeto Date.
//*************************************************************************************************
function dataSQL(dt) {
	var dia = '00' + dt.getDate().toString();
	var mes = '00' + (dt.getMonth()+1).toString();
	var ano = dt.getFullYear().toString();
	return ano + '-' + mes.substr(mes.length-2,2) + '-' + dia.substr(dia.length-2,2);
}
//*************************************************************************************************

// Formata datas como dd/mm/aa, a partir de um objeto Date.
// se tiver o parâmetro separadorHora, coloca as horas e minutos separando da data pelo parâmetro
//*************************************************************************************************
function dataDMA(dt, separadorHora) {
	var dia = '00' + dt.getDate().toString();
	var mes = '00' + (dt.getMonth()+1).toString();
	var ano = dt.getFullYear().toString();
	var data = dia.substr(dia.length-2, 2) + '/' + mes.substr(mes.length-2, 2) + '/' + ano.substr(ano.length-2, 2);
	
	if (separadorHora) {
		var hora = '00' + dt.getHours().toString();
		var min = '00' + dt.getMinutes().toString();
		data += separadorHora + hora.substr(hora.length-2, 2) + ':' + min.substr(min.length-2, 2)
	}
	
	return data
}
//*************************************************************************************************

// cria um objeto Date a partir de uma string com dd/mm/aa.
//*************************************************************************************************
function dmaDate(dt) {
	if (dt.length < 3) return '';
	try { dt = dt.replace(/[\.\\\-]/g,'/'); } catch(e) { alert(e + ', dt = ' + dt); }
	var areiData = dt.split('/');
	return new Date(areiData[2], areiData[1]-1, areiData[0]);
}
//*************************************************************************************************

// Formata datas como dd/mm/aa, a partir de uma data em formato YYYY-MM-DD.
//*************************************************************************************************
function dataSQL_DMA(dt) {
	if (dt.length > 0) dt = dt.substr(8,2) + '/' + dt.substr(5,2) + '/' + dt.substr(2,2);
	return dt
}
//*************************************************************************************************

// Formata datas como dd/mm/aa, a partir de um objeto com as propriedades dia, mes e ano.
//*************************************************************************************************
function dataOBJ_DMA(dt) {
	var dia = '00' + dt.dia.toString();
	var mes = '00' + dt.mes.toString();
	var ano = dt.ano.toString();
	return dia.substr(dia.length-2,2) + '/' + mes.substr(mes.length-2,2) + '/' +
		ano.substr(ano.length-2,2);
}
//*************************************************************************************************




// Transforma um texto em numérico (só para inteiros), tirando os zeros da frente
//*************************************************************************************************
function txtToInt(txtNumerico) {
	return parseInt(txtNumerico.replace(/^0/,''));
}
//*************************************************************************************************




// Formata um cnpj de só números para 000.000.000/0000-00
//*************************************************************************************************
function formataCNPJ(num) {
	num = '000000000000000' + num;
	num = num.substring(num.length-15,num.length);
	num = num.substring(0,3) + '.' + num.substring(3,6) + '.' + num.substring(6,9) + '/' + 
		num.substring(9,13) + '-' + num.substring(13,15);
	return num;
}
//*************************************************************************************************




// cria (ou altera) um cookie
//*************************************************************************************************
function criaCookie(nome, valor, tempoDias) {
	if (tempoDias) {
		var data = new Date();
		data.setTime(data.getTime() + (tempoDias*24*60*60*1000));
		var expira = "; expires=" + data.toGMTString();
	}
	else var expira = "";
	document.cookie = nome + "=" + valor + expira + "; path=/";
}
//*************************************************************************************************




// lê um cookie
//*************************************************************************************************
function leCookie(nome) {
	var nomeEQ = nome + "=";
	var cada = document.cookie.split(';');
	for(var i=0; i < cada.length; i++) {
		var c = cada[i];
		while (c.charAt(0) == ' ') c = c.substring(1,c.length);
		if (c.indexOf(nomeEQ) == 0) return c.substring(nomeEQ.length,c.length);
	}
	return null;
}
//*************************************************************************************************




// apaga um cookie
//*************************************************************************************************
function apagaCookie(nome) {
	criaCookie(nome, "", -1);
}
//*************************************************************************************************

// abre uma janela com os dados do setup
//*************************************************************************************************
function abreSetup(idemp,plsid,mostraFinanceiro) {
	parametros = 'toolbar=yes,location=yes,status=no,menubar=yes,scrollbars=yes,resizable=yes,';
	parametros += 'width=600,height=510,top=30,left=30';
	url = '../interno/setup.asp?idemp=' + idemp + '&plsid=' + plsid + '&mostraFinanceiro=' + mostraFinanceiro;
	janela = window.open(url,'',parametros);
}
//*************************************************************************************************


//*************************************************************************************************



	
// cria as options de um select
//*************************************************************************************************
function criaSelect(elem, arei, ref) {
	for (var i = 0; i<arei.length; i++) {
		var opt = document.createElement('OPTION');
		opt.value = arei[i].id; opt.text = arei[i].nome;
		if (opt.value == ref) opt.selected = true;
		try {
			elem.add(opt, null); // browsers que seguem o padrão W3C - objetoSelect.add(objetoOptionNovo, objetoOptionExistente)
		} catch(exececao) {
			elem.add(opt); // IE - objetoSelect.add(objetoOptionNovo)
		}
	}
}
//*************************************************************************************************


	
// cria as options de um select a partir dos resultados vindo do Ajax (split('|'))
//*************************************************************************************************
    function preencheSelect(arei,sel,referencia,emBranco) {
		var inicial = 0;
        if (emBranco) {
			newOption(sel, 0, '', '');
			inicial++;
		}
        for (var i=0; i<arei.length; i++) {
            var val = arei[i].split('|');
			var opt = newOption(sel, inicial + i, val[1], val[0]);
            if (val[0] == referencia) opt.selected = true;
        }
    }
//*************************************************************************************************


	
// descobre a posição do elemento (retorna .left e .top)
//*************************************************************************************************
function getElementPosition(elem) {
	var offsetTrail = elem;
	var offsetLeft = 0;
	var offsetTop = 0;
	while (offsetTrail) {
		offsetLeft += offsetTrail.offsetLeft;
		offsetTop += offsetTrail.offsetTop;
		offsetTrail = offsetTrail.offsetParent;
	}
	if (navigator.userAgent.indexOf("Mac") != -1 && 
		typeof document.body.leftMargin != "undefined") {
		offsetLeft += document.body.leftMargin;
		offsetTop += document.body.topMargin;
	}
	return {left:offsetLeft, top:offsetTop};
}
//*************************************************************************************************

// recupera o elemento onde aconteceu o evento e sobe no DOM até o "tag"
// tag -> primeira tag que deseja localizar ev -> o evento que realizou a chamada da função
// *************************************************************************************************
function origemEvento(tag, ev) {
	if (ev && ev.tagName) {
		// se o que foi passado no lugar no evento é um elemento:
		// se a tag do elemento passado é a própria tag solicitada, retorna o elemento
		// senão retorna o primeiro pai dele com a tag informada
		if (ev.tagName == tag) return ev;
		else return sobeDOM(ev, tag);
	} else {
		// se não foi passado nenhum parâmetro de evento (IE < 8), retorna o objeto evento do window
		if (!ev) ev = window.event;
		// se não tem objeto evento nem na window, não retorna nada
		if (!ev) return null;
		// encontra o elemento que gerou o evento (IE: srcElement, outros browsers: target)
		var evorigem = ev.srcElement || ev.target;
	}
	// sobe pela hieraquia DOM até encoontrar o primeiro pai do elemento clicado com a tag que foi informada
	return sobeDOM(evorigem, tag);
}
// *************************************************************************************************


// *************************************************************************************************
// funções para colocar e tirar eventos de um objeto
// criado por John Resig (http://ejohn.org/projects/flexible-javascript-events/)
// e melhorada em http://www.quirksmode.org/blog/archives/2005/10/_and_the_winner_1.html
// alterados os nomes para não dar conflito com Mootools em 23/09/2009 (Sergio) - era addEvent e removeEvent
//
// realizadas alterações para incluir mouseenter e mouseleave cross-browser (Sergio - janeiro/2010)
// ** baseado em http://blog.stchur.com/2007/03/15/mouseenter-and-mouseleave-events-for-firefox-and-other-non-ie-browsers/
// *************************************************************************************************
function colocaEvent( obj, type, fn ) {
	if (obj.addEventListener) {
		if (type === 'mouseenter') obj.addEventListener( 'mouseover', evento_fazFuncao(fn), false );
		else if (type === 'mouseleave') obj.addEventListener( 'mouseout', evento_fazFuncao(fn), false );
		else obj.addEventListener( type, fn, false );
	} else if (obj.attachEvent) {
		obj["e"+type+fn] = fn;
		obj[type+fn] = function(){ obj["e"+type+fn]( window.event ); }
		obj.attachEvent( "on"+type, obj[type+fn] );
	}
}

function tiraEvent( obj, type, fn ) {
	try {
		if (obj.removeEventListener)
			obj.removeEventListener( type, fn, false );
		else if (obj.detachEvent) {
			obj.detachEvent( "on"+type, obj[type+fn] );
			obj[type+fn] = null;
			obj["e"+type+fn] = null;
		}
	} catch(e) {}
}

function evento_fazFuncao(fn) {
	return function(evt) {
		var relTarget = evt.relatedTarget;
		if (this === relTarget || evento_ehFilhoDe(this, relTarget)) return;
		fn.call(this, evt);
	}
}

function evento_ehFilhoDe(pai, filho) {
   if (pai === filho) return false;
   while (filho && filho !== pai) try { filho = filho.parentNode; } catch(e) { break; }
   return filho === pai;
}
// *************************************************************************************************



// *************************************************************************************************
// funções para habilitar ou desabilitar botões (ícones - imagens)
// a classe "desabilitado" deixa a imagem transparente (40%)
// *************************************************************************************************
function desabilitaBot(botao) {
	//alert(botao.tagName);
	if (!botao || !botao.tagName) return;
	if (botao.onclick) botao.old_onclick = botao.onclick;
	botao.onclick = null;	
	if (botao.onmousedown) botao.old_onmousedown = botao.onmousedown;
	botao.onmousedown = null;	
	if (botao.onmouseup) botao.old_onmouseup = botao.onmouseup;
	botao.onmouseup = null;
	if (botao.alt) botao.old_alt = botao.alt;
	botao.alt = '';
	if (botao.title) botao.old_title = botao.title;
	botao.title = '';
	colocaClasse(botao, 'desabilitado');
	botao.style.cursor = 'default';
	if (botao.getAttribute("calendario") == '1') tiraEvent(botao,'click',calend.novo);
}

function habilitaBot(botao) {
	if (!botao || !botao.tagName) return;
	tiraClasse(botao, 'desabilitado');
	if (botao.old_onclick) botao.onclick = eval(botao.old_onclick);
	if (botao.old_onmousedown) botao.onmousedown = eval(botao.old_onmousedown);
	if (botao.old_onmouseup) botao.onmouseup = eval(botao.old_onmouseup);
	if (botao.old_alt) botao.alt = botao.old_alt;
	if (botao.old_title) botao.title = botao.old_title;
	botao.style.cursor = 'pointer';
	if (botao.getAttribute("calendario") == '1') colocaEvent(botao,'click',calend.novo);
}
// *************************************************************************************************



// *************************************************************************************************
// funções para criar e trabalhar com elementos do DOM
// *************************************************************************************************
// encontra o elemento "id" na página
function obj(id) {
	return document.getElementById(id);
}

// exclui um elemento do DOM
function removeObj(obj) {
	if (obj && obj.parentNode) obj.parentNode.removeChild(obj);
}

// exclui todos os filhos de um objeto (exceto os elementos no array "exceto", se existir)
function limpaConteudo(obj, exceto) {
	if(!obj || !obj.childNodes) return;
	var filhos = obj.childNodes;
	for (var i=filhos.length-1; i>=0; i--) {
		var tira = true;
		if (exceto) {
			for (var j=0; j<exceto.length; j++) {
				if (filhos[i] == exceto[j]) {
					tira = false;
					break;
				}
			}
		}
		if (tira) removeObj(filhos[i]);
	}
}

// sobe na hierarquia do DOM desde o elemento "elem" até o elemento com a tag "tag"
function sobeDOM(elem, tag) {
	while (elem.tagName && elem.tagName.toUpperCase() != tag.toUpperCase()) elem = elem.parentNode;
	if (elem.tagName) return elem;
	else return false;
}

// cria um elemento DOM com propriedades e estilos parametrizáveis
// tag: a tag do elemento em string (se for 'txt' vai criar um textNode com o texto do segundo argumento)
// prop: array associativo com as propriedades (atributos)
// estilo: array associativo com os estilos
// txt: para incluir no objeto criado um nó de texto
function cria(tag, prop, estilo, txt) {
		if (tag == 'txt') return document.createTextNode(prop);
		var elem = document.createElement(tag);
		// atributos que podem ser incluídos direto como em HTML (elemento[nomeAtributo] = valorAtributo)
		var atributosHTML = '| className | colSpan | rowSpan | border | innerHTML | text |';
		// outros atributos são incluídos pelo método "setAttribute"
		if (prop) for (var i in prop) {
			if (atributosHTML.indexOf(i) > 0) elem[i] = prop[i];
			else elem.setAttribute(i, prop[i]);
		}
		if (estilo) for (var i in estilo) elem.style[i] = estilo[i];
		if (txt !== undefined && txt !== false && txt !== null) elem.appendChild(document.createTextNode(txt));
		return elem;
}
// *************************************************************************************************


 // aplica a função cancelBubble (para de propagar pelos elementos DOM acima) para todos browsers
function paraPropag(ev) {
	if (window.event) {
		// IE
		window.event.cancelBubble = true;
	} else {
		if (ev) ev.stopPropagation();
	}
	return;
}
// ******************************************************************************************************


// ******************************************************************************************************
// ********** funções para manipular as classes de um elemento
// ********** colocaClasse: inclui uma classe ao elemento
// ********** tiraClasse: exclui uma classe do elemento
// ********** temClasse: testa se o elemento possui uma classe. Retorna true ou false
// ******************************************************************************************************
function colocaClasse(elem, classe) {
	elem.className +=  ' ' + classe;
}

function tiraClasse(elem, classe) {
	var objClasse = new RegExp('\\b' + classe + '\\b','gi');
	if (elem && elem.className) elem.className = elem.className.replace(objClasse,'');
}

function temClasse(elem, classe) {
	if (!elem) return false;
	if (!elem.className) return false;
	return (elem.className.indexOf(classe) >= 0);
}
// ******************************************************************************************************



// ******************************************************************************************************
// função para pegar a posição do mouse em relação à tela do browser (cross-browser)
// baseado em http://www.quirksmode.org/js/events_properties.html
function mousePos(e) {
	var posx = 0;
	var posy = 0;
	if (!e) var e = window.event;
	if (e.pageX || e.pageY) {
		posx = e.pageX;
		posy = e.pageY;
	} else if (e.clientX || e.clientY) {
		posx = e.clientX + document.body.scrollLeft + document.documentElement.scrollLeft;
		posy = e.clientY + document.body.scrollTop + document.documentElement.scrollTop;
	}
	return {left: posx, top: posy};
}
// ******************************************************************************************************


//*****************************************************************************************************
// ** função genérica para limpar filtros
 // ** parâmetro excecoes: array contendo o valor para o ftvalue
function limpfiltro() {
    var forms = document.getElementsByTagName('form');
	var formFiltro;
	for (var i=0; i<forms.length; i++) {
		if (forms[i].name == 'filtros') {
			formFiltro = forms[i];
			break;
		}
	}
	if (!formFiltro) return;
	
	// limpa os selects
    
    var selects = formFiltro.getElementsByTagName("select");
	for (j=0; j<selects.length; j++) {
		if (selects[j].selectedIndex > 0) {
		     
			selects[j].selectedIndex = 0;
			
		}
	}
	
	// limpa os inputs
    var inputs = formFiltro.getElementsByTagName("input");
	   
	for (i=0; i<inputs.length; i++) {
		if (inputs[i].value!='') {
				
			inputs[i].value='';
			
		}
	}
}
// ******************************************************************************************************


//*****************************************************************************************************
// ** função para gravar um log de acesso ao link dos recursos (via Ajax)
function logRec(e) {
	if (!e) var e = window.event;
	var clicado = e.target || e.srcElement;
	var idrec = clicado.getAttribute('idrec');
	var idestrutura = clicado.getAttribute('pag');
	var url = '../funcoes/log_fx.asp?id_estrutura=' + idestrutura + '&id_rec=' + idrec;
	var ajax = new cnx.carrega(url);
}
// ******************************************************************************************************


//*****************************************************************************************************
// ** função cross-browser (strict ou não) para pegar o tamanho da janela onde está o browser
// ** já desconsiderando as barras de scroll quando houver
// ** retorna .altura e .largura
function tamanhoTela() {
	var largura = 0, altura = 0;
	if ( typeof( window.innerWidth ) == 'number' ) {
		// outros browsers fora o IE
		largura = window.innerWidth;
		altura = window.innerHeight;
	} else if ( document.documentElement && ( document.documentElement.clientWidth || document.documentElement.clientHeight ) ) {
		// IE 6+ sem Strict
		largura = document.documentElement.clientWidth;
		altura = document.documentElement.clientHeight;
	} else if ( document.body && ( document.body.clientWidth || document.body.clientHeight ) ) {
		// IE < 6
		largura = document.body.clientWidth;
		altura = document.body.clientHeight;
	}
	return { largura: largura, altura: altura };
}
// ******************************************************************************************************


//******************************************************************************************************
// ** função cross-browser (strict ou não) para pegar o quanto já houve de scroll na página
// ** retorna .top e .left
// ** baseado em http://stackoverflow.com/questions/871399/cross-browser-method-for-detecting-the-scrolltop-of-the-browser-window
function quantScroll() {
    if (typeof pageYOffset != 'undefined') { // maioria dos browsers
        return { top: pageYOffset, left: pageXOffset }; 
    } else {
        var referencia = document.documentElement; // IE with doctype 
        var corpo = document.body; // IE 'quirks' 
        referencia = (referencia.clientHeight) ? referencia : corpo; 
        return { top: referencia.scrollTop, left: referencia.scrollLeft }; 
    }
}
//******************************************************************************************************


// ********** cria o método trim para strings **********************************************************************
// a função com dois replaces é mais rápida - http://blog.stevenlevithan.com/archives/faster-trim-javascript
// *******************************************************************************************************************
String.prototype.trim = function() {   
    // return this.replace( /^\s+|\s+$/g, "");
    return this.replace(/^\s\s*/, '').replace(/\s\s*$/, '');
}
// *******************************************************************************************************************



// ********** função responsavel em fechar windows ***********************************************************
// funcao utilizada para fechar janelas... quando colocamos direto na funcao COLOCAEVENT o "window.close" não
// funciona ele informa que não tem permissão. o firefox tem algumas propriedades definidas para segurança e 
// isso acaba bloqueando algumas ações
// *******************************************************************************************************************
function fechaJanela() {
	window.close();
}
// *******************************************************************************************************************



// ********** função para criar options em selects *****************************************************************
// 
// *******************************************************************************************************************
function newOption(sel, pos, text, value) {
	var isIE = (/\bmsie\b/i.test(navigator.userAgent) && document.all && !(/\bopera\b/i.test(navigator.userAgent)));
	if (isIE) {
		var opt = new Option(text, value);
		sel.add(opt, pos);
		return opt;
	} else {
		var length = sel.options.length;
		if (length > 0)
			for(var i = length; i > pos; i--)
				sel.options[i] = sel.options[i-1].cloneNode(true);
		sel.options[pos] = new Option(text, value);
		return sel.options[pos];
	}
}
// *******************************************************************************************************************



// ********** função cross-browser para pegar a altura total do documento ***********************************************************
// copiada de http://james.padolsey.com/javascript/get-document-height-cross-browser/
// **********************************************************************************************************************************
function alturaDocumento() {
    var corpo = document.body;
    var doc = document.documentElement;
    return Math.max(
        Math.max(corpo.scrollHeight, doc.scrollHeight),
        Math.max(corpo.offsetHeight, doc.offsetHeight),
        Math.max(corpo.clientHeight, doc.clientHeight)
    );
}
// **********************************************************************************************************************************



// ********** função insertAfter ****************************************************************************************************
// método de todos os elementos HTML (só é aplicado em páginas com DOCTYPE strict, senão o Element não existe)
// usar exatamente como o .insertBefore
// **********************************************************************************************************************************
//if (document.documentElement.clientHeight) { // se for Strict
//	Element.prototype.insertAfter = function(novoElemento, referencia) {
//		if (referencia.nextSibling) {
//			return this.insertBefore(novoElemento, referencia.nextSibling);
//		} else {
//			return this.appendChild(novoElemento);
//		}
//	}
//}
// **********************************************************************************************************************************



//**********função temporizador ****************************************************************************************************
//Essa função recebe um elemento que foi clicado e pega os seus atributos (função, tempo e parâmetros)
//É necessário também um objeto da página para atribuir o temporizador.
//starta um temporizador que após o atributo tempo do elemento manda para a função que é o atributo também do elemento.
//Quase os atributos do elemento devem existir para que a função funcione (função - função que será realizada após um determinado tempo
//																		   tempo - após ocorrer o evento e passar esse tempo é realizada a função
// 																		   parâmetros - é opcional e deve existir caso a função que será 
//																			realizada necessite de parâmetros para a sua execução.
//																			)

var temporizador = new Object();
temporizador.ini = function(e) {
	// localiza quem gerou o evento e pega os atributos função e temporizador para colocar um atraso na chamada da função 
	if (e && e.tagName) {
		var elemento = e;
	} else {
		if (!e) e = window.event;
		if (!e) return;
		var elemento = e.srcElement || e.target;
	}
	if (!elemento) return;
	var funcao = elemento.getAttribute('funcao');
	var tempo = elemento.getAttribute ('temporizador');
	if (!funcao || !tempo) return;
	// se houver parâmetros manda para a função.
	var parametros = elemento.getAttribute('parametros');
	if (!parametros) parametros = '';
	//temporizador.contador = null;
	clearTimeout(temporizador.contador);
	//temporizador.contador = setTimeout( function(){ eval(funcao)(elemento.getAttribute('parametros')) }, tempo);
	temporizador.contador = setTimeout( funcao + '(' + parametros + ')', tempo);
}

//**********************************************************************************************************************************



//*******************************************************************************************************************************************************************
// ** função que compacta uma string trocando as palavras mais frequentes por "ids" que são embutidos no início da string para posterior substituição
//*******************************************************************************************************************************************************************
function compactaPalavra(texto) {
	var sep = /#-#|\||\s|\.|\,/; // separadores entre as palavras = '#-#' ou '|' ou ' ' ou '.' ou ','
	var listaPalavras = texto.split(sep);
	
	// conta a frequencia em que aparece cada palavra (com mais de 4 carateres)
	var freqPalavras = {};
	for (var i=0; i<listaPalavras.length; i++) {
		if (listaPalavras[i].length > 4) {
			if (freqPalavras[listaPalavras[i]]) freqPalavras[listaPalavras[i]]++;
			else freqPalavras[listaPalavras[i]] = 1;
		}
	}
	
	// monta a lista de "ids" de substituicao para cada palavra que repetir mais de cinco vezes
	var listaSubstitu = {};
	var cont = 1;
	for (var i in freqPalavras) if (freqPalavras[i] > 5) listaSubstitu['#' + (cont++) + '#'] = i;
	
	// troca os textos pelos "ids"
	var compactado = texto;
	for (var i in listaSubstitu) {
		var regular = new RegExp(listaSubstitu[i], 'g');
		compactado = compactado.replace(regular, i);
	}
	
	// coloca a lista de substituicao no inicio do texto final compactado
	var listaFinal = [];
	for (var i in listaSubstitu) listaFinal.push(i + ': ' + listaSubstitu[i]);
	compactado = listaFinal.join('|') + '#substituicao#' + compactado;
	
	// retorna o texto compactado
	return compactado;
}
//*******************************************************************************************************************************************************************



//*******************************************************************************************************************************************************************
// ** função que recupera o valor da option selecionada de um select
//*******************************************************************************************************************************************************************
function valorSelect(elem) {
	if (!elem || !elem.selectedIndex || elem.childNodes.length == 0) return '';
	return elem.childNodes[elem.selectedIndex].value;
}
//*******************************************************************************************************************************************************************


//*******************************************************************************************************************************************************************
// ** cria e retorna uma lista de abas (no estilo abas2)
// ** recebe:	lista - array linear sendo cada elemento um objeto com nome e acao
// **			funcao - funcao chamada pelo click nas abas
//*******************************************************************************************************************************************************************
function montaAbas2(lista, funcao) {
	var ul = cria('ul', { id: 'abas2' });
	for (var i = 0; i < lista.length; i++) {
		var li = ul.appendChild(cria('li',null,{width:lista[i].tamanho}));
		if (i == 0) colocaClasse(li, 'primeiro');
		li.appendChild(cria('a', { href: 'javascript:void(0)', className: 'm', onclick: funcao, acao: lista[i].acao }, null, lista[i].nome));
		li.appendChild(cria('img', { src: '../img/aba_borda_dir.gif', className: 'bordaDir' }));
		li.appendChild(cria('img', { src: '../img/aba_borda_esq.gif', className: 'bordaEsq' }));
	}
	return ul;
}
//******************************************************************************************************************************************************************


//*******************************************************************************************************************************************************************
// ** de acordo com as teclas, chama a surpresa
//*******************************************************************************************************************************************************************
function valorSelect(elem) {
	if (!elem || !elem.selectedIndex || elem.childNodes.length == 0) return '';
	return elem.childNodes[elem.selectedIndex].value;
}
//*******************************************************************************************************************************************************************


//*******************************************************************************************************************************************************************
// ** de acordo com as teclas, chama a surpresa
//*******************************************************************************************************************************************************************
function timeStamp() {
	var agora = new Date();
	return agora.getDate() + agora.getHours() + agora.getMilliseconds();
}
//*******************************************************************************************************************************************************************


//*******************************************************************************************************************************************************************
// ** retorna um número aleatório inteiro entre max e min
//*******************************************************************************************************************************************************************
function randomInt(min, max) {
	return Math.floor(Math.random() * (max - min + 1)) + min;
}
//*******************************************************************************************************************************************************************


//*******************************************************************************************************************************************************************
// ** trata campos de input e texarea para prevenir códigos SQL (deve ser tratado também na chegada ao servidor)
//*******************************************************************************************************************************************************************
function trataSQL(campo, lang) {
	var expressao = new RegExp('declare|script|(\-\-)|(\%[0-9])','gim');
	if (expressao.test(campo.value)) {
		alert('Caracteres inválidos.');
		return false;
	}
	return true;
	//return campo.value;
}
//*******************************************************************************************************************************************************************