///////////////////////////////////////////////////////////////////////////////////
//
// -> main.js <- JavaScript generic functions
// Created by: Diego dos Santos <diegodsp ig.com.br>
//
// *** IMPORTANT ***
// FREE USE!!!
//
///////////////////////////////////////////////////////////////////////////////////

function myPostBack(eventTarget, eventArgument) {
	var theform = document.forms[0];
	theform.__EVENTTARGET.value = eventTarget.split("$").join(":");
	theform.__EVENTARGUMENT.value = eventArgument;
	theform.submit();
}

///////////////////////////////////////////////////////////////////////////////////
// UTILIDADES
///////////////////////////////////////////////////////////////////////////////////

// when press ENTER, submit
function enter2Submit(e, obj, btnId) {
	if (window.event) key = event.keyCode;
	else key = e.which;
    if (key == 13) {
		document.getElementById(btnId).click();
		// obj.form.submit();
		if (window.event)
			event.returnValue = true;
		else
			return true;
    }
}

// blockEnter
function blockEnter(e, obj) {
	if (window.event) key = event.keyCode;
	else key = e.which;
	if (key == 13) {
		if (window.event) {
			event.keyCode = 9;
			event.returnValue = true;
		} else {
			e.which = 9;
		}
	}
}

// uso interno
function prepareKey(e, obj) {
	if (window.event) key = event.keyCode;
	else key = e.which;
	if (key == 8) return null;
    if (key == 9 || key == 16) {
		obj.select();
		return null;
    }
    return key;
}

///////////////////////////////////////////////////////////////////////////////////

// colore o fundo de um TD
// exemplo de uso:
//      <td onmouseover="setBg(this, '#RGB')" onmouseout="setBg(this, '#RGB')"></td>
function setBg(obj, newColor) {
    // descobre se o browser é opera
    if (typeof(window.opera) == 'undefined' &&
        typeof(obj.getAttribute) != 'undefined') {
        // curColor = obj.getAttribute('bgcolor');
        domDetect = true;
    } else {
        // curColor = obj.style.backgroundColor;
        domDetect = false;
    }
    // seta a nova cor de fundo
    if (domDetect) {
    	obj.style.cursor = 'pointer';
        obj.style.backgroundColor = newColor;
    } else {
        obj.setAttribute('bgcolor', newColor, 0);
    }
}

///////////////////////////////////////////////////////////////////////////////////

// openPopup
// abre uma janela de acordo com os parâmetros
// @param url
// @param winName Nome da janela
// @param width
// @param height
// @param scroll "yes" ou "no" (literal)
// @param resizable "yes" ou "no" (literal)
// @return nada
function openPopup(_url,_winName,_width,_height,_scroll,_resize) {
	// show popup on middle of screen
	_y = (screen.height - _height) / 2;
	_x = (screen.width - _width) / 2;
	var win = window.open(_url,_winName,'toolbar=no,location=no,directories=no,status=no,menubar=no,scrollbars='+_scroll+',resizable='+_resize+',copyhistory=no,top='+_y+',left='+_x+',screenY='+_y+',screenX='+_x+',width='+_width+',height='+_height);
	win.focus();
	return win;
}

///////////////////////////////////////////////////////////////////////////////////
// DATA
///////////////////////////////////////////////////////////////////////////////////

// formatDate
// formata a data no formato (dd/mm/yyyy)
// @param objeto input onde está a data
// @return nada
function formatDate(e, obj) {
	key = prepareKey(e, obj);
	if (key == null) return;

    // formato dd/mm/yyyy
    if ((obj != null) && (obj.value.length > 0)) {
		obj.value = stripSpecialChars(obj.value);
		
		if (obj.value.length > 8) {
            // > 8, é exagero, tira fora
            obj.value = obj.value.substring(0, 8);
        }
        
        // se for menor que 8 está digitando a data
        if (obj.value.length <= 8) {
            reg = new RegExp("^([0-9]{2})([0-9]{2})([0-9]{4})$", "g");
            obj.value = obj.value.replace(reg, "$1/$2/$3");
        }
    }
}

///////////////////////////////////////////////////////////////////////////////////

