//<![CDATA[
/********
** @tit:	~[R.F.L.B]~JavaScript Library [rbJavaScriptLib]
** @desc:	Criar uma biblioteca com funções uteis e facilmente utilizáveis usando javascript
** @per:	Janeiro de 2010
** @ver:	1.0
** @aut:	Rafael Benites
*******/
/*** ### VARIÁVEIS ### ***/
var br = '\n';
/*** ###### FUNÇÕES GERAIS ###### ***/
/********
** @tit:	rbFake
** @desc:	Função faz nada
** @args:	void
** @rets:	void
***/
function rbFake(){}
/******
** @tit:	rb$
** @desc:	Função que tenta encontrar um objeto html com um id que o referencie, se um objeto passado apenas retornamos
** @args:	myId[string, Object], id do elemento
** @rets:	Retorna um objeto ou falso;
*******/
function rb$(myId){
	var obj = false;
	if(typeof(myId) == 'object')
		return myId;
	myId = rbTrim(myId);
	if(myId != ''){
		obj = document.getElementById(myId); 
		if(!obj && document.all)
			obj = document.all[myId];
	}
	return obj;
}
/******
** @tit:	rbSetDefault()
** @desc: 	Função que verifica se um elemento esta indefinido, em caso positivo atribui o valor passado como default
** @args:	atual[*], valor[*]
** @rets: 	valor do elemento, ou valor default;
*******/
function rbSetDefault(atual, valor){
	return typeof(atual) == 'undefined' ?  valor : atual;
}
/******
** @tit:	rbRand()
** @desc: 	Função que gera um número inteiro aleatório
** @args:	max[integer], número maior
** @rets: 	randomico[integer];
*******/
function rbRand(max){
	num = rbSetDefault(max, 10000);
	return (Math.round((Math.random()*(num-1))));
}
/******
** @tit:	rbIsIe()
** @desc: 	Função que identifica se o browser corrente é o Internet Explorer
** @args:	versao[string] uma versão especifica
** @rets: 	boolean;
*******/
function rbIsIe(versao){
	var str = 'msie', agent = navigator.userAgent.toLowerCase();
	versao = rbSetDefault(versao, '');
	if(versao != '')
		str += ' '+versao;
	return agent.indexOf(str) > 0;
}

