/*************************************************
 * BaLHau LIB
 * Esta biblioteca foi desenvolvida por Vítor Hugo Fernandes, a.k.a BaLHau
 * @author Balhau
 */
/**
 * Método que devolve os elementos que contém uma determinada className
 * @param cls {@link String} nome da class
 * @return {@link Array} contendo os elementos de uma determinada class
 */
var getByClassName=function(cls){
	var el=document.getElementsByTagName('*');
	var out=[];
	for(var i=0;i<el.length;i++){
		if(el[i].className==cls){
			out[out.length]=el[i];
		}
	}
	return out;
};


/**
 * Função que nos devolve o elemento a partir do seu identificador, ou então os elementos que verificam um determinado 
 * tipo de className, ou ainda o conjunto de elementos pertencentes a um tipo de tag
 * @param {String} idel ID do elemento
 */
var $=function(idel){
	if(typeof(idel)=='undefined' || idel==null)
		return null;
	if(typeof(idel)=="string"){
		if(idel.charAt(0)=='#'){
			if(document.getElementsByClassName){
				return HElement.get(document.getElementsByClassName(idel.substr(1,idel.length)));
			}else
			{
				return HElement.get(getByClassName(idel.substr(1,idel.length)));
			}
		}
		if(idel.charAt(0)=='$'){
			return HElement.get(document.getElementsByTagName(idel.substr(1,idel.length)));
		}
	}
	return HElement.get(idel);
};

var $$=function(tag,n){
	if(BLauLib.isUndefined(n)){
		if(tag.charAt(0)=='#'){
			return document.createAttribute(tag);
		}
		else{
			return HElement.get(document.createElement(tag));
		}
	}
	var out=[];
	for(var i=0;i<n;i++){
		out[i]=$$(tag);
	}
	return out;
}


/**
 * Objecto que contém os scripts da aplicação
 * @classDescription Objecto que representa a principal objecto da biblioteca. Dentro deste objecto encontram-se um conjunto de 
 * outros objectos com propósitos mais específicos. Este consiste, portanto, num contentor de bibliotecas. Poucos métodos
 * são directamente implementados neste objecto e em versões futuras poderão mesmo ser reagrupados noutras estruturas
 * @author Balhau
 * @constructor Construtor da API
 */
var BLauLib=function(){
	this.versao=0.1;
	this.author="Ví­tor Fernandes, a.k.a Balhau";
};

/**
 * Método que devolve uma string com as horas a partir do total de segundos
 * @param {Number} totseg
 */ 
BLauLib.segToHour=function(totseg){
	var vmin=Math.floor((totseg/60)%60);
	var vhor=Math.floor((totseg/3600)%24);
	var min=vmin>=10?vmin:"0"+vmin;
	var hora=vhor>=10?vhor:"0"+vhor;
	var seg=(totseg%60)>=10?totseg%60:"0"+totseg%60;
	var rt="";
	rt=(hora>0)?hora+":":"";
	rt+=min+":"+seg;
	return rt;
};

/**
 * Método que devolve os valores representados numa string URL no formato GET
 * @return {Object} Variaveis e seus respectivos valores
 */
String.prototype.getVarsFromUrl=function(){
	var aux=this.split("?");
	if(aux.length==0)
		return {};
	var vars=aux[1].split("&");
	var out={};
	var par="";
	for(var i=0;i<vars.length;i++){
		par=vars[i].split("=");
		out[par[0]]=par[1];
	}
	return out;
}

/**
 * Objecto com um conjunto de funções utilitárias para manipulação de cookies
 * @classDescription Objecto com um conjunto de funções utilitárias para manipulação de cookies.
 */
BLauLib.COOKIES=function(){
	var vars=document.cookie.split(";");
	var aux;
	var assArray={};
	for(var i=0;i<vars.length;i++){
		aux=vars[i].split('=');
		assArray[aux[0].trim()]=aux[1];
	}
	return assArray;
};

/**
 * Método que adiciona um novo cookie no browser
 * @param {String} name Nome do cookie
 * @param {String} value Valor do cookie
 * @param {String} time Validade do cookie
 * @param {String} path Domínio do cookie
 */
BLauLib.COOKIES.add=function(name,value,time,path){
	var pth=null;
	if(!path)
		pth="/";
	else
		pth=path;
	var dt=new Date();
	dt.setSeconds(dt.getSeconds()+time);
	document.cookie=name+'='+value+'; expires='+dt.toUTCString()+'; path='+pth;
}

/**
 * Método que nos devolve o tempo restante de sessão, redireccinando no final  
 * @param {String} divid Identificador do div que contem o tempo
 * @param {Number} totseg Número representando o total de segundos da hora.
 * @param {String} Link com o endereço da página no final da sessão
 */
BLauLib.getTime=function(divid,totseg,redirect){
	if(totseg>0){
		var dvel=$(divid);
		dvel.innerHTML=BLauLib.segToHour(totseg);
		totseg=totseg-1;
		setTimeout("BLauLib.getTime('"+divid+"',"+totseg+",'"+redirect+"')",1000);
	}
	else{window.location=redirect;}
};

/**
 * Libraria para invocação de páginas através do protocolo XMLHttpRequest
 * @classDescription Classe que implementa um conjunto de funcionalidades para comunicação assíncrona com servidores
 * 
 */
BLauLib.Ajax=function()
{
	this._init_();
};

/**
 * Objecto que representa o estado da ligação
 * @classDescription Este objecto representa o estado da ligação assíncrona efectuada
 */
BLauLib.Ajax.Status={};
/**
 * Ligação efectuada com sucesso
 */
BLauLib.Ajax.Status.OK=200;
/**
 * Página não encontrada
 */
BLauLib.Ajax.Status.NotFound=404;

BLauLib.Ajax.prototype._init_ = function(){
	this.xmlHttp = false;
	this.text="";
	this.html="";
	this.onLoaded=null;
	this.onLoading=null;
	this.onError=null;
	this.postvars=[];
	this.onCompleted=null;
	try {
		// tentativa para criar o objecto ajax para versões não IE
			this.xmlHttp = new XMLHttpRequest();
		} 
	catch (e) {
		// para IE6 ou mais recente
		var XmlHttpVersions = ['MSXML2.XMLHTTP.6.0', 'MSXML2.XMLHTTP.5.0', 'MSXML2.XMLHTTP.4.0', 'MSXML2.XMLHTTP.3.0', 'MSXML2.XMLHTTP', 'Microsoft.XMLHTTP'];
		// tenta todas as versões
		for (var i = 0; i < XmlHttpVersions.length && !xmlHttp; i++) {
			try {
				// tenta o objecto para as várias versões do IE
				this.xmlHttp = new ActiveXObject(XmlHttpVersions[i]);
			} 
			//ignora os erros
			catch (ex) {
			}
		}
	}
};
/**
 * Adiciona um novo par (variável,valor) para envio no pedido ajax
 * @param {String} name Nome da variável
 * @param {String} value Valor da variável
 * @return {void}
 */
BLauLib.Ajax.prototype.addVar=function(name,value){
	this.postvars[this.postvars.length]=[name,value];
};

/**
 * Método que devolve o objecto resposta do servidor enviado em formato JSON
 * @return {Object} Objecto
 */
BLauLib.Ajax.prototype.getJSON=function(){
	return BLauLib.FromJSON(this.text);
}
/**
 * Limpa as variáveis POST presentes no objecto
 * @return {void}
 */
BLauLib.Ajax.prototype.clearVars=function(){
	this.postvars=[];
};

BLauLib.mousePos=function(ev){
	if(ev.pageX || ev.pageY){ 
		return {x:ev.pageX, y:ev.pageY}; 
	} 
	return { 
		x:ev.clientX + document.body.scrollLeft - document.body.clientLeft, 
		y:ev.clientY + document.body.scrollTop  - document.body.clientTop 
	}; 
};

/**
 * Método que codifica o array de variáveis post para uma string com a sua representação 
 * @return{String} String com a representação das variáveis
 */
BLauLib.Ajax.prototype.encPostVars=function(){
	var str="";
	for(var i=0;i<this.postvars.length;i++){
		if(i!==0){
			str+="&";
		}
		str+=this.postvars[i][0]+"="+this.postvars[i][1];
	}
	return str;
	
};

/**
 * Método que efectua uma chamada Assíncrona pelo protocolo POST
 * @param {String} pag Endereço da página
 */
BLauLib.Ajax.prototype.callPost=function(pag){
	this.open("POST", pag);
	this.send(this.encPostVars());
}

/**
 * Objecto para manipulação de chamadas assíncronas com recurso a iframes
 */
BLauLib.AIM={};

/**
 * Método que cria um frame para chamada assí­ncrona
 * @param {Object} Object com as funções callback
 */
BLauLib.AIM.criaFrame=function(callbackobject){
	var id=Math.floor(Math.random()*10000);
	id="frm_"+id;
	var dcont=$$('div');
	dcont.innerHTML="<iframe style='display:none' src='about:blank' id='"+id+"' name='"+id+"' onload=BLauLib.AIM.onLoaded('"+id+"')></iframe>";
	document.body.appendChild(dcont);
	var frm=$(id);
	if(callbackobject){
		if(typeof(callbackobject.onComplete)=="function")
			frm.onComplete=callbackobject.onComplete;
	}
	return id;
}

BLauLib.AIM.form=function(formE,name){
	formE.setAttribute('target',name);
}

BLauLib.AIM.submit=function(formE,callbackobject){
	BLauLib.AIM.form(formE, BLauLib.AIM.criaFrame(callbackobject));
	if(callbackobject){
		if(typeof(callbackobject.onStart)=="function")
			return callbackobject.onStart();
		return true;
	}else{
		return true;
	}
}

BLauLib.AIM.onLoaded=function(id){
	var el=$(id);
	if(el.contentDocument){
		var doc=el.contentDocument;
	}
	else if(el.contentWindow){
		var doc=el.contentWindow.document;
	}
	else{
		var doc=window.frames[id].document;
	}
	
	if(doc.location.href=="about:blank"){
		return;
	}
	if(typeof(el.onComplete)=='function'){
		el.onComplete(doc.body.innerHTML);
	}
}
/**
 * Método que efectua uma ligação assíncrona ao servidor
 * @param {String} metodo Tipo de ligação POST/GET
 * @param {String} urlAja Endereço da ligação
 */