// isDate
// verifica se a data está em formato (dd/mm/yyyy)
// @param testa a data
// @return boolean
function isDate(data) {
    // formato dd/mm/yyyy
    if ((data != null) && (data.length > 0)) {
        reg = new RegExp("^([0-9]{2})+/([0-9]{2})+/([0-9]{4})+$", "g");
        if (reg.test(data)) {
            // quebra a data
            s = data.split("/");
            
            // faz assim devido a um erro do parseInt com 08 e 09
            if (s[0] == '08') s[0] = '8';
            if (s[0] == '09') s[0] = '9';
            if (s[1] == '08') s[1] = '8';
            if (s[1] == '09') s[1] = '9';
            
            dia = parseInt(s[0]);
            mes = parseInt(s[1]);
            ano = parseInt(s[2]);
            
            // verifica se o mês está entre 1 e 12
            if (mes < 1 || mes > 12) return false;
            
        	// verifica se o dia está de acordo com o mês
            if (mes == 1 || mes == 3 || mes == 5 || mes == 7 || mes == 8 || mes == 10 || mes == 12)
        		if (dia < 1 || dia > 31) return false;
        	if (mes == 2) {
        		if (isLeapYear(ano)) {
        			if (dia < 1 || dia > 29) return false;
        		} else {
        			if (dia < 1 || dia > 28) return false;
        		}
        	}
        	if (mes == 4 || mes == 6 || mes == 9 || mes == 11)
            	if (dia < 1 || dia > 30) return false;
            
            // se chegou até aqui, é pq tá ok
            return true;
        } else {
            return false;
        }
    } else {
        return false;
    }
}

///////////////////////////////////////////////////////////////////////////////////

// isLeapYear
// verifica se o ano é um ano bissexto
// @param testa o ano
// @return boolean
function isLeapYear(ano) {
    if ((ano != null) && (ano.length > 0))
    	if (ano % 4 == 0 && (ano % 100 != 0 || ano % 400 == 0 )) return true;
	// se chegou até aqui é pq não é
	return false;
}

///////////////////////////////////////////////////////////////////////////////////
// PHONE
///////////////////////////////////////////////////////////////////////////////////

// isPhone
// verifica se o telefone está no formato brasileiro
// formato 9999-9999
// @param telefone
// @return true ou false
function isPhone(phone) {
    // formato 9999-9999
    if ((phone != null) && (phone.length > 0)) {
        reg = new RegExp("^([0-9]{3,4})+(-[0-9]{4})+$", "g");
        return reg.test(phone);
    } else {
        return false;
    }
}

///////////////////////////////////////////////////////////////////////////////////

// formatPhone
// formata o telefone no formato brasileiro
// formato 9999-9999
// @param objeto onde está o telefone
// @return nada
function formatPhone(e, obj) {
	key = prepareKey(e, obj);
	if (key == null) return;

    // formato 9999-9999
    if ((obj != null) && (obj.value.length > 0)) {
		obj.value = stripSpecialChars(obj.value);
        // obj.value = obj.value.replace(/-/g, "");
        // se for menor que 8 está digitando o telefone
        if (obj.value.length <= 8) {
            // obj.value = obj.value.replace("-", "");
            reg = new RegExp("^([0-9]{3,4})+(-)?([0-9]{4})+$", "g");
            obj.value = obj.value.replace(reg, "$1-$3");
        } else {
            // > 8, é exagero, tira fora
            obj.value = obj.value.substring(0, 9);
        }
    }
}

///////////////////////////////////////////////////////////////////////////////////
// CEP
///////////////////////////////////////////////////////////////////////////////////

// formatZipCode
// formata o cep no formato brasileiro
// formato 99999-999
// @param objeto onde está o cep
// @return nada
function formatZipCode(e, obj) {
	key = prepareKey(e, obj);
	if (key == null) return;

    // formato 99999-999
    if ((obj != null) && (obj.value.length > 0)) {
        // se for menor que 9 está digitando o cep
        if (obj.value.length <= 9) {
			obj.value = stripSpecialChars(obj.value);
            // obj.value = obj.value.replace(/-/g, "");
            reg = new RegExp("^([0-9]+)+([0-9]{3})+$", "g");
            obj.value = obj.value.replace(reg, "$1-$2");
        } else {
            // > 9, é exagero, tira fora
            obj.value = obj.value.substring(0, 9);
        }
    }
}