/********
** @tit:	rbTrim
** @desc:	Limpa espaços do fim e do inicio de uma string
** @args:	str[string]
** @rets:	[string] sem espaços extras
***/
function rbTrim(str){
	if(typeof(str) == 'undefined')
		return '';
	return str.replace(/^\s+|\s+$/g,'');
}
/******
** @tit:	rbAddSlashes()
** @desc: 	Função que adiciona barras invertidas similar a addslashes(php)
** @args:	str[string]
** @rets: 	string;
*******/
function rbAddSlashes(str) {
	str = str.replace(/\\/g,'\\\\');
	str = str.replace(/\'/g,'\\\'');
	str = str.replace(/\"/g,'\\"');
	str = str.replace(/\0/g,'\\0');
	return str;
}
/********
** @tit:	rbNL2BR()
** @desc:	Função que substitui '\n' por '<br />'
** @args:	str[string] string para substituição
** @rets:	[string]
***/
function rbNL2BR(str){
	str = rbSetDefault(str, '');
	return str.replace(/\n/g,'<br />');
}
/********
** @tit:	rbPrF()
** @desc:	Função de formatação, substitui %r por outros argumentos
** @args:	base[string], argumentos ...
** @rets:	[string]
**
** @obsv:	Só será verificada a falta de argumentos!
***/
function rbPrF(){
	if(arguments.length <2)
		return '';
	var tot = arguments.length, base = arguments[0], n = base.length, last ='', k = 1, ret = '', cur;
	for(i=0; i<n;i++){
		cur = base.charAt(i);
		if(cur === 'r' && last === '%'){
			if(k > (tot - 1)){
				alert(rbPrintf('Erro @ rbPrF() missing argument [%r]',k));
				return '';
			}
			ret += arguments[k++];
		}
		else if(last === '%' && cur !== 'r')
			ret += last+cur;
		else if(cur !== '%')
			ret += cur;
		last = cur;
	}
	return ret;
}
/******
** @tit:	rbIsArray()
** @desc: 	Função que diz se um elemento é um array
** @args:	elem[object]
** @rets: 	boolean;
*******/
function rbIsArray(elem){
	return typeof(elem)=='object'&&(elem instanceof Array);
}
/******
** @tit:	rbInArray()
** @desc: 	Função que diz se um elemento esta em uma lista
** @args:	el[*],arr[array[*]], strict[boolean] se é '===' ou '=='
** @rets: 	boolean;
*******/
function rbInArray(el, arr, strict){
	strict = rbSetDefault(strict, false);
	if(rbIsArray(arr))
		if(strict)
			for(ind in arr)
				if(arr[ind] === el)
					return true;
		else
			for(ind in arr)
				if(arr[ind] == el)
					return true;
	else
		return strict ? el ===arr : el == arr;
	return false;
}
/******
** @tit:	rbStripTags()
** @desc: 	Função que tenta remover tags [markup] de uma string
** @args:	valor[string]
** @rets: 	valor[string], sem tags;
*******/
function rbStripTags(valor){
	valor = rbTrim(valor);
	valor = valor.replace(/<\/?[^>]+>/gi, "");
	return valor;	
}
/******
** @tit:	rbUntag()
** @desc: 	Função que retira tags html, > < " e coloca HTML entities
** @args:	cont[string]
** @rets: 	string;
*******/
function rbUnTag(cont){
	cont = rbTrim(cont);
	cont = cont.replace('<', '&lt;');
	cont = cont.replace('>', '&gt;');
	cont = cont.replace(/\"/g, '&quot;');
	return cont;
}
/********
** @tit:	rbAddEvent
** @desc:	Função que adiciona um evento
** @args:	elm[obj, string] elemento que receberá o evento, evnt[string] tipo do evento
**			func[string] função que será usada, usec[boolean]
** @rets:	[boolean, void]
***/
function rbAddEvent(elm, evnt, func, usec){
	elm = rb$(elm);
	if(elm){
		if (elm.addEventListener){
			elm.addEventListener(evnt, func, usec);
			return true;
		}
		if (elm.attachEvent)
			return elm.attachEvent('on' + evnt, func);
		elm['on' + evnt] = func;
		return false;
	}
	alert('Erro @rbAddEvent() elemento desconhecido');
}
/********
** @tit:	rbInfo()
** @desc:	Função que tenta extrair informações de um elemento
** @args:	elem[object, string] elemento a ser buscado
** @rets:	[string]
***/
function rbInfo(elem){
	var msg ='';
	elem = rb$(elem);
	for(i in elem){
		try{
			msg += rbPrf('[%r] = %r; %r',i.toString(), elem[i].toString(), br);
		}catch(e){}
	}
	return msg;
}
/******
** @tit:	rbFill()
** @desc: 	Função que atribui um conteudo ao value[input] ou html[outros] de um objeto
** @args:	elem[object, string], valor[*], tipo[ 1 -> sobrescreve; 2->insere no final; 3->insere no começo]
** @rets: 	void;
*******/
function rbFill(elem, cont, tipo){
	var elem = rb$(elem);
	if(elem){
		tipo = rbSetDefault(tipo, 1);
		switch(elem.tagName.toLowerCase()){
			case 'input':
				switch(elem.type.toLowerCase()){
					case 'checkbox':
						if(elem.value == cont)
							elem.checked = true;
						return;
					break;
					case 'radio':
						var n = rbSetDefault(elem.length, 0), i=0, set=false;
						if(n == 0){
							if(elem.value == cont)
								elem[i-1].checked = set = true;
							return;
						}
						while(i < n && !set){
							if(elem[i++].value == cont)
								elem[i-1].checked = set = true;
						}
						return;
					break;
					default: break;
				}
			case 'textarea':
				try{
						if(tipo == 1)
							elem.value = cont;
						else{
							if(tipo == 2)
								elem.value += cont;
							else
								elem.value = cont + elem.innerHTML;
						}
				}
				catch(err){}
			break;
			case 'select':
				var n = elem.length, i=0, set=false;
				while(i < n && !set){
					if(elem[i++] ===cont)
						elem[i-1].selected = set = true;
				}				
			break;
			default:
				try{
					if(tipo == 1)
						elem.innerHTML = cont;
					else{
						if(tipo == 2)
							elem.innerHTML += cont;
						else
							elem.innerHTML = cont + elem.innerHTML;
					}
				}
				catch(err){}
			break;
		}
	}
}
/******
** @tit:	rbGet()
** @desc: 	Função que retorna o value[input, select, option, textarea] ou o innerHTML[outros] de um elemento
** @args:	elem[object, string]
** @rets: 	string;
*******/
function rbGet(elem){
	elem = rb$(elem);
	if(elem){
		switch(elem.tagName.toLowerCase()){
			case 'input':
			case 'select':
			case 'option':
			case 'textarea':
				return elem.value;
			break;
		default:
			return elem.innerHTML;
		break;
		}
	}
	return '';
}
/******
** @tit:	rbDisplay()
** @desc: 	Função que altera o display de um elemento
** @args:	elem[string, object], valor[string; 'block, none, inline,...', nenhuma verificação ao tipo de display]
** @rets: 	void;
*******/
function rbDisplay(elem, valor){
	elem = rb$(elem);
	if(elem){
		valor = rbSetDefault(valor, 'block');
		try{
			elem.style.display = valor;
		}catch(e){}
	}
}
/******
** @tit:	rbSetBorder()
** @desc: 	Função que adiciona borda a um elemento
** @args:	el[string, object]id do elemento, bSize[integer] tamanho da borda, bStyle[string] estilo da borda, bColor[string], cor da borda;
** @rets: 	void;
*******/
function rbSetBorder(el, bSize, bStyle, bColor){
	try{
		el = rb$(el);
		bSize = rbSetDefault(bSize, 1);
		bStyle = rbSetDefault(bStyle, 'solid');
		bColor = rbSetDefault(bColor, '#F00');
		temp = el.style.border;
		el.style.border = rbPrF('%rpx %r %r', bSize, bStyle, bColor);
		el.onkeyup = function(){this.style.border = temp;};
		el.focus();
	}catch(err){}
}
/******
** @tit:	rbAddStyle()
** @desc: 	Função que adiciona um estilo[css] ao <head> de uma pagina html
** @args:	conteudo[string], o codigo do estilo, id[string], id do style
** @rets: 	void;
*******/
function rbAddStyle(conteudo, id){
	var stl = document.createElement('style');
	try{
		id = rbSetDefault(id, '');
		if(id != '')
			stl.setAttribute("id", id);
		stl.setAttribute("type", "text/css");
		head = document.getElementsByTagName('head')[0];
		head.appendChild(stl);
		if(rbIsIe())
			stl.styleSheet.cssText = conteudo;	
		else
			stl.appendChild(document.createTextNode(conteudo));
	}
	catch(err){}
}
/******
** @tit:	rbValidSWF()
** @desc: 	Função que inclui um embed flash valido [x]HTML
** @args:	objswf[string], params[string], width[integer], height[integer]
** @rets: 	[string];
*******/
function rbValidSWF(objswf, params, wth, hgt){
	cont  = '<!--[if !IE]> -->' + br;
	cont += '<object type="application/x-shockwave-flash"' + br;
	cont += rbPrF('data="%r?%r" width="%r" height="%r">%r', objswf, params, wth, hgt, br);
	cont += '<param name="wmode" value="opaque" />' + br;
	cont += '<!-- <![endif]-->' + br;
	cont += '<!--[if IE]>' + br;
	cont += '<object classid="clsid:D27CDB6E-AE6D-11cf-96B8-444553540000"' + br;
	cont += rbPrF('codebase="http://download.macromedia.com/pub/shockwave/cabs/flash/swflash.cab#version=6,0,0,0" width="%r" height="%r">', wth, hgt);
	cont += rbPrF('<param name="movie" value="%r?%r" />%r', objswf, params, br);
	cont += '<!--><!-- rbAddValidEmbed -->' + br;
	cont += '</object>' + br;
	cont += '<!-- <![endif]-->' + br;
	return cont;
}
/******
** @tit:	rbMouseCoord()
** @desc: 	Classe para guardar os dados do mouse
** @requ:	uma chamada a função rbMouseInitialize é necessária
*******/
function rbMouseCoord(){
	this.x=0;
	this.y=0;
	this.getX = function(){ return this.x;}
	this.getY = function(){ return this.y;}
	this.set = function(x, y){this.x=x;this.y=y;}
}
/******
** @tit:	rbMouse
** @desc: 	Variável global que receberá uma instância de rbMouseCoord usado onmousemove
*******/
var rbMouse = new rbMouseCoord();
/******
** @tit:	rbMouseInitialize()
** @desc: 	Função que inicializa a captura do mouse, e instancia um objeto rbMouseCoord()
** @args:	void
** @rets: 	void;
*******/
function rbMouseInitialize(){
	if(window.Event){
		document.captureEvents(Event.MOUSEMOVE);
	}
	document.onmousemove = rbSetCoordinates;
}
/******
** @tit:	rbSetCoordinates()
** @desc: 	Função que seta os valores do mouse, seta a instancia de rbMouseCoord[rbMouse]
** @args:	e[event] necessário firefox;
** @rets: 	void;
*******/
function rbSetCoordinates(e){
	var x=0,y=0;
	if(window.Event){
		x = e.pageX;
		y = e.pageY;
	}
	else{
		x = event.clientX + (document.documentElement.scrollLeft? document.documentElement.scrollLeft: document.body.scrollLeft);
		y = event.clientY + (document.documentElement.scrollTop ? document.documentElement.scrollTop : document.body.scrollTop );
	}
	rbMouse.set(x,y);
}
/*** ### COOKIES ### ***/
/******
** @tit:	rbCreateCookie()
** @desc: 	Função que adiciona um cookie guardando um valor por algum tempo
** @args:	name[string], value[*], days[integer]
** @rets: 	void;
*******/
function rbCreateCookie(name, value, days) {
	var expires = "", date = new Date();
	if(days){
		date.setTime(date.getTime()+(days*24*60*60*1000));
		expires = rbPrF("expires=%r", date.toGMTString());
	}
	document.cookie = rbPrF("%r=%r; %r; path=/", name, value, expires);
}
/******
** @tit:	rbReadCookie()
** @desc: 	Função que busca por um cookie
** @args:	name[string]
** @rets: 	valor[string, null]
*******/
function rbReadCookie(name) {
	var nameI = name + "=", ca = document.cookie.split(';'), c, i;
	for(i=0;i < ca.length;i++) {
		c = rbTrim(ca[i]);
		if (c.indexOf(nameI) == 0)
			return c.substring(nameI.length,c.length);
	}
	return null;
}
/******
** @tit:	rbEraseCookie()
** @desc: 	Função que 'apaga' um cookie
** @args:	name[string]
** @rets: 	void;
*******/
function rbEraseCookie(name) {
	rbCreateCookie(name,"",-1);
}
/***
############
#BEGIN: AJAX
############
***/
/******
** @tit:	rbAjaxTry()
** @desc: 	Classe para uso de ajax
*******/
function rbAjaxTry(){
/** ###########	Variaveis ########### **/
	/******
	** @tit:	rbAjaxTry::elem;
	** @desc: 	Pode ser que a tarefa seja apenas preencher um elemento com a 
	**			resposta assim a classe ja faz isso  pra vc 
	*****/
	this.elem;
	/******
	** @tit:	rbAjaxTry::modo;
	** @desc: 	forma que a resposta vai ser adicionada 1-> sobrescrever; 2->por no fim; 3-> por no comeco;
	*****/
	this.modo = 1;
	/******
	** @tit:	rbAjaxTry::response
	** @desc: 	Guarda a última resposta recebida
	******/
	this.response;
	/******
	** @tit:	rbAjaxTry::msg
	** @desc: 	Mensagem relevante apos cada processo
	******/
	this.msg = false;
	/******
	** @tit:	rbAjaxTry::req
	** @desc: 	Variável XMLHTTP;
	******/
	this.req = false;
	/******
	** @tit:	rbAjaxTry::debug
	** @desc: 	variavel que define o debug;
	******/
	this.debug = false;
	/******
	** @tit:	rbAjaxTry::numReq
	** @desc: 	variavel que define o número de chamadas ativas;
	******/
	this.numReq = 0;
/** ###########	Funções gerais ########### **/
	/******
	** @tit:	rbAjaxTry::setDebug()
	** @desc: 	Função que ativa ou desativa o debug
	** @args:	void;
	** @rets: 	void;
	*******/
	this.setDebug = function(){
		this.debug = !this.debug;
	}
	/******
	** @tit:	rbAjaxTry::numOfRequests()
	** @desc: 	Função que ativa seta e retorna o numero de requisições ativas
	** @args:	integer, void;
	** @rets: 	integer;
	*******/
	this.numOfRequests = function(val){
		val = rbSetDefault(val, 0);
		this.numReq += val;
		return this.numReq;
	}
	/******
	** @tit:	rbAjaxTry::setMessage()
	** @desc: 	Função que seta e retorna a ultima mensagem relevante da classe
	** @args:	string, void;
	** @rets: 	string;
	*******/
	this.setMessage = function(mens){
		this.msg = rbSetDefault(mens, this.msg);
		return this.msg;
	}
	/******
	** @tit:	rbAjaxTry::setXMLHTTPVar()
	** @desc: 	Função que ativa a funcionalidade do ajax e retorna-a;
	** @args:	void
	** @rets: 	Um objeto que provê funcionalidades do ajax;
	*******/
	this.setXMLHTTPVar = function(){
		if(this.debug)
			alert('@ rbAjaxTry::setXMLHTTPVar()');
	/* variavel ja setada */	
		if(this.req)
			return this.req;
	/* activexobject */
		if(window.ActiveXObject){
			var i =0,
				teste = new Array("Microsoft.XMLHTTP", "Msxml2.XMLHTTP", "MSXML.XMLHTTP", "MSXML3.XMLHTTP");
			while(i<4 && !this.req){
				try{
					this.req = new ActiveXObject(teste[i++]);
				}catch(e){}
			}
			if(this.req)
				return this.req;
		}
	/* tentamos se for possivel usando window.XMLHttpRequest */
		if(window.XMLHttpRequest){ 
			this.req = new XMLHttpRequest();
			return this.req
		}
	/* createrequest */
		if(window.createRequest){
			this.req = window.createRequest();
			return this.req;
		}
		/* se a variavel ainda é falsa não foi possível criar */
		this.setMessage('Erro @ rbAjaxTry::setXMLHTTPVar() #Não existe a possibilidade de usar ajax!');
		return false;
	}
	/******
	** @tit:	rbAjaxTry::setDiv()
	** @desc: 	Função que busca um elemento e o seta[objeto ou string] caso o encontre retorna sua referência 
	**			e ajusta o modo de como será preenhido
	** @args:	string, object; modo[integer] 1->sobrescrever; 2-. pornofim; 3-> por no inicio
	** @rets: 	object, false;
	*******/
	this.setDiv = function(elem, modo){
		if(this.debug)
			alert('@ rbAjaxTry::setDiv()');
		elem = rbSetDefault(elem, '');
		if(elem != ''){
			var obj = rb$(elem);
			this.elem = obj ? obj : elem;
			this.modo = rbSetDefault(modo, 1);
		}
		return this.elem;
	}
	/******
	** @tit:	rbAjaxTry::initialize()
	** @desc: 	Função que inicializa a classe
	** @args:	divID, referencia a quem receberá as respostas
	** @rets: 	void;
	*******/
	this.initialize = function(divID, modo){
		if(this.debug)
			alert('rbAjaxTry::initialize()');
		this.setXMLHTTPVar();
		divID = rbSetDefault(divID,'');
		if(divID != '')
			this.setDiv(divID, modo);
	}
/** ###########	Funções de retorno ########### **/
	/******
	** @tit:	rbAjaxTry::alertResponse()
	** @desc: 	Função que exibe a resposta recebida por meio de um window.alert
	** @args:	response[function], função para ser avaliada ao término,
	** 			tipo[integer], qual resposta 1-> text; 2 ->xml
	** @rets: 	void;
	*******/
	this.alertResponse = function (response, tipo){
		if (this.req.readyState == 4){
			if (this.req.status == 200 || this.req.status == 0){
				this.numOfRequests(-1);
				if(tipo == 1)
					this.response = this.req.responseText;
				else
					this.response = this.req.responseXML;
				alert(this.response);
				eval(response+'()');
			}
			else{
				this.setMessage(this.req.statusText);
			}
		}
	}
	/******
	** @tit:	rbAjaxTry::fillResponse()
	** @desc: 	Função que tenta  preencher o elemento com o valor da resposta
	** @args:	response[function], função para ser avaliada ao término,
	** 			tipo[integer], qual resposta 1-> text; 2 ->xml
	** 			modo[integer], como preencher 1-> sobrescrever; 2 ->por no fim; 3-> por no começo;
	** @rets: 	void;
	*******/
	this.fillResponse = function (response, tipo){
		if (this.req.readyState == 4){
			if (this.req.status == 200 || this.req.status == 0){
				this.numOfRequests(-1);
				if(tipo == 1)
					this.response = this.req.responseText;
				else
					this.response = this.req.responseXML;
				/* tenta preencher o div */
				rbFill(this.elem, this.response, this.modo);
				eval(response+'()');
			}
			else{
				this.setMessage(this.req.statusText);
			}
		}
	}
	/******
	** @tit:	rbAjaxTry::externalResponse()
	** @desc: 	Função que apenas manda a resposta para ser executada por uma funcao passada
	** @args:	response[function], função para ser avaliada ao término,
	** 			tipo[integer], qual resposta 1-> text; 2 ->xml
	** @rets: 	void;
	*******/
	this.externalResponse = function (response, tipo){
		if (this.req.readyState == 4){
			if (this.req.status == 200 || this.req.status == 0){
				this.numOfRequests(-1);
				if(tipo == 1)
					this.response = this.req.responseText;
				else
					this.response = this.req.responseXML;
				if(this.debug)
					alert(rbPrF("%r('%r')", response,rbAddSlashes(this.response)));
				eval(response+"('"+rbAddSlashes(this.response)+"')");
			}
		}
	}
/** ###########	Funções de Chamadas ########### **/
	/******
	** @tit:	rbAjaxTry::makeRequest()
	** @desc: 	Função que faz equisicao por GET
	** @args:	path[string] a url;
	**			response[function] uma funcao que sera executada ao termino
	**			tipo[string] -> 1 -> text; 2 -> xml
	** @rets: 	object, false;
	*******/
	this.makeRequest = function(path, response, tipo){
		if(this.debug)
			alert(rbPrF('rbAjaxTry::makeRequest() 2 %r',path));
		/* prepara a funcao */
		if(!this.req || rbIsIe()){
			this.req = null;
			if(!this.setXMLHTTPVar())				
				return false;
		}
		/* define a resposta */
		response = rbSetDefault(response, 'rbFake');
		tipo = rbSetDefault(tipo, 1);
		this.numOfRequests(1);
		var This = this;
		if(this.elem)
			this.req.onreadystatechange = function(){This.fillResponse(response, tipo);};
		else if(this.debug)
			this.req.onreadystatechange = function(){This.alertResponse(response, tipo);};
		else
			this.req.onreadystatechange = function(){This.externalResponse(response, tipo);};
		this.req.open("GET", path, true);
		this.req.send(null);
	}
	/******
	** @tit:	rbAjaxTry::sendRequest()
	** @desc: 	Função que envia uma requisição por POST
	** @args:	path[string] a url;
	**			params[function] os parametros enviados
	**			response[function] uma funcao que sera executada ao termino
	**			tipo[string] -> 1 -> text; 2 -> xml
	** @rets: 	object, false;
	*******/
	this.sendRequest = function(path, params, response, tipo){
		if(this.debug)
			alert(rbPrF("rbAjaxTry::sendRequest('%r') 2 %r", params, path));
		if(!this.req || rbIsIe()){
			this.req = false;
			if(!this.setXMLHTTPVar())				
				return false;
		}
		/* define a resposta */
		response = rbSetDefault(response, 'rbFake');
		tipo = rbSetDefault(tipo, 1);
		this.numOfRequests(1);
		this.req.open("POST", path, true);
		this.req.setRequestHeader("Content-type", "application/x-www-form-urlencoded");
		this.req.setRequestHeader("Content-length", params.length);
		this.req.setRequestHeader("Connection", "close");
		var This = this;
		if(this.elem)
			this.req.onreadystatechange = function(){This.fillResponse(response, tipo);};
		else if(this.debug)
			this.req.onreadystatechange = function(){This.alertResponse(response, tipo);};
		else
			this.req.onreadystatechange = function(){This.externalResponse(response, tipo);};
		this.req.send(params);
	}
};
/***
############
#END: AJAX
############
***/
/** ###########	Validações ########### **/

/******
** @tit:	rbDefaultError()
** @desc: 	Função que exibe a mensagem de campo vazio
** @args:	empty[string]
** @rets: 	void;
*******/
function rbDefaultError(empty, msg){
	msg = rbSetDefault(msg, 'O campo [%r] não pode ser vazio');
	try{
		var tmp = empty.split('_');
		tmp =  tmp.length > 1 ? tmp[1] : tmp[0];
		alert(rbPrF(msg, tmp));
		rbSetBorder(empty);
	}catch(e){}
}
/********
** @tit:	rbDataValidation()
** @desc:	Função de validação com alguns padrões definidos
** @args:	valor[string], tipo[string]
** @rets: 	boolean
*******/

function rbValidation(value, tipo){
	switch(tipo){
		case "alfanum":
			return (/^\w+$/).test(value);
		break;
		case "numero":
			return (/^\d+[,.]\d+$/).test(value);
		break;
		case "letra":
			return (/^[a-z]+$/).test(value.toLowerCase());
		break;
		case "email":
			return(/^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*(\.[a-z]{2,3})$/).test(value);
		break;
		case "bissexto":
			return ( (value % 4==0) && (value % 100 != 0) || (value % 400==0));
		break;
		case "data":
			format = (/^\d{2}[-\/]\d{2}[-\/]\d{1,4}$/).test(value);
			if(!format) return false;
			dia = parseInt(value.substr(0,2), 10);
			mes = parseInt(value.substr(3,2), 10);
			ano = parseInt(value.substr(6), 10);
			if(mes < 1  || mes > 12)
				return false;
			if(dia > 31 || dia < 1)
				return false;
			if( rbInArray(mes,['4','5','9', '11'], true) )
				return dia < 31;
			if( mes == 2)
				return dia < 29 || ( dia == 29 && rbValidation(ano, 'bissexto') );
			return true;
		break;
		case "hora":
			return (/^([0-1]\d|2[0-3]):[0-5]\d(:[0-5]\d)?$/).test(value);
		break;
		case "semespaco":
			return !(/\s/g).test(value);
		break;
		case "senha":
			return (/^[a-zA-Z0-9_\.\-\*]{4,}$/).test(value);
		break;
		default:
			alert( rbPrF('Tipo[%r] desconhecido para avaliar [%r]\n', tipo, value) );
			return true;
		break;
	}
}

/******
** @tit:	rbValidaForm()
** @desc: 	Função que verifica se os campos não são vazios, caso full setado usa rbValidation
** @args:	base do caminho, campos a serem validados, usar rbValidation, função a ser executada
** @rets: 	boolean;
*******/
function rbValidaForm(base, campos, full, func){
	full = rbSetDefault(full, false);
	if(!rbIsArray(campos)){
		alert('Error @ rbValidaForm o arg 2 deve ser um array');
		return false;
	}
	func = rbSetDefault(func, 'rbDefaultError');
	var n = campos.length, el, val;
	/* verifica se todos campos são não vazios */
	for(i=0; i<n; i++){
		try{
			el = rb$(base+campos[i]);
			val = rbTrim(rbGet(el));
			rbFill(el, val);
			if(val == ''){
				eval(func+"('"+base+campos[i]+"')");
				return false;
			}
			if(full){
				switch(campos[i]){
					case 'senha':
					case 'password':
						if(!rbValidation(val, 'senha')){
							eval(func+"('"+base+campos[i]+"', 'Senhas devem ter no mínimo 4 caracteres, compostas de letras, números ou -.*_')");
							return false;
						}
					break;
					case 'login':
					case 'user':
					case 'usuario':
						if(!rbValidation(val,'semespaco')){
							eval(func+"('"+base+campos[i]+"', 'Nome de usuário[login] não pode conter espaços')");
							return false;
						}
					break;
					case 'email':
						vals = val.split(";");
						for(var i=0; i < vals.length; i++){
							if(!rbValidation(vals[i], 'email')){
								eval(func+"('"+base+campos[i]+"', 'O formato do email é inválido!(user@servidor;)+')");
								return false;
							}
						}
					break;
					case 'data':
					case 'quando':
					case 'nascimento':
						if(!rbValidation(val, 'data')){
							eval(func+"('"+base+campos[i]+"', 'A data fornecida é inválida(dd-mm-aaaa)!')");
							return false;
						}
					break;
					default:
					break;
				}
			}
		}catch(err){}
	}
	return true;
}
/********
** @tit:	inverteData()
** @desc:	Recebe uma data no formato dd-mm-yyyy e devolve no formato yyyy-mm-aa e vice-versa
** @args:	data[string]
** @rets:	string
***********/
function inverteData(data){
	/* busca pelo separador */
	var i=0;
	while( /\d/.test(data.charAt(i)) )
		i++;
	var tag = data.charAt(i);
	/* quebra a data */
	data = data.split(tag);
	/* formata */
	return data[2]+"-"+data[1]+"-"+data[0];
}
/********
** @tit:	setOpacity()
** @desc:	seta a opacidade de um elemento
** @args:	el[string, object], value[integer]
** @rets:	void
***********/
function setOpacity(el, value){
	var obj = rb$(el);
	try{
		obj.style.opacity = value/100;
		obj.style.filter = 'alpha(opacity='+value+')';
	}catch(err){}
} 
// ]]>