BLauLib.Ajax.prototype.open=function(metodo,urlAja)
{
	//Copia das estruturas devido à   não visibilidade do operador "this" dentro do método "onreadystatechange"
	
	var onLoading=this.onLoading;
	var onLoaded=this.onLoaded;
	var onError=this.onError;
	var ajax=this.xmlHttp;
	var estado=this.xmlHttp.readyState;
	var pthis=this;
	var ready=function()
	{
		if(ajax.readyState==4)
		{
			if(typeof(onLoaded)=="function"){
				pthis.text=ajax.responseText;
				pthis.html=ajax.responseXML;
				onLoaded();
			}
		}
		if(ajax.readyState==2){
			if(typeof(onLoading)=="function"){
				onLoading();
			}
		}
		if(ajax.readyState==3){
			if(typeof(onError)=="function"){
				onError();
			}
		}
	};
	this.xmlHttp.onreadystatechange=ready;
	this.xmlHttp.open(metodo,urlAja);
	if(metodo=="POST"|| metodo=="post"){
		this.xmlHttp.setRequestHeader("Content-Type","application/x-www-form-urlencoded;charset=UTF-8");
	}
};
/**
 * Método que envia uma mensagem para o servidor
 * @param {String} conteúdo para o servidor
 */
BLauLib.Ajax.prototype.send=function(conteudo)
{
	this.xmlHttp.send(conteudo);
};

/**
 * Devolve o dia da semana para um determinado mes de um determinado ano
 * @param mes Mes
 * @param ano Ano
 * @return Índice do dia da semana
 */
Date.getFirstDayMonth=function(mes,ano){
	var d=new Date(ano,mes);
	d.setDate(1);
	return d.getDay();
};

/**
 * Método que devolve o número de dias de um mês
 * @param mes Mes que se pretende saber o numero de dias
 * @param ano Ano que se pretende saber o numero de dias
 * @return Dias 28-31 dias do mes
 */
Date.getNumDaysMonth=function(mes,ano){
	return 32-new Date(ano,mes,32).getDate();
}

BLauLib.UI={};
/**
 * Painel que apresenta os dados no ecran sob a forma paginada
 * @param {String} Id do elemento contentor
 * @param {Array} Array com os cabeçalhos
 * @param {Array} Array com os dados tabelados
 * @param {Number} Number com o número de elementos por página
 */
BLauLib.UI.NPaged=function(iddiv,aheaders,adata,nppag,css){
	this.headers=aheaders;
	this.data=adata;
	this.nppage=nppag;
	this.divp=$(iddiv);
	this.tblcon=null;
	this.idpr=this.divp.id;
	this.pagenumber=1;
	if(typeof(css)=="undefined")
		this.css="npage";
	else
		this.css=css;
	this.build();
};

/**
 * Objecto que representa um objecto calendário
 */
BLauLib.UI.DatePicker=function(id){
	this.id=id;
	this.dinput=$$('input');
	this.dbox=BLauLib.UI.DatePicker.buildDataBox(dinput);
	
	this.dinput.id="data_"+this.id;
	this.dbox.id="dataBox_"+this.id;
};

/**
 * Método que efectua a construção do div de dados
 */
BLauLib.UI.DatePicker.buildDateBox=function(inputobj){
	var i_obj=$(inputobj);
	var divbox=$$('div');
	
};


/**
 * Método que efectua a criação da tabela contentora das datas
 * @param {obj} Elemento associado ao calendário
 */
BLauLib.UI.DatePicker._createTableDate=function(obj,id){
		var DS=7;
		var id=id;
		var tbody=$$('table');		//Criação do elemento table que servirá de contentor do calendário
		var linhas=$$('tr',DS+1);		//Numero de linhas da tabela
		var cells=$$('td',46);		//Numero de células 46, inclui dias do mes, semana, cabeçalho e rodapé
		tbody.className="dpTB";
		tbody.id="dpTB_"+id;
		//Configuração do cabeçalho
		var btleft=$$('input');
		var btright=$$('input');
		var title=$$('div');
		title.id="dpHeader_"+id;
		
		btleft.type="button";
		btright.type="button";
		btright.value=">";
		btleft.value="<";
		
		cells[1].colSpan=DS-2;
		cells[1].className="dpTTD";
		
		cells[0].add(btleft);
		cells[1].add(title);
		cells[2].add(btleft);
		linhas[0].add(cells[0],cells[1],cells[2]);
		//Configuração dos dias da semana
		var dsem=cells.select(3,2+DS);
		var dsm=["Do","Se","Te","Qu","Qu","Se","Sa"];
		for(var i=0;i<DS;i++){
			dsem[i].id="dia_"+i;
			dsem[i].innerHTML=dsm[i];
		}
		linhas[1].add(dsem);
		var dias=cells.select(DS+3,DS+3+33);	//34=4*7+6 dias 
		//Configuração dos dias do mes
		for(var i=2;i<DS;i++){
				linhas[i].add(dias.select(7*(i-2),7*(i-1)-1));
		}
		//Configuração dos botões de fundo
		
		tbody.add(linhas);
		return tbody;
};

/**
 * Devolve o número de páginas necessárias para a representação dos dados
 */
BLauLib.UI.NPaged.prototype.getNPages=function(){
	return this.data.length.ICDiv(this.nppage); 
};

/**
 * Método responsável por mudar o conteúdo de página  
 * @param npage  Numero da página
 * @return Nada
 */
BLauLib.UI.NPaged.prototype.displayPage=function(npage){
	this.pagenumber=npage;
	this.tblcon.innerHTML="";
	var posmin=(npage-1)*this.nppage;
	var posmax=Math.min((npage)*this.nppage-1,this.data.length);
	var aux1=null;
	var aux2=null;
	//preenche headers
	aux2=$$('tr');
	aux2.className=this.css+"_hd";
	for(var i=0;i<this.headers.length;i++){
		aux1=$$('td');
		aux1.className=this.css+"_td_";
		if((j%2)==0)
			aux1.className+="par";
		else
			aux1.className+="impar";
		aux1.innerHTML=this.headers[i];
		aux2.add(aux1);
	}
	this.tblcon.add(aux2);
	//preenche corpo
	for(var i=posmin;i<posmax;i++){//itera sobre as linhas da matriz de dados
		aux1=$$('tr');
		if((i%2)==0)//paridade da coluna
			aux1.className=this.css+"_tr_par";
		else
			aux1.className=this.css+"_tr_impar";
		for(var j=0;j<this.data[i].length;j++){//itera sobre as colunas da matriz de dados
			aux2=$$('td');
			aux2.innerHTML=this.data[i][j];
			aux2.className=this.css+"_td_";
			if((j%2)==0)
				aux2.className+="par";
			else
				aux2.className+="impar";
			aux1.add(aux2);
		}
		this.tblcon.add(aux1);
	}
	this.setFooter(npage-1);
}

/**
 * Função que remove uma entrada no objecto NPaged
 * @param n Índice da entrada
 * @param callback Função de callback
 * @return void
 */
BLauLib.UI.NPaged.prototype.removeEntry=function(n,callback,s){
	var posmin=(this.pagenumber-1)*this.nppage;
	var posmax=Math.min((this.pagenumber)*this.nppage-1,this.data.length);
	if(n<0 || n>=this.data.length) //caso o valor de n esteja fora do intervalo de dados
		return;
	if(n>=posmin && n<posmax){//caso o valor n pertenca à página que se encontra seleccionada
		var linhas=this.tblcon.get('$tr');
		var linha=linhas[n-posmin+1];
		var obj=this;
		var call=function(){
			if(typeof callback!="undefined" && callback!=null)
				callback();
			obj.displayPage(obj.pagenumber);
		}
		linha.del(s,call);
		this.data=this.data.remove(n);
	}
}

BLauLib.UI.NPaged.prototype.setFooter=function(n){
	for(var i=0;i<this.dfoot.childNodes.length;i++){
		if(i==n)
			this.dfoot.childNodes[i].className=this.css+"_bf_on";
		else
			this.dfoot.childNodes[i].className=this.css+"_bf";
	}
}

BLauLib.UI.NPaged.prototype.build=function(){
	var np=this.getNPages();
	this.divp.innerHTML="";//apaga o conteudo presente no contentor pai
	this.tblcon=$$('table');//tabela com os dados
	this.divtbc=$$('div');
	this.divtbc.className=this.css+"_table";
	this.tblcon.className=this.css+"_table";
	this.dfoot=$$('div');//divisor com os números
	var aux1;
	var aux2;
	var obj=this.displayPage;
	this.divtbc.add(this.tblcon);
	this.divp.add(this.divtbc);
	var obj=this;
	//preenche divisor
	var cls=function(a){
		var ev=a?a:window.event;
		var el=ev.currentTarget;
		var num=parseInt(el.id.split("_")[1])+1;
		obj.displayPage(num);
	}
	if(np>1){
		for(var i=0;i<np;i++){
			 aux1=$$('div');
			 aux1.innerHTML=i;
			 aux1.id="p_"+i;
			 aux1.className=this.css+"_bf";
			 aux1.onclick=cls;
			 this.dfoot.add(aux1);
		}
		this.divp.add(this.dfoot);
	}
	//mostra a primeira página
	this.displayPage(this.pagenumber);
};
/**
 * Este objecto implementa uma interface para efectuar procuras
 */
BLauLib.UI.ISearch=function(id,parent,callback,height,txsize){
	this.bheight=300;
	if(!BLauLib.isUndefined(height) && !BLauLib.isNull(height))
		this.bheight=height;
	this.contentor=$(parent);
	this.callback=callback;
	this.datadiv=$$('div');
	this.datadiv.className="scrolldata";
	this.idsearch="search_"+id;
	
	this.intext=$$('input');
	this.intext.id=this.idsearch+"_input";
	this.intext.type="text";
	this.intext.size=(typeof txsize == "undefined")?60:txsize;
	this.table=$$('table');
	var obj=this;
	this.intext.onkeyup=function(){
		if(typeof obj.callback!="undefined" && obj.callback!=null)
			obj.callback();
	}
	this.table.className="isearcht";
	this.datadiv.style.maxHeight=this.bheight+"px;";
	this.build();
};