///////////////////////////////////////////////////////////////////////////////////

// getZipFromZipCode
// pega o valor de cep formatado ou não
// @param cep
// @return número
function getZipCode(zipcode) {
    // formato 99999-999
    if ((zipcode != null) && (zipcode.length > 0)) {
        reg = new RegExp("^([0-9]+)+(-)?([0-9]{3})+$", "g");
        return zipcode.replace(reg, "$1$3");
    } else {
        return 0;
    }
}

///////////////////////////////////////////////////////////////////////////////////

// isZipCode
// verifica se é um cep válido
// formato 99999-999
// @param cep
// @return boolean
function isZipCode(zipcode) {
    // formato 99999-999
    if ((zipcode != null) && (zipcode.length > 0)) {
        reg = new RegExp("^([0-9]+)+(-[0-9]{3})+$", "g");
        return reg.test(zipcode);
    } else {
        return false;
    }
}

///////////////////////////////////////////////////////////////////////////////////
// MOEDA
///////////////////////////////////////////////////////////////////////////////////

// formatCurrency
// formata o número em moeda com o número de casas decimais informado em decimals
// formato 9999,99 ou 9999,n
// @param objeto onde está o valor
// @param número de casas decimais do valor
// @return nada
function formatCurrency(e, obj, decimals) {
	key = prepareKey(e, obj);
	if (key == null) return;

    // formato 9999,n
    if ((obj != null) && (obj.value.length > 0)) {
		obj.value = stripSpecialChars(obj.value);
        // obj.value = obj.value.replace(/,/g, "");
        // obj.value = obj.value.replace(/\./g, "");
        reg = new RegExp("^([0-9]+)+([0-9]{" + decimals + "})+$", "g");
        obj.value = obj.value.replace(reg, "$1,$2");
    }
}

///////////////////////////////////////////////////////////////////////////////////

// getValueFromCurrency
// pega o valor de um número formatado ou não
// @param número
// @param número de casas decimais do número
// @return número
function getValueFromCurrency(num, decimals) {
    // formato 9999,n -> 9999n
    if ((decimals == null) || (decimals < 0))
        decimals = 2;
    if ((num != null) && (num.length > 0)) {
        reg = new RegExp("^([0-9]+)+(,)?([0-9]{" + decimals + "})?$", "g");
        num = num.replace(reg, "$1$3");
        return (num / Math.pow(10, decimals));
    } else {
        return 0;
    }
}

///////////////////////////////////////////////////////////////////////////////////
// NÚMERO
///////////////////////////////////////////////////////////////////////////////////

// formatNumber
// só deixa inserir números
// @param número
// @return boolean
function formatNumber(e, obj) {
	key = prepareKey(e, obj);
	if (key == null) return;

    if (((key >= 65) && (key <= 90)) || (key == 32) || (key == 110) || (key == 188) || (key == 190)) {
		if (window.event) {
			e.keyCode=0;
			e.returnValue=false;
        } else
			return false;
    }
}

///////////////////////////////////////////////////////////////////////////////////

// isNumber
// verifica se é um número válido
// formato 9 ou 999,99 ou 9999,n
// @param número
// @return boolean
function isNumber(num, decimals) {
    // formato 9999,n
    if ((decimals == null) || (decimals < 0))
        decimals = 0;
    if ((num != null) && (num.length > 0)) {
        reg = new RegExp("^([0-9]+)+([\.,]{1})?([0-9]{" + decimals + "})?$", "g");
        return reg.test(num);
    } else {
        return false;
    }
}

///////////////////////////////////////////////////////////////////////////////////
// HORA
///////////////////////////////////////////////////////////////////////////////////

// formatTime
// formata a hora no formato (hh:mm[:ss])
// @param objeto input onde está a hora
// @return nada
function formatTime(e, obj) {
	key = prepareKey(e, obj);
	if (key == null) return;

    // formato hh:mm:ss
    if ((obj != null) && (obj.value.length > 0)) {
        // se for menor que 8 está digitando a hora
        if (obj.value.length <= 8) {
            // primeira parte hh:
            reg = new RegExp("^([0-9]{2})+$", "g");
            obj.value = obj.value.replace(reg, "$1:");
            // segunda parte hh:mm:
            reg = new RegExp("^([0-9]{2})+([0-9]{2})+$", "g");
            obj.value = obj.value.replace(reg, "$1:$2");
            // terceira parte hh:mm:ss
            reg = new RegExp("^([0-9]{2})+:([0-9]{2})+\:?([0-9]{2})+$", "g");
            obj.value = obj.value.replace(reg, "$1:$2:$3");
        } else {
            // > 8, é exagero, tira fora
            obj.value = obj.value.substring(0, 8);
        }
    }
}

///////////////////////////////////////////////////////////////////////////////////

// isTime
// Verifica se a o valor está em formato hh:mm ou hh:mm:ss
// @param texto contendo a hora
// @return boolean
function isTime(hora) {
    if ((hora != null) && (hora.length > 0)) {
        reg = new RegExp("^([0-9]{2})+:([0-9]{2})+(:[0-9]{2})?$", "g");
        if (reg.test(hora)) {
            s = hora.split(":");
            // hora
            sTime = parseInt(s[0]);
            // minuto
            sMin = parseInt(s[1]);
            // segundo
            sSec = 0;
            if (s.length == 3)
                sSec = parseInt(s[2]);
            // testa para ver se é valida
        	if ((sTime < 0) || (sTime > 23) ||
                (sMin < 0) || (sMin > 59) ||
                (sSec < 0) || (sSec > 59)) return false;
            return true;
        }
    } else {
        return false;
    }
}

///////////////////////////////////////////////////////////////////////////////////
// EMAIL
///////////////////////////////////////////////////////////////////////////////////

// isEMail
// verifica se é um email válido
// @param email
// @return boolean
function isEmail(email) {
    if ((email != null) && (email.length > 0)) {
        reg = new RegExp("^[_a-zA-Z0-9\-\.]+@[_a-zA-Z0-9\-]+(\.[_a-zA-Z0-9\-]+)+$", "g");
        return reg.test(email);
    } else {
        return false;
    }
}

///////////////////////////////////////////////////////////////////////////////////
// STRINGS
///////////////////////////////////////////////////////////////////////////////////

// isCNPJ
// verifica se é um cnpj válido
// @param cnpj
// @return boolean
function isCNPJ(cnpj) {
    if ((cnpj != null) && (cnpj.length > 0)) {
        reg = new RegExp("^([0-9]{2})+\.([0-9]{3})+\.([0-9]{3})+\/([0-9]{4})+\-([0-9]{2})+$", "g");
        return reg.test(cnpj);
    } else {
        return false;
    }
}

///////////////////////////////////////////////////////////////////////////////////

// CNPJ
// formata o CNPJ
// @param objeto input onde está o CNPJ
// @return nada
function formatCNPJ(e, obj) {
	key = prepareKey(e, obj);
	if (key == null) return;

    // formato CNPJ (xx.xxx.xxx/xxxx-xx)
    if ((obj != null) && (obj.value.length > 0)) {
        // se for menor que 18 está digitando o CNPJ
        if (obj.value.length <= 18) {
            // primeira parte
            reg = new RegExp("^([0-9]{2})+$", "g");
            obj.value = obj.value.replace(reg, "$1.");
            // segunda parte
            reg = new RegExp("^([0-9]{2})+\.([0-9]{3})+$", "g");
            obj.value = obj.value.replace(reg, "$1.$2.");
            // terceira parte
            reg = new RegExp("^([0-9]{2})+\.([0-9]{3})+\.([0-9]{3})+$", "g");
            obj.value = obj.value.replace(reg, "$1.$2.$3/");
            // quarta parte
            reg = new RegExp("^([0-9]{2})+\.([0-9]{3})+\.([0-9]{3})+\/([0-9]{4})+$", "g");
            obj.value = obj.value.replace(reg, "$1.$2.$3/$4-");
            // quinta parte
            reg = new RegExp("^([0-9]{2})+\.([0-9]{3})+\.([0-9]{3})+\/([0-9]{4})+\-([0-9]{2})+$", "g");
            obj.value = obj.value.replace(reg, "$1.$2.$3/$4-$5");
        } else {
            // > 18, é exagero, tira fora
            obj.value = obj.value.substring(0, 18);
        }
    }
}