BLauLib.UI.ISearch.prototype.setText=function(val){
	this.intext.value=val;
}

BLauLib.UI.ISearch.prototype.getText=function(){
	return this.intext.value;
}

BLauLib.UI.ISearch.prototype.clearData=function(){
	this.datadiv.innerHTML="";
}

BLauLib.UI.ISearch.prototype.build=function(){
	var inputline=$$('tr');
	var inputcell=$$('td');
	
	
	
	var trdata=$$('tr');
	var tddata=$$('td');
	
	tddata.add(this.datadiv);
	trdata.add(tddata);
	inputcell.id=this.intext.id+"_td";
	inputcell.add(this.intext);
	inputline.add(inputcell);
	
	this.table.add(inputline);
	this.table.add(trdata);
	this.table.className="isearcht";
	this.contentor.add(this.table);
};


/**
 * Método que adiciona os dados ao objecto
 * @return
 */
BLauLib.UI.ISearch.prototype.displayData=function(dt){
	this.clearData();
	var pdata=null;
	if(typeof dt=="undefined" || dt==null)
		return;
	for(var i=0;i<dt.length;i++){
		pdata=$$('div');
		pdata.className="data";
		pdata.innerHTML=dt[i];
		this.datadiv.add(pdata);
	}
};

/**
 * Extensoes as primitvas de JavaScript
 * Criacao de um wrapper para o objecto Element, HElement
 * o objectivo consiste em extender os objectos Element sem entrar em conflito
 * com as extensoes de otras bibliotecas, tais como Prototype, JQuery, etc
 * @author Vitor Fernandes (a.k.a balhau)
 */

/**
 * Metodo que efectua o resize de um array, devolve como parametro de saida 
 * o array redimensionado
 * @author Vitor Fernandes (a.k.a: Balhau)
 */
var e$=function(divel){return document.getElementById(divel);};

/**
 * Classe para efectuar a concatenação de strings de uma forma eficiente, substitui a operação "+="
 * @param {String} str String String inicial
 * @author Balhau
 */
var StringBuilder=function(str){
	this._arrstr=[];
	this._comp=str.length;
	for(var i=0;i<str.length;i++){
		this._arrstr[i]=str.charAt(i);
	}
};
/**
 * Método para concatenação de strings
 * @param {String} str String que se pretende concatenar com a já existente representada sob a forma
 * de array
 */
StringBuilder.prototype.append=function(str){
	for(var i=0;i<str.length;i++){
		this._arrstr[this._arrstr.length]=str.charAt(i);
	}
};

/**
 * Método que devolve o objecto string representado
 * @return {String} String resultante da concatenação
 */
StringBuilder.prototype.toString=function(){
	return this._arrstr.join('');
};


/**
 * Efectua um resize no array removendo os elementos "undefined"
 * @return {Array} Array onde foram removidos os elementos com valor "undefined"
 */
Array.prototype.resize=function()
{
	var arr=[];
	var i;
	var k=0;
	for(i=0;i<this.length;i++)
	{
		if(typeof(this[i])=="undefined"){
			continue;
		}
		arr[k]=this[i];
		k++;
	}
	return arr;
};

/**
 * Remove os elementos a partir do valor de endereço do objecto
 * @param {Object} obj Objecto a remover
 * @return {Array} Array
 */
Array.prototype.removeByObject=function(obj){
	var out=[];
	for(var i=0;i<this.length;i++){
		if(this[i]!==obj)
			out[out.length]=this[i];
	}
	return out;
}

/**
 * Método que remove os elementos "undefined" e null de um array
 * @return {Array} Array resultante da remoção de elementos null e undefined
 */
Array.prototype.clean=function(){
	var out=[]
	for(var i=0;i<this.length;i++){
		if(this[i]!=null && typeof this[i]!="undefined")
			out[out.length]=this[i];
	}
	return out;
};

/**
 * Efectua a remoção de caracteres vazios à esquerda da string
 * @return {String} String sem espaços brancos à esquerda
 */
String.prototype.ltrim=function(){
	var i=0;
	var cmp=this.length;
	while(this.charAt(i)==' ' && i<cmp){
		i++;
	}
	return this.substring(i, this.length);
}

String.prototype.addEvent=function(event,value){
	return "<a "+event+"=\""+value+"\">"+this+"</a>";
};

/**
 * Efectua a remoção de caracteres vazios à direita da string
 * @return {String} String sem espaços brancos à direita
 */
String.prototype.rtrim=function(){
	var i=this.length-1;
	while(i>=0 && this.charAt(i)==' '){
		i--;
	}
	return this.substring(0,i+1);
}

/**
 * Verifica se uma string é vazia
 * @return {Boolean} Valor verdadeiro caso a string seja vazia, falso caso contrário
 */
String.prototype.empty=function(){
	return (this.trim()=='');
}

String.prototype.trim=function(){
	return this.ltrim().rtrim();
}

/**
 * Método que devolve um array de elementos que devolvem valor true quando passados para a função callback
 * @param {Function} callback Função callback que avalia o elemento
 * @return {Array} Array com os elementos que retornam valor true na avaliação pela função callback
 */
Array.prototype.where=function(callback){
	var out=[];
	for(var i=0;i<this.length;i++){
		if(callback(this[i])){
			out[out.length]=this[i];
		}
	}
	return out;
};

Array.prototype.select=function (ini,end){
	if(typeof end=="undefined") 
		end=this.length+1;
	return this.slice(ini,end+1);
}

/**
 * Método que aplica uma função a todos os elementos de um determinado array
 * @param callback Função callback executada sobre os elementos
 * @return true ou false dependendo se o argumento da função é uma função ou não.
 */
Array.prototype.map=function(callback){
	if(!BLauLib.isFunction(callback))
		return false;
	var cmp=this.length;
	for(var i=0;i<cmp;i++){
		callback(this[i]);
	}
	return true;
};

Array.prototype.AMap=function(callback){
	if(!BLauLib.isFunction(callback))
		return this.clona();
	var cmp=this.length;
	var out=[];
	for(var i=0;i<cmp;i++){
		out[i]=callback(this[i]);
	}
	return out;
};

Array.prototype.getObjectBy=function(paramname,value){
	var prop=null;
	for(var i=0;i<this.length;i++){
		prop=this[i];
		if(prop[paramname]==value)
			return prop;
	}
	return null;
};

//NodeList.prototype.where=function(callback){
//	var out=[];
//	for(var i=0;i<this.length;i++){
//		if(callback(this[i])){
//			out[out.length]=this[i];
//		}
//	}
//	return out;
//}

/**
 * Devolve uma string com a representação dos elementos contidos no Array
 * @return {String} String com a representação dos elementos presentes no Array
 */
Array.prototype.toString = function()
{
	var i;
	var str="[";
	for(i=0;i<this.length;i++)
	{
		if(i===0){
			str+=this[i];
		}
		else{
			str+=","+this[i];
		}
	}
	str+="]";
	return str;
};

/**
 * Método que efectua a remoção do último elemento do array
 * @return {Object} Elemento presente no array 
 */
Array.prototype.pop=function()
{
	var obj=this[this.length-1];
	this.remove(this.length-1);
	return obj;
};

/**
 * Devolve a posição que um determinado objecto ocupa no array
 * @param {Object} valor Objecto do array
 * @return {Number} Posição do elemento do array, -1 caso o elemento não pertença ao array
 */
Array.prototype.getIndex=function(valor){
	for(var i=0;i<this.length;i++){
		if(this[i]==valor){	return i;}
	}
	return -1;
};

/**
 * Método que adiciona um elemento ao array
 * @param {Object} Objecto, ou lista de objectos a adicionar
 * @return {Array} devolve o próprio array para efeitos de chaining
 */
Array.prototype.add = function(){
	var args=arguments;
	var cmp = this.length;
	for(var i=0;i<args.length;i++){
		this[cmp] = args[i];
		cmp++;
	}
	return this;
};

Array.prototype.clone=function(){
	var _c=[];
	for(var k=0;k<this.length;k++){
		_c[k]=this[k];
	}
	return _c;
}
/**
 * Método que remove um elemento do array 
 * @param {Number} indice Posição do elemento a remover
 * @return {Array} devolve o array já sem o elemento
 */
Array.prototype.remove=function(indice)
{
	var _a=this.clone();
	if(_a.length<=indice || indice<0){return [];}
	delete(_a[indice]);
	return _a.resize();
};

Number.prototype.tipo=function()
{
	return "numero";
};



/**
 * Devolve a divisão inteira entre dois números arredondada por defeito
 * @return {Number} Valor da divisão
 */
Number.prototype.IFDiv=function(a){
	if(a==0)
		return NaN;
	return Math.floor(this/a);
}

/**
 * Devolve a divisão inteira entre dois números arredondada por excesso
 * @return {Number} Valor da divisão
 */
Number.prototype.ICDiv=function(a){
	if(a==0)
		return NaN;
	return Math.ceil(this/a);
}

/**
 * Devolve o valor do valor multiplicado por uma determinada percentagem
 * @param {Number} a Percentagem
 * @return {Number} Valor multiplicado pela percentagem a 
 */
Number.prototype.percent=function (a)
{
	return (this*a)/100;
}

String.prototype.tipo=function()
{
	return "string";
};
/**
 * Valida uma string a partir de uma expressão regular
 * @return {Boolean} Verdadeiro caso a string verifique a condição dada pela expressão regular, falso caso contrário
 */
String.prototype.valida=function(exreg){
	return this.match(exreg)===null?false:true;
};

/**
 * Método que extende a classe String, adicionando a possiblidade de reverter a ordem dos caracteres
 * @return {@link String} String com os caracteres em ordem reversa
 */
String.prototype.reverse=function(){
	var stou="";
	for(var i=this.length-1;i>=0;i--){
		stou+=this.charAt(i);
	}
	return stou;
};