///////////////////////////////////////////////////////////////////////////////////

// isCPF
// verifica se é um cpf válido
// @param cpf
// @return boolean
function isCPF(cpf) {
    if ((cpf != null) && (cpf.length > 0)) {
        reg = new RegExp("^([0-9]{3})+\.([0-9]{3})+\.([0-9]{3})+\-([0-9]{2})+$", "g");
        return reg.test(cpf);
    } else {
        return false;
    }
}

///////////////////////////////////////////////////////////////////////////////////

// CPF
// formata o CPF
// @param objeto input onde está o CPF
// @return nada
function formatCPF(e, obj) {
	key = prepareKey(e, obj);
	if (key == null) return;

    // formato CPF (xxx.xxx.xxx-xx)
    if ((obj != null) && (obj.value.length > 0)) {
        // se for menor que 14 está digitando o CPF
        if (obj.value.length <= 14) {
            // primeira parte
            reg = new RegExp("^([0-9]{3})+$", "g");
            obj.value = obj.value.replace(reg, "$1.");
            // segunda parte
            reg = new RegExp("^([0-9]{3})+\.([0-9]{3})+$", "g");
            obj.value = obj.value.replace(reg, "$1.$2.");
            // terceira parte
            reg = new RegExp("^([0-9]{3})+\.([0-9]{3})+\.([0-9]{3})+$", "g");
            obj.value = obj.value.replace(reg, "$1.$2.$3-");
            // quarta parte
            reg = new RegExp("^([0-9]{3})+\.([0-9]{3})+\.([0-9]{3})+\-([0-9]{2})+$", "g");
            obj.value = obj.value.replace(reg, "$1.$2.$3-$4");
        } else {
            // > 14, é exagero, tira fora
            obj.value = obj.value.substring(0, 14);
        }
    }
}

///////////////////////////////////////////////////////////////////////////////////

// toISO
// transforma o texto passado em ISO-8859-1
// @param texto
// @return texto alterado
function toISO(value) {
    if ((value != null) && (value.length > 0)) {
    	var accents = "áàãââÁÀÃÂéêÉÊíÍóõôÓÔÕúüÚÜÿýçÇabcdefghijklmnopqrstuvxwyz";
    	var noAccents ="AAAAAAAAAEEEEIIOOOOOOUUUUYYCCABCDEFGHIJKLMNOPQRSTUVXWYZ";
    	var position = null;
    	var character = null;
    	var retVal = ""; 
    	for (var i = 0; i < value.length; i++) {
    		character = value.charAt(i);
    		position = accents.indexOf(character);
    		if (position > -1)
    			retVal += noAccents.charAt(position);
    		else  
    			retVal += value.charAt(i);
    	}
    	return (retVal);
    } else {
        return value;
    }
}

///////////////////////////////////////////////////////////////////////////////////