/**
 * Método que transforma uma String num array com a sua codificação UNicode
 * @param {String} car Caracter separador
 * @return {String} Codificação Unicode separada através do caracter car
 */
String.prototype.toUnicodeArray=function(car){
	var sb=new StringBuilder('');
	for(var i=0;i<this.length;i++){
		if(i===0){sb.append(String(this.charCodeAt(i)));}
		else{sb.append(car+""+this.charCodeAt(i));}
	}
	return sb.toString();
};

Array.prototype.tipo=function()
{
	return "array";
};

/**
 * Método que cria um array com valores aleatórios
 * @param {int} dim Dimensão do array
 * @param {int} low Valor mínimo
 * @param {int} sup Valor máximo
 * @param {bool} intarray Valor booleano indicando se o array é composto por valores inteiros ou valores decimais
 * @return {int} Array aleatório com dim elementos compreendidos entre low e sup
 */
Array.random=function(dim,low,sup,intarray){
	var arr=[];
	if(typeof(low)=='undefined')
		low=0;
	if(typeof(sup)=='undefined')
		sup=100;
	if(typeof(intarray)=='undefined')
		intarray=true;
	for(var i=0;i<dim;i++){
		if(intarray)
			arr[i]=Math.floor(Math.random()*(sup-low+1)+low);
		else
			arr[i]=Math.random()*(sup-low)+low;
	}
	return arr;
};

/**
 * Método que devolve um array bidimensional com valores aleatórios 
 * @param {Number} col Número de colunas da matriz
 * @param {Number} lin Número de linhas da matriz
 * @param {Number} low Mínimo possível
 * @param {Number} sup Máximo possivel
 * @param {Boolean} intarray True para valores inteiros, false para valores decimais
 */
Array.mrandom=function(col,lin,low,sup,intarray){
	var out=[]
	for(var i=0;i<lin;i++)
		out[i]=Array.random(col,low,sup,intarray);
	return out;
}


var Elemento={};

Elemento.setAttribute=function(elemento,nome,valor){
    switch(nome){
        case "class":
            if(typeof(ActiveXObject)!="undefined"){elemento.setAttribute("className",valor);}
            else{elemento.setAttribute("class",valor);}
            break;
		case "checked":
			elemento.defaultChecked=valor;
			break;
        default:
            elemento.setAttribute(nome,valor);
        }
};

Elemento.getAttribute=function(elemento,nome){
    switch(nome){
        case "class":
            if(typeof(ActiveXObject)!="undefined"){return elemento.getAttribute('className');}
            else{return elemento.getAttribute('class');}
            break;
        default:
                return elemento.getAttribute(nome);
    }
};
Elemento.criaRadioBox=function(id,nome,checked){
	if(checked=="undefined"){
		checked=false;
	}
	var radioInput;
    try {
        var radioHtml = '<input type="radio" name="' + nome + '"';
        if ( checked ) {
            radioHtml += ' checked="checked"';
        }
        radioHtml += '/>';
        radioInput = document.createElement(radioHtml);
		radioInput.setAttribute('id',id);
    } catch( err ) {
        radioInput = document.createElement('input');
        radioInput.setAttribute('type', 'radio');
        radioInput.setAttribute('name', name);
		radioInput.setAttribute('id',id);
        if ( checked ) {
            radioInput.setAttribute('checked', 'checked');
        }
    }
return radioInput;
};

Elemento.createInput=function(tipo,nome,id)
{
	var el;
	if(id===undefined){
		id=nome;
	}
	switch(tipo){
		case "radio":
			el=Elemento.criaRadioBox(id,nome,false);
			break;
		default:
			el=document.createElement('input');
			el.setAttribute('name',nome);
			el.setAttribute('id',id);
			el.setAttribute('type',tipo);
			break;
	}
	return el;
};


Elemento.FX={};
/**
 * Objecto responsavel por extender funcionalidades ao objecto Element
 * @classDescription Em vez de se proceder a uma extensao natural do objecto Element, baseado
 * na adicao de novos metodos ao objecto em questao, efectuou-se a criacao de um novo objecto
 * chamado HElement que copia todos os metodos e propriedades existentes no objecto Element.
 * A razao pela qual se decidiu em criar este wrapper, vem pelo facto de evitar conflitos com
 * outras librarias de javascript, nomeadamente jquery e prototype. 
 * Este elemento tem uma unica desvantagem. Tem um overhead superior no inicalizar do objecto
 * devido ao ciclo que copia as funcionalidades prototipadas.
 * @author Balhau
 */
var HElement = function () {
	this.clones=0;
	this.evnts={"onmouseover":[],"onmousedown":[],"onmouseup":[],"onmouseout":[]};
	this.ontransition=false;
	this.isdrag=false;
};


HElement.Event={};


HElement.Event.ONMOUSEOVER="onmouseover";

HElement.Event.ONMOUSEUP="onmouseup";

HElement.Event.ONMOUSEDOWN="onmousedown";

HElement.Event.ONMOUSEOUT="onmouseout";

/**
 * Objecto reservado para implementação de funções para animar objectos
 */
HElement.prototype.FX={};
/**
 * Método que especifica a transparência do objecto em HTML
 * @param {Object} val percentagem compreendida entre 0-100
 */
HElement.prototype.setAlpha=function(val){
	//caso do IE
	if(typeof(this.style.filter)!='undefined'){
		this.style.zoom=1;
		this.style.filter="alpha(opacity="+val+")";
	}
	//caso firefox, etc
	else{
		if(val<=0){
			this.style.visibility="hidden";
			}
		else{
			this.style.visibility="visible";
		}
		val=val/100;
		this.style.opacity=val;
	}
	this.alpha=val;
}

/**
 * Método que devolve a posição de um determinado elemento
 * @return {Object} Objecto.x, Objecto.y
 */
HElement.prototype.getPos=function(){
	var cX=this.offsetLeft;
	var cY=this.offsetTop; 
	var pai=this;
	if (pai.offsetParent) {
		while (pai = pai.offsetParent) {
			cX += pai.offsetLeft;
			cY += pai.offsetTop;
		}
	}
	return {x: cX,y:cY};
}

/**
 * Método que atribui uma posição a um elemento
 * @param {Number} x Valor de X
 * @param {Number} y Valor de Y 
 */
HElement.prototype.setPos=function(x,y){
	this.style.position="absolute";
	this.style.top=y+"px";
	this.style.left=x+"px";
}

HElement.prototype.pai=function(){
	return HElement.get(this.parentNode);
}

/**
 * Método que devolve a actual transparência aplicada ao objecto
 * @return Number Percentagem de transparência
 */
HElement.prototype.getAlpha=function(){
	var rg=new RegExp();
	//Caso IE;
	if (typeof(this.style.filter) != 'undefined') {
		if(this.style.filter===""){
			return 100;
		}
		var match=/opacity=(.*)\)/i.exec(this.style.filter);
		return parseInt(match[1]*100);
	}
	//Caso não IE
	if(this.style.opacity===""){
		return 100;
	}
	return this.style.opacity*100;
};

/**
 * Método que remove um elemento do DOM
 * @return
 */
HElement.prototype.del=function(s,callback){
	if(typeof s=="undefined" || s==null){
		var pai=HElement.get(this.parentNode);
		var a=this;
		pai.remove(a);
		return;
	}
	var a=this;
	this.desvanece(s,function(){a.del();if(typeof callback!="undefined" && callback!=null)callback();});
}

/**
 * Metodo que inicializa o mecanismo de drag sobre um objecto
 * @param x {@link Number} Coordenada em x
 * @param y {@link Number} Coordenada em y
 * @param callback {@link Function} Funcao callback executada a cada instancia do movimento
 * @return
 */
HElement.prototype.startDrag=function(x,y,callback){
	var isto=this;
	if(x && y){
		isto.mouseX=x;
		isto.mouseY=y;
		
	}else{
		isto.mouseX=0;
		isto.mouseY=0;
	}
	if (isNaN(parseInt(isto.style.pixelLeft))) { isto.style.pixelLeft = isto.getPos().x; }
	if (isNaN(parseInt(isto.style.pixelTop))) { isto.style.pixelTop = isto.getPos().y; }
	
	document.onmousemove=function(e){
		var x = parseInt(isto.style.pixelLeft);
		var y = parseInt(isto.style.pixelTop);
 
		e = e ? e : window.event;
		isto.style.pixelLeft = x + (e.clientX - isto.mouseX);
		isto.style.pixelTop = y + (e.clientY - isto.mouseY);
		isto.mouseX = e.clientX;
		isto.mouseY = e.clientY;
		if(callback){callback(x, y);}
	}
};


/**
 * Método que adiciona valores quando estamos na presença de um objecto do tipo select.
 * Este método foi concebido devido às diferenças existentes entre os vários browsers
 * @param {Object} value Valor da opção
 * @param {Object} capt Label associado ao item
 */
//Método para adicionar valores a elementos
HElement.prototype.addOption=function(value,capt,id){
	switch(this.nodeName){
		case "SELECT":
			var noElem=HElement.createElement('option');
			var indice=0;
			var lastElem=null;
			if(typeof(capt)=="undefined"){
				noElem.text="undefined";
			}
			else{
				noElem.text=capt;
			}
			if(typeof(id)=="undefined"){
				noElem.id="id_"+value;
			}
			noElem.value=value;
			if(this.selectedIndex!=-1){
				this.indice=this.selectedIndex;
				lastElem = this.options[indice];
			}
			try {
				this.add(noElem,lastElem); // standards compliant; doesn't work in IE
    		}
    		catch(ex) {
      			this.add(noElem, this.selectedIndex); // IE only
    		}
		default: 
	}
};


/**
 * Método que aplica um efeito de desvanecimento a elementos de HTML
 * @param {Number} seg Número de segundos ate atingir a transparencia mínima
 * @see #getAlpha
 * @see #setAlpha
 * @see #aparece
 */
HElement.prototype.desvanece=function(seg,callback){
	var alphaAct=this.getAlpha();
	this.transicaoAlpha(alphaAct,0,seg,callback);
};

/**
 * Devolve o comprimento do elemento
 * @return {Number} Comprimento, em pixeis, do elemento
 */
HElement.prototype.getWidth=function(){
	return this.style.width===""? 0 : this.style.width.split("px")[0];
}

/**
 * Atribui um comprimento ao elemento
 * @param {Number} vl Comprimento em pixeis
 */
HElement.prototype.setWidth=function(vl){
	this.style.width=vl+"px";
}

/**
 * Atribui uma altura ao elemento
 * @param {Number} vl Altura em pixeis
 */
HElement.prototype.setHeight=function(vl){
	this.style.height=vl+"px";
}

/**
 * Devolve o comprimento do elemento
 * @return {Number} Comprimento, em pixeis, do elemento
 */
HElement.prototype.getHeight=function(){
	return this.style.height===""? 0 : this.style.height.split("px")[0];
}

/**
 * Método que aplica um efeito de reaparecimento a elementos de HTML
 * @param {Number} seg Número de segundos ate atingir a transparencia máxima
 * @see #setAlpha
 * @see #setAlpha
 * @see #desvanece
 */
HElement.prototype.aparece=function(seg,callback){
	var alphaAct=this.getAlpha();
	this.transicaoAlpha(alphaAct,100,seg,callback);
};

Object.prototype.select=function(callback){
	var out=[];
	if(this.length!=undefined){
		for(var i=0;i<this.length;i++){
			if(callback(this[i])){
				out[out.length]=this[i];
			}
		}
	}
	return out;
}

Object.prototype.isFunction=function(){
	return (this.constructor==Function)?true:false;
}

Object.prototype.isNum=function(){
	return (this.constructor==Number)?true:false;
}

Object.prototype.isString=function(){
	return (this.constructor==String)?true:false;
}

/**
 * Metodo que detecta a intersecao entre o objecto instanciado e um outro passado por parametro
 * @param {String} l Identificador do Elemento para o qual se pretende efectuar a comparacao de cplosap
 */
HElement.prototype.hitTest=function(l){
	var l=document.getElementById(l);
	function getOffset(o){
		for(var r = {l: o.offsetLeft, t: o.offsetTop, r: o.offsetWidth, b: o.offsetHeight};
			o = o.offsetParent; r.l += o.offsetLeft, r.t += o.offsetTop);
		r.r += r.l; r.b += r.t;
		return r;
	}
	for(var b, s, r = [], a = getOffset(this), j = isNaN(l.length), i = (j ? l = [l] : l).length; i;
		b = getOffset(l[--i]), (a.l == b.l || (a.l > b.l ? a.l <= b.r : b.l <= a.r))
		&& (a.t == b.t || (a.t > b.t ? a.t <= b.b : b.t <= a.b)) && (r[r.length] = l[i]));
	return j ? !!r.length : r;
};



/**
 * Método que efectua a duplicação em profundidade de um determinado Elemento HTML. Quando invocado este método
 * cria um elemento idêntico ao elemento instanciado assim como os Elementos filhos num processo recursivo.
 * Os identificadores são diferentes de cópia para cópia para evitar colisões em posteriores invocações de objectos
 * a partir de javascript partindo do seu ID;
 * @param {Booleano} Variável boleana indicando o tipo de clonagem. Caso este parãmetro não seja inserido
 * ou seja verdadeiro a cópia é feita em profundidade, caso o valor seja falso temos unicament a cópia do elemento
 * sem efectuar profundidade.
 * @return {HElement} Devolve um objecto do tipo HElement que consiste no presente objecto duplicado
 */
HElement.prototype.clone = function(prof){
	if(typeof(this.clones)=='undefined' || this.clones==null)
		this.clones=0;
	if(typeof(prof)=='undefined'){
		prof=true;
	}
	var cln = document.createElement(this.tagName);
	for (i = 0; i < this.attributes.length; i++) {
		if (this.attributes[i].name == "id") {
			cln.setAttribute(this.attributes[i].name, this.attributes[i].nodeValue + "_clone_" + this.clones);
		}
		else {
			//cln.attributes[i]=document.createAttribute(el.attributes[i].name);
			cln.setAttribute(this.attributes[i].nodeName,this.attributes[i].nodeValue);
			if(typeof(this.innerText)!='undefined')
				cln.innerText=this.innerText;
		}
	}
	if (prof) {
		var filhos = this.childNodes;
		for (i = 0; i < filhos.length; i++) {
			//Elementos do tipo TEXTO
			if (filhos[i].nodeType == 3) {
				cln.appendChild(filhos[i]);
			}
			else {
				elF = HElement.get(filhos[i]);
				cln.appendChild(HElement.get(elF.clone(prof)));
			}
		}
	}
	else 
		cln.innerHTML = this.innerHTML;
	return cln;
};

/**
 * Método que coloca um elemento no centro da janela
 */
HElement.prototype.putAtCenter=function(){
	var wd=BLauLib.Window.width();
	var he=BLauLib.Window.height();
	var sx=BLauLib.Window.scrX();
	var sy=BLauLib.Window.scrY();
	var x=wd/2+sx-this.offsetWidth/2;
	var y=he/2+sy-this.offsetHeight/2;
	this.style.position="absolute";
	this.style.left=isNaN(x)?(wd/2+"px"):(x+"px");
	this.style.top=isNaN(y)?(he/2+"px"):(y+"px");
}

/**
 * Método que aplica uma função de callback aos elementos em profundidade
 * @param {Function} callback
 */
HElement.prototype.traverse=function(callback){
	callback(this);
	for(var i=0;i<this.childNodes.length;i++){
		HElement.get(this.childNodes[i]).traverse(callback);
	}
}

/**
 * Método que efectua o resize de um objecto
 * @param {Event} mev Evento de rato
 * @param {Number} minx Comprimento minimo
 * @param {Number} miny Altura mínima
 * @deprecated Método não deve ser utilizado, efectuar o resize utilizando a especificação CSS3
 */
HElement.prototype.resize=function(mev,minx,miny){
	mev?mev:window.event;
	if(!minx)
		minx=0;
	if(!miny)
		miny=0;
	var pos=this.getPos();
	var xdiff=mev.clientX-pos.x;
	var ydiff=mev.clientY-pos.y;
	if(xdiff>minx)
		this.style.width=xdiff+"px";
	if(ydiff>miny)
		this.style.height=ydiff+"px";
}

/***
 * Objecto que representa uma contentor janela
 * @classDescription Este objecto representa um contentor janela. O propósito consiste em simular um ambiente desktop
 * a partir de construção de um conjunto de elementos e alguns métodos associados
 * @param {String} nel Nome do elemento
 * @param {String} titulo Titulo da janela
 * @param {String} bdcontent Conteudo do contentor
 * @param {Number} dimx Dimensão em X
 * @param {Number} dimy Dimensão em Y
 */
BLauLib.Window=function(nel,titulo,bdcontent,dimx,dimy){
	var nel=nel;
	this.dx=null;
	this.drag=false;
	this.dy=null;
	if(dimx && dimy){
		dx=Math.max(dimx,BLauLib.Window.MIN_WIDTH);
		dy=Math.max(dimy,BLauLib.Window.MIN_HEIGHT);
	}
	else{
		dx=300;
		dy=100;
	}
	this.titulo=titulo;
	if(!nel){
		nel=BLauLib.Window.COUNT;
		BLauLib.Window.COUNT++;
	}
	
	//contentor
	this.contentor=$$("div");
	
	//topbar
	this.tbbar=$$("div");
	imgclose=$$("img");
	//tabelatop
	var tbartable=$$("table");
	tbartable.className="tbwindow";
	//tbartable.setWidth(dx);
	
	//titulo
	this.divT=$$("div");
	this.divT.innerHTML=this.titulo;
	this.divT.className="titleheader";
	
	//divImgClose
	var divImgClose=$$("div");
	divImgClose.className="imgclose";
	
	//corpo
	this.bd=$$("div");
	this.bd.className="wcontent";
	
	this.contentor.className="wmain";
	this.contentor.id="wd_"+nel;
	this.contentor.setWidth(dx);
	var obj=this.contentor;
	var tbb=this.tbbar;
	//top bar
	this.tbbar.className="wheader";
	this.tbbar.id="tpbar_"+nel;
	//this.tbbar.setHeight(BLauLib.Window.TBAR_HEIGHT);
	
	
	imgclose.id="imgclose_"+nel;
	imgclose.src=BLauLib.Window.IMGCLOSE;
	var evimgclose=function(ev){
		var el=HElement.get(obj);
		var onimgclose=function(){
			el.parentNode.removeChild(el);
		}
		el.desvanece(0.2,onimgclose);
	}
	
	
	this.bd.className="wcontent";
	this.bd.id="bd_"+nel;
	this.bd.style.minHeight=dy+"px";
	this.bd.innerHTML=bdcontent;
	
	//adiciona os elementos ao top bar
	this.tbbar.appendChild(this.divT);
	divImgClose.appendChild(imgclose);
	this.tbbar.appendChild(divImgClose);
	
	//eventos
	var isto=this;
	this.tbbar.onmousedown=function(e){
		e=e?e:window.event;
		isto.drag=true;
		var elH=HElement.get(obj);
		var hD=HElement.get(tbb);
		var pnt=elH.startDrag(e.clientX,e.clientY,null);
	}
	
	this.tbbar.onmouseup=function(){
		document.onmousemove=null;
		isto.drag=false;
	}

	imgclose.onmouseup=evimgclose;
	this.contentor.appendChild(this.tbbar);
	this.contentor.appendChild(this.bd);
}

/**
 * Método que devolve o div contentor da janela
 */
BLauLib.Window.prototype.getContentor=function(){
	return this.contentor;
}

/**
 * Método que atribui uma determinada transparência à janela
 * @param {Number} val Transparência, valor entre 0 e 100
 */
BLauLib.Window.prototype.setAlpha=function(val){
	this.contentor.setAlpha(val);
}

/**
 * Método que permite especificar o conteúdo do contentor da janela
 * @param {String} val String contendo o HTML que irá ficar interno ao contentor da janela
 */