// stripSpecialChars
// retira os caracteres especiais
// @param valor
// @return o valor tratado
function stripSpecialChars(value) {
    value = value.replace(/,/g, "");
    value = value.replace(/\¦/g, "");
    value = value.replace(/|/g, "");
    value = value.replace(/\./g, "");
    value = value.replace(/;/g, "");
    value = value.replace(/\//g, "");
    value = value.replace(/\\/g, "");
    value = value.replace(/|/g, "");
    value = value.replace(/</g, "");
    value = value.replace(/>/g, "");
    value = value.replace(/:/g, "");
    value = value.replace(/\?/g, "");
    value = value.replace(/\"/g, "");
    value = value.replace(/'/g, "");
    value = value.replace(/!/g, "");
    value = value.replace(/@/g, "");
    value = value.replace(/#/g, "");
    value = value.replace(/$/g, "");
    value = value.replace(/%/g, "");
    value = value.replace(/\¨/g, "");
    value = value.replace(/&/g, "");
    value = value.replace(/\*/g, "");
    value = value.replace(/\(/g, "");
    value = value.replace(/\)/g, "");
    value = value.replace(/-/g, "");
    value = value.replace(/_/g, "");
    value = value.replace(/\+/g, "");
    value = value.replace(/=/g, "");
    value = value.replace(/\§/g, "");
    value = value.replace(/\ª/g, "");
    value = value.replace(/\º/g, "");
    value = value.replace(/\´/g, "");
    value = value.replace(/\`/g, "");
    value = value.replace(/\[/g, "");
    value = value.replace(/\{/g, "");
    value = value.replace(/\]/g, "");
    value = value.replace(/\}/g, "");
    value = value.replace(/^/g, "");
    value = value.replace(/~/g, "");
    value = value.replace(/\¹/g, "");
    value = value.replace(/\²/g, "");
    value = value.replace(/\³/g, "");
    value = value.replace(/\£/g, "");
    value = value.replace(/\¢/g, "");
    value = value.replace(/\¬/g, "");
    value = value.replace(/\./g, "");
    return value;
}

///////////////////////////////////////////////////////////////////////////////////

// ltrim
// retira os espaços à esquerda do texto
// @param texto
// @return texto alterado
function ltrim(s){
    if ((s != null) && (s.length > 0))
    	return s.replace(/^\s*/, '');
}
	
///////////////////////////////////////////////////////////////////////////////////

// rtrim
// retira os espaços à direita do texto
// @param texto
// @return texto alterado
function rtrim(s){
    if ((s != null) && (s.length > 0))
    	return s.replace(/\s*$/, '');
}
	
///////////////////////////////////////////////////////////////////////////////////

// trim
// retira os espaços dos dois lados do texto
// @param texto
// @return texto alterado
function trim(s){
    if ((s != null) && (s.length > 0))
    	return rtrim(ltrim(s));
}
	
///////////////////////////////////////////////////////////////////////////////////

// changeImage
// troca a imagem informada pela imagem informada
// @param nome do objeto imagem
// @param nova imagem
// @return nada
function changeImage2(imgName, img) {
	document.images[imgName].src = img;
}

// with object
function changeImage(obj, src) {
	obj.src = src;
}
	
///////////////////////////////////////////////////////////////////////////////////
// TESTE DE BROWSERS
///////////////////////////////////////////////////////////////////////////////////

// browser
// como se fosse uma classe
// @return o objeto
function browser(){
	this.ver = navigator.appVersion;
	this.agent = navigator.userAgent;
	this.dom = document.getElementById ? 1 : 0;
	this.ie5 = (this.ver.indexOf("MSIE 5") > -1 && this.dom) ? 1 : 0;
	this.ie6 = (this.ver.indexOf("MSIE 6") > -1 && this.dom) ? 1 : 0;
	this.ie4 = (document.all && !this.dom) ? 1 : 0;
	this.ie = this.ie4 || this.ie5 || this.ie6;
	this.mac = this.agent.indexOf("Mac") > -1;
	this.opera = this.agent.indexOf("Opera") > -1;
	this.opera5 = this.agent.indexOf("Opera 5") >- 1;
	this.ns6 = (this.dom && parseInt(this.ver) >= 5) ? 1 : 0;
	this.ns4 = (document.layers && !this.dom)? 1 : 0;
	this.ne = this.ns6 || this.ns4;
	return this;
}
	
///////////////////////////////////////////////////////////////////////////////////

// isIE
// cria o objeto browser e verifica se é IE
// @return boolean
function isIE() {
	var browser_ = new browser();
	return browser_.ie;
}
	
///////////////////////////////////////////////////////////////////////////////////

// isNE
// cria o objeto browser e verifica se é NE
// @return boolean
function isNE() {
	var browser_ = new browser();
	return browser_.ne;
}
	
///////////////////////////////////////////////////////////////////////////////////
// AJAX
///////////////////////////////////////////////////////////////////////////////////

//////////////////
// Helper Stuff //
//////////////////

// used to find the Automation server name
function getDomDocumentPrefix() {
	if (getDomDocumentPrefix.prefix)
		return getDomDocumentPrefix.prefix;
	
	var prefixes = ["MSXML2", "Microsoft", "MSXML", "MSXML3"];
	var o;
	for (var i = 0; i < prefixes.length; i++) {
		try {
			// try to create the objects
			o = new ActiveXObject(prefixes[i] + ".DomDocument");
			return getDomDocumentPrefix.prefix = prefixes[i];
		}
		catch (ex) {};
	}
	
	throw new Error("Could not find an installed XML parser");
}

function getXmlHttpPrefix() {
	if (getXmlHttpPrefix.prefix)
		return getXmlHttpPrefix.prefix;
	
	var prefixes = ["MSXML2", "Microsoft", "MSXML", "MSXML3"];
	var o;
	for (var i = 0; i < prefixes.length; i++) {
		try {
			// try to create the objects
			o = new ActiveXObject(prefixes[i] + ".XmlHttp");
			return getXmlHttpPrefix.prefix = prefixes[i];
		}
		catch (ex) {};
	}
	
	throw new Error("Could not find an installed XML parser");
}

//////////////////////////
// Start the Real stuff //
//////////////////////////


// XmlHttp factory
function XmlHttp() {}

XmlHttp.create = function () {
	try {
		if (window.XMLHttpRequest) {
			var req = new XMLHttpRequest();
			
			// some versions of Moz do not support the readyState property
			// and the onreadystate event so we patch it!
			if (req.readyState == null) {
				req.readyState = 1;
				req.addEventListener("load", function () {
					req.readyState = 4;
					if (typeof req.onreadystatechange == "function")
						req.onreadystatechange();
				}, false);
			}
			
			return req;
		}
		if (window.ActiveXObject) {
			return new ActiveXObject(getXmlHttpPrefix() + ".XmlHttp");
		}
	}
	catch (ex) {}
	// fell through
	throw new Error("Your browser does not support XmlHttp objects");
};

// XmlDocument factory
function XmlDocument() {}

XmlDocument.create = function () {
	try {
		// DOM2
		if (document.implementation && document.implementation.createDocument) {
			var doc = document.implementation.createDocument("", "", null);
			
			// some versions of Moz do not support the readyState property
			// and the onreadystate event so we patch it!
			if (doc.readyState == null) {
				doc.readyState = 1;
				doc.addEventListener("load", function () {
					doc.readyState = 4;
					if (typeof doc.onreadystatechange == "function")
						doc.onreadystatechange();
				}, false);
			}
			
			return doc;
		}
		if (window.ActiveXObject)
			return new ActiveXObject(getDomDocumentPrefix() + ".DomDocument");
	}
	catch (ex) {}
	throw new Error("Your browser does not support XmlDocument objects");
};

// Create the loadXML method and xml getter for Mozilla
if (window.DOMParser &&
	window.XMLSerializer &&
	window.Node && Node.prototype && Node.prototype.__defineGetter__) {

	// XMLDocument did not extend the Document interface in some versions
	// of Mozilla. Extend both!
	//XMLDocument.prototype.loadXML = 
	Document.prototype.loadXML = function (s) {
		
		// parse the string to a new doc	
		var doc2 = (new DOMParser()).parseFromString(s, "text/xml");
		
		// remove all initial children
		while (this.hasChildNodes())
			this.removeChild(this.lastChild);
			
		// insert and import nodes
		for (var i = 0; i < doc2.childNodes.length; i++) {
			this.appendChild(this.importNode(doc2.childNodes[i], true));
		}
	};
	
	
	/*
	 * xml getter
	 *
	 * This serializes the DOM tree to an XML String
	 *
	 * Usage: var sXml = oNode.xml
	 *
	 */
	// XMLDocument did not extend the Document interface in some versions
	// of Mozilla. Extend both!
	/*
	XMLDocument.prototype.__defineGetter__("xml", function () {
		return (new XMLSerializer()).serializeToString(this);
	});
	*/
	Document.prototype.__defineGetter__("xml", function () {
		return (new XMLSerializer()).serializeToString(this);
	});
}

///////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////


//Descricao: Mostra e esconde também, porém não troca a imagem
//Criado por: Rodrigo Carvalho em data indefinida
function mostraEsconde(layer) {
	if (layer.style.display == '')
	    layer.style.display = 'none';
	else
	    layer.style.display = '';
}