BLauLib.Window.prototype.setBodyContent=function(val){
	this.bd.innerHTML=val;
}

/**
 * Método que permite especificar o conteúdo da barra de título da janela
 * @param {String} titulo HTML com o conteúdo a passar para a janela de título
 */
BLauLib.Window.prototype.setTitle=function(titulo){
	this.divT.innerHTML=titulo;
}
/**
 * Objecto Canvas que encapsular um conjunto de funcionalidades a operar sobre o objecto canvas
 * @classDescription Neste objecto pretende-se encapsular um conjunto de funcionalidades que irão operar sob 
 * a tag canvas. Este objecto consiste numa pequena API para automatizar algumas ferramentas e funcionalidades de
 * computação visual que se pode efectuar recorrendo à especificação HTML5 
 * @param {String} id identificador do objecto canvas
 */
BLauLib.Canvas=function(id){
	this.canvas=$(id);
	if(this.canvas && this.canvas.getContext){
		this.c=this.canvas.getContext("2d");
	}
	else
		throw "O browser não suporta o objecto canvas";
}

/**
 * Método que especifica a função que será executada quando se efectua um varrimento da imagem pixel por pixel.
 * A função enviada para o método será invocada para todos os valores de pixel. 
 * @see #inverte
 * @see #noiseImage
 * @see #blackWhiteNoise
 * @see #Threshold
 * @param {Function} func Função callback
 * @param {Object} args Argumentos adicionais para a função callback
 */
BLauLib.Canvas.prototype._ppixelCallback=function(func,args){
	var imgd=this.c.getImageData(0,0,this.canvas.width,this.canvas.height);
	var pixs=imgd.data;
	var n=pixs.length;
	var sm=0;
	for(var i=0;i<n;i+=4){
		var arr=func(pixs[i],pixs[i+1],pixs[i+2],pixs[i+3],args);
		pixs[i]=arr[0];
		pixs[i+1]=arr[1];
		pixs[i+2]=arr[2];
		pixs[i+3]=arr[3];
	}
	this.c.putImageData(imgd,0,0);
}

/**
 * Método que efectua uma inversão de cor
 */
BLauLib.Canvas.prototype.inverte=function(){
	this._ppixelCallback(function(r,g,b,a){
		return [255-r,255-g,255-b,a];
	},null);
}

/**
 * Converte uma string para uma string de representação hexadecimal
 * @return {String} String com a representação hexadecimal
 */
String.prototype.Hexify=function(){
	var strout="";
	for(var i=0;i<this.length;i++){
		strout+="\\x"+this.charCodeAt(i).DecToHex();
	}
	return strout;
}

/**
 * Método que transforma uma string de codigos hexadecimais na sua representação de caracteres
 * @return {String} Devolve a string original
 */
String.prototype.DHexify=function(){
	var arrCods=this.split("\\x");
	var strout="";
	for(var i=1;i<=this.length;i++){
		strout+=String.fromCharCode(parseInt(arrCods[i],16));
	}
	return strout;
}

/**
 * Converte um número Decimal para a sua representação Hexadecimal
 * @return {Number} representação hexadecimal
 */
Number.prototype.DecToHex=function(){
	return this.toString(16);
}

/**
 * Converte um número Hexadecimal para a sua representação Decimal
 * @return {Number} representação Decimal
 */
Number.prototype.HexToDec=function(){
	return parseInt(this,16);
}


/**
 * Preenche a imagem a ruido com cores
 * @param {Number} alpha parametro de transparência 
 */
BLauLib.Canvas.prototype.noiseImage=function(alpha){
	this._ppixelCallback(function(){
		if(!arguments[4])			
			return [Math.floor(Math.random()*255),Math.floor(Math.random()*255),Math.floor(Math.random()*255),Math.floor(Math.random()*100)];
		return [Math.floor(Math.random()*255),Math.floor(Math.random()*255),Math.floor(Math.random()*255),arguments[4]];
	},alpha);
}

/**
 * Preenche a imagem a ruido a preto e branco
 */
BLauLib.Canvas.prototype.blackWhiteNoise=function(){
	this._ppixelCallback(function(){
		if(Math.random()>0.5)
			return [255,255,255,100];
		return [0,0,0,100]
	},null)
}


/***
 * Aplica threshold na imagem
 * @param {Number} treshold Limite de threshold
 */
BLauLib.Canvas.prototype.Threshold=function(tresh){
	this._ppixelCallback(function(px1,px2,px3,alpha,tr){
		var arr=[];
		sm=(px1+px2+px3)/3;
		if(sm<tr) arr[0]=arr[1]=arr[2]=0;else arr[0]=arr[1]=arr[2]=255;
		arr[3]=alpha;
		return arr;
	},tresh);
}

/**
 * Método que carrega uma imagem para o objecto canvas efectuando um redimensionamento
 * a partir do seu comprimento máximo
 * @param {String} src Endereço da imagem
 * @param {Number} xmax Comprimento máximo da imagem
 */
BLauLib.Canvas.prototype.loadScaledXImage=function(src,xmax){
	var img=new Image();
	var sfac=1;
	img.src=src;
	if (xmax && img.width > xmax) {
		sfac = xmax / img.width;
		img.width = img.width * sfac;
		img.height = img.height * sfac;
	}	
	this.canvas.width = img.width;
	this.canvas.height = img.height;
	this.c.drawImage(img,0,0,img.width,img.height);
	this.c.scale(sfac,sfac);
}

/**
 * Método que carrega uma imagem para o objecto canvas efectuando um redimensionamento
 * a partir da sua altura máxima
 * @param {String} src Endereço da imagem
 * @param {Number} xmax Altura máxima da imagem
 */
BLauLib.Canvas.prototype.loadScaledYImage=function(src,ymax){
	var img=new Image();
	var sfac=1;
	img.src=src;
	if (xmax && img.width > ymax) {
		sfac = ymax / img.height;
		img.width = img.width * sfac;
		img.height = img.height * sfac;
	}	
	this.canvas.width = img.width;
	this.canvas.height = img.height;
	this.c.drawImage(img,0,0,img.width,img.height);
	this.c.scale(sfac,sfac);
}


var HOSTNAME="";
var DIR_IMAGENS="";
BLauLib.Window.COUNT=0;
BLauLib.Window.TBAR_HEIGHT=25;
BLauLib.Window.BBAR_HEIGHT=25;
BLauLib.Window.MIN_HEIGHT=100;
BLauLib.Window.MIN_WIDTH=100;
BLauLib.Window.IMGCLOSE=HOSTNAME+DIR_IMAGENS+"close16.png";
BLauLib.Window.IMGRESIZE=HOSTNAME+DIR_IMAGENS+"resze.png";

BLauLib.Window.width=function(){
	return $('$html')[0].clientWidth;
}

BLauLib.Window.height=function(){
	return $('$html')[0].clientHeight;
}
BLauLib.Window.scrX=function(){
	return $('$html')[0].scrollLeft;
}

BLauLib.Window.scrY=function(){
	return $('$html')[0].scrollTop;
}

BLauLib.MsgBox=function(tipoMsg,msg,titulo){
	BLauLib.Window.apply(this, ["msg"+BLauLib.Window.COUNT,titulo,400,100]);
	this.bd.innerHTML=msg;
	return this.contentor;
}
/**
 * Método que efectua a transicao entre dois niveis de transparencia
 * @param {Number} alphaIni Percentagem de opacidade inicial
 * @param {Number} alphaFin Percentagem de opacidade final
 * @param {Number} seg Numero em segundos de duracao da transicao
 * @see #desvanece
 * @see #aparece
 * @see #getAlpha
 * @see #setAlpha
 */
HElement.prototype.transicaoAlpha=function(alphaIni,alphaFin,seg,callback){
	if(!this.ontransition){
		this.ontransition=true;
		var cresc=true;
		var transita=true;
		if(alphaIni>alphaFin)
			cresc=false;
		var passo=(alphaFin-alphaIni)/(seg*24);
		var alphaAct=alphaIni;
		var obj=this;
		var act=function(){
			if ((cresc === true && alphaAct > alphaFin) || (cresc === false && alphaAct < alphaFin)) {
				transita=false;
				if(alphaAct>100){
					obj.setAlpha(100)
				}
				if(alphaAct<0){
					obj.setAlpha(0);
				}
				obj.ontransition=false;
				clearInterval(i);
				if(callback!=null){
					callback();
				}
			}
			else{
				alphaAct+=passo;
				obj.setAlpha(alphaAct);
				
			}
		}
		if(transita)
			var i=setInterval(act,1000/30);
	}
};

/**
 * Método que remove um elemento filho a partir do seu identificador
 * @param {String} id Identificador do elemento a remover
 */
HElement.prototype.removeChildById=function(id){
	var cnt=this.childElementCount;
	var filho=null;
	for(var i=0;i<cnt;i++){
		filho=this[i];
		if(filho.id===id){
			this.removeChild(filho);
			cnt--;
		}
	}
	return this;
}

/**
 * Método que devolve o atributo do elemento a partir do seu identificador
 * @param {String} attribute Identificador do atributo
 * @return {Attribute} Elemento do tipo atributo
 */
HElement.prototype.getAttribute = function (attribute) {
    if (attribute == "class") attribute = "className";
    if (attribute == "for") attribute = "htmlFor";
    return this[attribute];
};

/**
 * Mecanismo responsavel por efectuar a troca de dois elementos
 * Este metodo esta em fase de testes
 * @param {HElement} el1 Elemento A
 * @param {HElement} el2 Elemento B
 */
HElement.swap=function(el1,el2){
	var p1=el1.parentNode;
	var p2=el2.parentNode;
	p1.insertBefore(el2.cloneNode(true),el1);
	p2.insertBefore(el1.cloneNode(true),el2);
	p1.removeChild(el1);
	p2.removeChild(el2);
};

/**
 * Metodo que especifica o valor para um dado atributo
 * Metodo em desenvolvimento. Sempre que hajam algumas incompatibilidades de browser detectadas na
 * especificacao de atributos deve-se alterar esta funcao para encapsular as diferencas
 * @param {String} attribute Valor 
 * @param {String} value Valor que se pretende associar ao atributo
 */
HElement.prototype.setAttribute = function (attribute, value) {
    if (attribute == "class") attribute = "className";
    if (attribute == "for") attribute = "htmlFor";
    this[attribute] = value;
};

/**
 * Método que especifica valores a atributos
 * @param {String} atr Nome do atributo
 * @param {Object} val Valor do atributo
 */
HElement.prototype.set=function(atr,val){
	this.setAttribute(atr, val);
}

/**
 * Método que adiciona um novo elemento filho ou um conjunto de elementos
 * @param {HElement} arg Elemento filho
 */
HElement.prototype.add=function(){
	if(arguments.length==1 && BLauLib.isArray(arguments[0])){
		var arg=arguments[0];
		for(var i=0;i<arg.length;i++){
			this.appendChild(arg[i]);
		}
	}else{
		for(var i=0;i<arguments.length;i++)
			this.appendChild(arguments[i]);
	}
};

/**
 * Método que efectua a conversao de um determinado elemento para a estrutura HElement
 * @param {Element} ele Objecto do tipo Element a converter
 * @return {HElement} Objecto do tipo HElemento equivalente ao elemento fornecido.
 */
HElement.get=function(ele){
	var el;
	if(typeof(ele)=='undefined')
			return null;
	if(typeof(ele)=="NodeList"){
		var cnt=ele.length;
		var out=[];
		for(var i=0;i<cnt;i++){
			out[i]=HElement.get(ele[i]);
		}
		return out;
	}
	if(typeof(ele)=="number"){
		return HElement.get(this.childNodes[ele]);
	}
	if(typeof(ele)=='string')
		el=document.getElementById(ele);
	else
		el=ele;
	var interf=new HElement();
	for(metodo in interf){
		//so assina se não estiver definido
		if(el[metodo]==undefined)
			try{el[metodo]=interf[metodo];}catch(e){}
	}
	return el;
};

/**
 * Método que desabilita um elemento
 * @param {Boolean} val True para desabilitar, false para habilitar
 * @param {Boolean} recurs Recursivo ou não recursivo
 */
HElement.prototype.disable=function(val,recurs){
	try{
		this.disabled=val?true:false;
	}
	catch (e) {}
	if(recurs){
		var cmp=this.childNodes.length;
		var hel=null;
		for(var i=0;i<cmp;i++){
			hel=HElement.get(this.childNodes[i]);
			if(hel.disable)
				hel.disable(val,recurs);
		}
	}
};

/**
 * Devolve o número de filhos de um HElement 
 * @return {Number} Número de filhos de um HElement
 */
HElement.prototype.length=function(){
	return this.childNodes.length;
}

/**
 * Devolve um elemento presente num HElement
 * @param {Object} ele Objecto
 * @return {HElement} 
 */
HElement.prototype.get=function(ele){
	if(arguments.length==0)
		return this.innerHTML;
	if(typeof(ele)=='string')
		idel=ele;
	else
		idel=ele.id;
	if(idel.charAt(0)=='#'){
		if(this.getElementsByClassName){
			return HElement.get(document.getElementsByClassName(idel.substr(1,idel.length)));
		}else
		{
			return HElement.get(getByClassName(idel.substr(1,idel.length)));
		}
	}
	if(idel.charAt(0)=='$'){
		return HElement.get(this.getElementsByTagName(idel.substr(1,idel.length)));
	}
	
	return HElement.get(document.getElementById(idel));
}

/**
 * Extende o metodo createElement para poder extender propriedades a elementos do IE
 * @param {String} tagName Nome de tag do objecto a criar
 */

HElement.createElement = function(tagName) {
    var element = document.createElement(tagName);
    var interf = new HElement();
    for (methodo in interf)
        element[methodo] = interf[methodo];
    return element;
};
/**
 * Método que remove elementos filhos a partir da sua posição ou valor 
 * @param {Number,Object} val
 */
HElement.prototype.clear=function(val){
	if(arguments.length==0){
		var ln=this.childNodes.length;
		for(var i=0;i<ln;i++){
			this.removeChild(this.childNodes[0]);
		}
	}
	else{
		if(typeof(val)=="number"){
			this.removeChild(this.childNodes[val]);
			return this;
		}
		this.removeChild(val);
	}
	return this;
}

HElement.prototype.remove=function(el){
	this.removeChild(el);
}

HElement.dragElements=[];

/**
 * Nao esta definido porque entra em conflito com o jQuery

Object.prototype.tipo=function()
{
	return "objecto";
}
*/
Boolean.prototype.tipo=function()
{return "booleano"};


var utils=function()
{
	this.parseTipo=function(tipo,objName,val)
	{
		var s="";
		if (tipo == "booleano") 
			s += this.parseBool(val);
		else if(tipo=="numero")
			s+=this.parseNumber(val);
		else if(tipo=="string")
			s+=this.parseString(val);
		else if(tipo=="array")
			s+=this.parseArray(val,"");
		else
			s+=this.parseObj(val,"");
		return s;
	}
	
	this.parseObj=function(obj,str)
	{
		str+="{";
		var k=0;
		var o=null;
		for(o in obj)
		{
			if(obj[o]==undefined){
				if (k == 0)
					str += '"'+o+'":undefined';
				else {
					str += ',"' + o+'":undefined';
				}
				k++;
			}
			else if(obj[o]==null){
				if(k==0){
					str += '"'+o+'":null';
				}
				else{
					str +='"'+o+'":null';
				}
			}
			else if (obj.propertyIsEnumerable(o) && typeof(obj[o].tipo)!="undefined") {
				if (k == 0)
					str += '"'+o+'":'+this.parseTipo(obj[o].tipo(), o, obj[o]);
				else {
					str += ',"' + o+'":' +this.parseTipo(obj[o].tipo(), o, obj[o]);
				}
				k++;
			}
			else{
				if (obj.propertyIsEnumerable(o)) {
					if (k == 0) 
						str += '"'+o + '":' + this.parseObj(obj[o], "");
					else 
						str += ',"' + o + '":' + this.parseObj(obj[o], "");
					k++;
				}
			}
		}
		return str+="}";
	}
	this.parseArray=function(obj,str)
	{
		str+="[";
		var k=0;
		var o=null;
		for(o in obj)
		{
			if(obj[o]==undefined){
				if (k == 0)
					str += '"'+o+'":undefined';
				else {
					str += ',"' + '"'+o+'":undefined';
				}
				k++;
			}
			else if(obj[o]==null){
				if(k==0){
					str += '"'+o+'":null';
				}
				else{
					str += '"'+o+'":null';
				}
			}
			else if (obj.propertyIsEnumerable(o) && typeof(obj[o].tipo)!="undefined") {
				if (k == 0)
					str += this.parseTipo(obj[o].tipo(), o, obj[o]);
				else {
					str += "," +this.parseTipo(obj[o].tipo(), o, obj[o]);
				}
				k++;
			}
			else{
				if (obj.propertyIsEnumerable(o)) {
					if (k == 0) 
						str += this.parseObj(obj[o], "");
					else 
						str += "," + this.parseObj(obj[o], "");
					k++;
				}
			}
		}
		return str+="]";
	}
	this.parseNumber=function(objVal)
	{
		var s=objVal;
		return s;
	}
	this.parseString=function(objVal)
	{
		var s='"'+objVal+'"';
		return s;
	}
}

utils.prototype.parseBool=function(val)
{
	if(val)
		return "true";
	return "false";
}

HElement.getFlashMovie=function(movieName) {
	  var isIE = navigator.appName.indexOf("Microsoft") != -1;
	  return (isIE) ? window[movieName] : document[movieName];
};

/**
 * Objecto com um conjunto de funcionalidades para gestão de eventos
 * @classDescription Para evitar que os eventos de rato e teclado associados ao elemento document sejam reassinados
 * causando bugs nas aplicações foi criado este objecto para encapsular a funcionalidades referidas. Aqui encontramos um
 * mecanismo de lista. Para cada evento existe uma lista com os métodos a invocar quando este é accionado. Desta forma 
 * pode-se ter mais do que uma função associada aos vários eventos disponíveis
 */
BLauLib.Events={
		loadwindow:[],
		mousemovewindow:[],
		mousedownwindow:[],
		mousemovedocument:[],
		mousedowndocument:[],
		addEvent:function(funcao,evento){
			var evList=this[evento];
			evList[evList.length]=funcao;
		},
		clearEvents:function(evento){
			if(this[evento])
				this[evento]=[];
		},
		WindowLoad:"loadwindow",
		WindowMouseMove:"mousemovewindow",
		WindowMouseDown:"mousedownwindow",
		DocumentMouseMove:"mousemovedocument",
		DocumentMouseDown:"mousedowndocument"
};


/**
 * Reeescreve o evento window.onload para que este suporte mais do que um evento
 */
window.onload=function(ev){
	for(var i=0;i<BLauLib.Events.loadwindow.length;i++){
		BLauLib.Events.loadwindow[i](ev);
	}
}

/**
 * Reescreve o evento onmousemove para que este suporte mais do que um evento
 */
window.onmousemove=function(ev){
	for(var i=0;i<BLauLib.Events.mousemovewindow.length;i++){
		BLauLib.Events.mousemovewindow[i](ev);
	}
}

window.onmousedown=function(ev){
	for(var i=0;i<BLauLib.Events.mousedownwindow.length;i++){
		BLauLib.Events.mousedownwindow[i](ev);
	}
}

document.onmousemove=function(ev){
	for(var i=0;i<BLauLib.Events.mousemovedocument.length;i++){
		BLauLib.Events.mousemovedocument[i](ev);
	}
}

document.onmousedown=function(ev){
	for(var i=0;i<BLauLib.Events.mousedowndocument.length;i++){
		BLauLib.Events.mousedowndocument[i](ev);
	}
}


/**
 * Objecto que contem um conjunto de metodos de validação de expressões regulares
 * para as principais entradas de formulário 
 */
BLauLib.Valida={
		numerico:function(val){
			return val.valida(/^[0-9]+$/);
		},
		maxchar:function(val,maxchar){
			return val.valida("^[a-zA-Z0-9]{0,"+maxchar+"}$");
		},
		codPostalA:function(val){
			return val.valida(/^[0-9]{4}$/);
		},
		codPostalB:function(val){
			return val.valida(/^[0-9]{3}$/);
		},
		email:function(val){
			return val.valida(/^[a-zA-Z0-9_.%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,4}$/);
		},
		webpage:function(val){
			return val.valida(/^(http:\/\/)?[a-zA-Z0-9.]+\.[a-zA-Z]{2,4}(.)+$/);
		},
		telefone:function(val){
			return val.valida(/^([0-9]{0,3})?[0-9]{9}$/);
		}
}
/**
 * Método que converte uma string json para o seu correspondente objecto
 */
BLauLib.FromJSON=function(a){
	if(JSON.parse)
		return JSON.parse(a);
	return eval('('+a+')');
}

BLauLib.isFunction=function(obj){
	return (typeof obj=="function");
}

BLauLib.isString=function(obj){
	return (typeof obj=="string");
}

BLauLib.isUndefined=function(obj){
	return (typeof obj=="undefined");
}

BLauLib.isNull=function(obj){
	return (obj==null);
}

BLauLib.isArray=function(obj){
	return BLauLib.isUndefined(obj)||BLauLib.isNull(obj)?false:(obj.constructor==Array);
}

/**
 * Método que converte um objecto para a sua representação JSON
 * @return {String} Representação JSON do objecto
 */
Object.prototype.toJSON =function() {
	var obj=this;
    var t = typeof (obj);  
    if (t != "object" || obj === null) {  
        // simple data type  
        if (t == "string") obj = '"'+obj+'"';  
        return String(obj);  
    }  
    else {  
        // recurse array or object  
        var n, v, json = [], arr = (obj && obj.constructor == Array);  
        for (n in obj) {
            v = obj[n]; t = typeof(v);
            if(t!="function"){
	            if (t == "string") v = '"'+v+'"';  
	            else if (t == "object" && v !== null) v = v.toJSON();  
	            json.push((arr ? "" : '"' + n + '":') + String(v));
            }
        }  
        return (arr ? "[" : "{") + json + (arr ? "]" : "}");  
    }  
}; 
/**
 * Método que codifica uma string para uma outra que consiste na sequencia de numeros representando
 * o caracter sob a numeração ascii separados por um caracter especial
 * @param {Object} caracterseparador Caracter de separação
 */
String.prototype.toUnicodeArray=function(caracterseparador){
	var i=0;
	var stB=new StringBuilder("");
	for(i=0;i<this.length;i++)
	{
		if(i==0)
			stB.append(String(this.charCodeAt(i)));
		else
			stB.append(caracterseparador+this.charCodeAt(i));
	}
	return stB.toString();
}
/**
 * Metodo que verifica se a string e um endereco de email
 * @return {@link Boolean} Verdadeiro caso a string seja um endereco de email, falso caso contrario
 */
String.prototype.isEmail=function(){
	var emailPattern = /^[a-zA-Z0-9._-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,4}$/;  
	   return emailPattern.test(this);  
};


/**
 * Método que transforma uma string codificada contendo os codigos unicode da string separados por um caracter separador.
 * para o seu valor descodificado
 * @param {String} caracter separador
 * @return {String} String correspondente à  dada pela codificação unicode
 */
String.prototype.fromUnicodeArray=function(caracterseparador)
{
	var arrS=this.split(caracterseparador);
	var strOut="";
	for(i=0;i<arrS.length;i++)
	{
		strOut+=String.fromCharCode(arrS[i]);
	}
	return strOut;
}

/**
 * Método que codifica uma string em formato UTF-8
 * @return {String} String no formato UTF-8
 */
String.prototype.encodeUTF8=function(){
	var string = this.replace(/\r\n/g,"\n");
	var utftext = "";

	for (var n = 0; n < string.length; n++) {

		var c = string.charCodeAt(n);

		if (c < 128) {
			utftext += String.fromCharCode(c);
		}
		else if((c > 127) && (c < 2048)) {
			utftext += String.fromCharCode((c >> 6) | 192);
			utftext += String.fromCharCode((c & 63) | 128);
		}
		else {
			utftext += String.fromCharCode((c >> 12) | 224);
			utftext += String.fromCharCode(((c >> 6) & 63) | 128);
			utftext += String.fromCharCode((c & 63) | 128);
		}
	}
	return utftext;
}

/**
 * Método que descodifica uma string do formato UTF-8
 * @return {String} String descodificada
 */
String.prototype.decodeUTF8=function(){
	var string = "";
	var i = 0;
	var c = c1 = c2 = 0;

	while ( i < this.length ) {

		c = this.charCodeAt(i);

		if (c < 128) {
			string += String.fromCharCode(c);
			i++;
		}
		else if((c > 191) && (c < 224)) {
			c2 = this.charCodeAt(i+1);
			string += String.fromCharCode(((c & 31) << 6) | (c2 & 63));
			i += 2;
		}
		else {
			c2 = this.charCodeAt(i+1);
			c3 = this.charCodeAt(i+2);
			string += String.fromCharCode(((c & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63));
			i += 3;
		}
	}
	return string;
}

var Priberam=function(){
	this.descricao="";
	this.NDIV=32;
	this.onLoaded=null;
}

var DragHandler = {
		 
		// private property.
		_oElem : null,
	 
		// public method. Attach drag handler to an element.
		attach : function(oElem,dgEl) {
			oElem.onmousedown = DragHandler._dragBegin;
			_dgEl=dgEl;
			// callbacks
			oElem.dragBegin = new Function();
			oElem.drag = new Function();
			oElem.dragEnd = new Function();
			return oElem;
		},
	 
	 
		// private method. Begin drag process.
		_dragBegin : function(e) {
			var oElem = DragHandler._oElem = this;
	 
			if (isNaN(parseInt(oElem.style.left))) { oElem.style.left = '0px'; }
			if (isNaN(parseInt(oElem.style.top))) { oElem.style.top = '0px'; }
	 
			var x = parseInt(oElem.style.left);
			var y = parseInt(oElem.style.top);
	 
			e = e ? e : window.event;
			oElem.mouseX = e.clientX;
			oElem.mouseY = e.clientY;
	 
			oElem.dragBegin(oElem, x, y);
	 
			document.onmousemove = DragHandler._drag;
			document.onmouseup = DragHandler._dragEnd;
			return false;
		},
	 
	 
		// private method. Drag (move) element.
		_drag : function(e) {
			var oElem = DragHandler._oElem;
	 
			var x = parseInt(oElem.style.left);
			var y = parseInt(oElem.style.top);
	 
			e = e ? e : window.event;
			oElem.style.left = x + (e.clientX - oElem.mouseX) + 'px';
			oElem.style.top = y + (e.clientY - oElem.mouseY) + 'px';
	 
			oElem.mouseX = e.clientX;
			oElem.mouseY = e.clientY;
	 
			oElem.drag(oElem, x, y);
	 
			return false;
		},
	 
	 
		// private method. Stop drag process.
		_dragEnd : function() {
			var oElem = DragHandler._oElem;
	 
			var x = parseInt(oElem.style.left);
			var y = parseInt(oElem.style.top);
	 
			oElem.dragEnd(oElem, x, y);
	 
			document.onmousemove = null;
			document.onmouseup = null;
			DragHandler._oElem = null;
			alert("END");
		}
	}

Priberam.prototype.get=function(pal){
	var aj=new BLauLib.Ajax();
	var dc;
	var obj=this;
	aj.addVar("url","http://www.priberam.pt/dlpo/default.aspx?pal="+encodeURI(pal));
	aj.onLoaded=function(){
		var eltmp=document.createElement('hidden');
		eltmp.innerHTML=aj.text;
		var dvs=eltmp.getElementsByTagName("div");
		obj.descricao=dvs[obj.NDIV].innerHTML.decodeUTF8();
		obj.onLoaded();
	};
	aj.open("POST","http://localhost/wbservices/wb_loadurl");
	aj.send(aj.encPostVars());
};

/**
 * Método que contém um conjunto de funcionalidades para o processamento de captchas
 * @classDescription Este objecto pretende fornecer um conjunto de funcionalidades de manipulação de imagens gerados pelo
 * sistema RECaptcha
 * @param {String} pubkey Chave pública
 * @param {String} privkey Chave privada
 * @author Balhau
 */
var RECaptcha=function(pubkey,privkey){
	this.publickey=pubkey;
	this.privatekey=privkey;
	this.challenge="";
	this.challengeURL=RECaptcha.ServerName+"challenge?k="+this.publickey;
}

/**
 * Método que utiliza um script de servidor para guardar imagens geradas pelo serviço RECaptcha
 * @param {String} imgname Nome da imagem que pretendemos guardar
 */
RECaptcha.prototype.saveImage=function(imgname){
	var aj=new BLauLib.Ajax();
	var obj=this;
	aj.onLoaded = function(){
		var resp = aj.text;
		resp=resp.split(";")[0];
		resp=resp.split(",");
		resp=resp[1].split(":");
		resp=resp[1].replace(/'/gi,"");
		obj.challenge=resp;
		var naj=new BLauLib.Ajax();
		var urlImg=RECaptcha.ServerName+"image?c="+resp.trim();
		naj.addVar("url",urlImg);
		naj.addVar("imgname",imgname);
		naj.onLoaded=function(){
		}
		naj.callPost(RECaptcha.PHPCallbackFile);
	}
	aj.open("GET",RECaptcha.PHPRedirectFile+"?url="+this.challengeURL);
	aj.send(null);
}

/**
 * Nome do ficheiro que efectua o processamento das imagens geradas pelo mecanismo RECaptcha 
 */
RECaptcha.PHPCallbackFile="save.php";

/**
 * Nome do ficheiro que funciona como proxy para endereços externos.
 */
RECaptcha.PHPRedirectFile="redirect.php";

/**
 * Endereço do serviço RECaptcha 
 */
RECaptcha.ServerName="http://www.google.com/recaptcha/api/";