/* -----------------------------------------------------------
        AEON Development Kit / ADK 1.0
            Extensão do Core JQuery

CopyRight		: AEON Digital
Programadora	: Rhianna Cantarelli Schellin
Data			: 17/10/2008 [ Inicio do Projeto ]
Secção			: Front-End Javascript
----------------------------------------------------------- */

	
	
	// Força Suporte de Opacidade
	$.support.opacity = true;






	/* -----------------------------------------------------------
		Set de Styles de Display
	----------------------------------------------------------- */
	$.fn.DisplayBlock = function() { return $(this).css('display', 'block'); };
	$.fn.DisplayNone = function() {	return $(this).css('display', 'none'); };

	/* -----------------------------------------------------------
		Set de Styles de Opacity
	----------------------------------------------------------- */
	$.fn.SetAlpha = function(value) { return $(this).css({ 'opacity': value, 'filter': 'alpha(opacity=' + (value*100) + ')' }); };






	/* -----------------------------------------------------------
		Objeto 'xdoc'
		Propriedades para restate de informações básicas acerca do documento e local atual
		
		- $.xdoc.sitename				: [string]	-> Nome do Site ex.: www.sitename.com.br
		- $.xdoc.pagename				: [string]	-> Nome da Página atual ex.: pagename.htm
		- $.xdoc.section				: [string]	-> Nome da Sessão [Baseada no nome da pasta em que a pagina está contida]
		- $.xdoc.querystrings			: [array]	-> Coleção de QueryStrings Passados pela URL
		- $.xdoc.getQueryString(query)	: [string]
			- query		: [string] nome da query a ser procurada
			- retornará 'null' em caso de não encontrar
	----------------------------------------------------------- */
	(function() {
		$.xdoc = {
			sitename		: null, 
			pagename		: null, 
			section			: null, 
			querystrings	: null, 
			getQueryString	: function(strQueryName) {
					var strReturn = null;
					if($.xdoc.querystrings != null) {
						for(i=0; i<$.xdoc.querystrings.length; i++) {
							atualQ = $.xdoc.querystrings[i];
							splitAtualQ = atualQ.split('=');
							if(splitAtualQ[0] == strQueryName) { strReturn = splitAtualQ[1]; break; }
						}
					}
					return strReturn;
				}
		};

		initiXdocObj = function() {
			// DEFINE INFORMAÇÕES DA SESSÃO E PÁGINA ATUAL
			var atualLocation = location + '';
			var strURL = '';
	
			// Retira Marcações 'http://', 'https://' e troca '&amp;' por '&'
			if(atualLocation.indexOf('http://') != -1) { strURL = atualLocation.replace('http://', '');	}
			else if(atualLocation.indexOf('https://') != -1) { strURL = atualLocation.replace('https://', ''); }
			while(strURL.indexOf('&amp;') != -1) { strURL = atualLocation.replace('&amp;', '&'); }
			
			splita = strURL.split("/");
			intLast = splita.length - 1;
			
			$.xdoc.sitename = unescape(splita[0]);
			$.xdoc.pagename = unescape(splita[intLast]);
			$.xdoc.section = unescape(splita[intLast - 1]);
			
			if($.xdoc.pagename.indexOf('?') != -1) { 
				$.xdoc.pagename = unescape($.xdoc.pagename.substring(0, $.xdoc.pagename.indexOf('?'))); 
				
				strQuery = splita[intLast].substring(splita[intLast].indexOf('?') + 1, splita[intLast].length);
				splitaQ = strQuery.split('&');
				
				$.xdoc.querystrings = new Array();
				
				for(i=0; i<splitaQ.length; i++) { $.xdoc.querystrings[i] = unescape(splitaQ[i]); }
			}			
		};
		initiXdocObj();
	})();















	/* -----------------------------------------------------------
		Objeto 'getoffset'

		Os Métodos abaixo resgatam informações sobre as dimensões do monitor do usuario, 
		janela do browser, o tamanho de um node carregado ou a posição x e y do scroll.

		- $.getoffset.screenw()			: [int]		-> Largura Total do Monitor do Usuário
		- $.getoffset.screenh()			: [int]		-> Altura Total do Monitor do Usuário

		- $.getoffset.windoww()			: [int]		-> Largura Total da Janela do Browser
		- $.getoffset.windowh()			: [int]		-> Altura Total da Janela do Browser

		- $.getoffset.nodew('css')		: [int]		-> Largura Total do Node Alvo [apenas o 1 node da Coleção]
		- $.getoffset.nodeh('css')		: [int]		-> Altura Total do Node Alvo [apenas o 1 node da Coleção]

		- $.getoffset.scrollx()			: [int]		-> Retorna a distância em 'px' que a janela do browser está focada da margem mais à esquerda da tela
		- $.getoffset.scrollx('css')	: [int]		-> Se definido um node, retorna a distância em 'px' que o node está da margem mais à esquerda da tela
		
		- $.getoffset.scrolly()			: [int]		-> Retorna a distância em 'px' que a janela do browser está focada da margem mais ao topo da tela
		- $.getoffset.scrolly('css')	: [int]		-> Se definido um node, retorna a distância em 'px' que o node está da margem mais ao topo da tela
	----------------------------------------------------------- */
	$.getoffset = {
		screenw		: function() { return screen.width; },
		screenh		: function() { return screen.height; },
		windoww		: function() { r = document.documentElement.clientWidth; if(r == 0) { r = document.body.clientWidth; } return r; },
		windowh		: function() { r = document.documentElement.clientHeight; if(r == 0) { r = document.body.clientHeight; } return r; },
		nodew		: function(css) { return $(css)[0].clientWidth; },
		nodeh		: function(css) { return $(css)[0].clientHeight; },
		
		scrollx		: function(css) {
			var offsetLeft;
			if(css == null) {
				if (self.pageXOffset) { offsetLeft = self.pageXOffset; } 
				else if (document.documentElement && document.documentElement.scrollLeft) { offsetLeft = document.documentElement.scrollLeft; } 
				else if (document.body) { offsetLeft = document.body.scrollLeft; }
			}
			else {
				node = $(css)[0];
				var offsetTrail = node; offsetLeft = 0;
				while (offsetTrail) { offsetLeft = parseInt(offsetLeft + offsetTrail.offsetLeft); offsetTrail = offsetTrail.offsetParent; }
				if (navigator.userAgent.indexOf("Mac") != -1 && typeof document.body.leftMargin != "undefined") {
		            offsetLeft = parseInt(offsetLeft + document.body.leftMargin);
				}
			}
			return offsetLeft;
		},

		scrolly		: function(css) {
			var offsetTop;
			if(css == null) {
				if (self.pageYOffset) { offsetTop = self.pageYOffset; } 
				else if (document.documentElement && document.documentElement.scrollTop) { offsetTop = document.documentElement.scrollTop; } 
				else if (document.body) { offsetTop = document.body.scrollTop; }
			}
			else {
				node = $(css)[0];
				var offsetTrail = node; offsetTop = 0;
				while (offsetTrail) { offsetTop = parseInt(offsetTop + offsetTrail.offsetTop); offsetTrail = offsetTrail.offsetParent; }
				if (navigator.userAgent.indexOf("Mac") != -1 && typeof document.body.leftMargin != "undefined") {
					offsetTop = parseInt(offsetTop + document.body.topMargin);
				}
			}
			return offsetTop;
		}
	};















	/* -----------------------------------------------------------
		Posiciona os Nodes selecionados ao centro do node Pai que os contém usando as propriedades CSS Top e Left.
		É necessário que os elementos alvos tenham position:relative ou absolute;

		- axle							: OPÇÕES [x,y ou xy] Indica em que Eixo os Nodes devem ser posicionados
		- nodeParent					: seletor [preferencialmente ID] de um node que deve ser o Pai dos que devem ser alinhados

		- $(seletor).alignToCenter('x')	: Posiciona Horizontalmente
		- $(seletor).alignToCenter('y')	: Posiciona Verticalmente
		- $(seletor).alignToCenter('xy'): Posiciona em ambos Eixos
	----------------------------------------------------------- */
	$.fn.alignToCenter = function(axle, nodeParent) {
		// Para cada Node Selecionado:
		return this.each(function(){
			var pNode;
			// Seleciona o Node que é Pai do node Atual
			if(nodeParent == null) { pNode = $(this).parent(); }
			else { pNode = $(nodeParent)[0]; }

			// Se for indicado que é para alinhar pelo eixo 'x'
			if(axle.indexOf('x') != -1) { $(this).css({left: Math.round ((parseInt($(pNode).width())-parseInt($(this).width()))/2) + 'px'}); }
			// Se for indicado que é para alinhar pelo eixo 'y'
			if(axle.indexOf('y') != -1) { $(this).css({top: Math.round ((parseInt($(pNode).height())-parseInt($(this).height()))/2) + 'px'}); }
		});
	};





	/* -----------------------------------------------------------
		Expande o node indicado	por toda a area selecionada.
		
		- area							: OPÇÕES [null, 'screen', 'css']
			- null		-> Se não for setado, os elementos alvos serão dimensionados para um tamanho igual aos seus respectivos parentNode
			- screen	-> indicando esta string, os nodes serão dimensionados para cobrir todo o documento.
			- css		-> o 1º node selecionado desta forma será a referência para o dimencionamento de todos os outros nodes.
		- nodeReference					: seletor do Node usado como referência.
	----------------------------------------------------------- */
	$.fn.extendNode = function(area, nodeReference) {
		return this.each(function() {
			var pNode; 
			var totalW; 
			var totalH;
			
			// Se não for passado nenhuma 'area', extenderá os nodes para o mesmo tamanho do seu parentNode mais próximo
			if(area == null) { 
				pNode = $(this).parent();
				totalW = $(pNode)[0].clientWidth;
				totalH = $(pNode)[0].clientHeight;
			}
			/* 
				Se for passado 'area' e 'nodeReference' : 
					Se 'area' == 'screen' os nodes alvos passarão a ter suas dimensões iguais aos do documento atual 
					usando as dimensções de nodeReference como referência
					Senão, usará a largura e altura do 'nodeReference' para seta-las igualmente aos nodes alvo.
			*/
			else if (area != null) { 
				pNode = $(nodeReference).parent(); // Node de referência para screen

				totalW = $(pNode)[0].clientWidth;
				totalH = $(pNode)[0].clientHeight;

				if(area == 'screen') {
					totalW = $.getoffset.windoww();
					totalH = $.getoffset.windowh();
					
					// Verifica maior dimensão entre altura e largura do documento e o encontrado em 'nodeReference'
					if($.getoffset.windoww() < $(pNode).width()) { totalW = $(pNode).width(); }
					if($.getoffset.windowh() < $(pNode).height()) { totalH = $(pNode).height(); }
				}
			}
			$(this).css({ 'width': totalW, 'height': totalH });
		});
	};





	/* -----------------------------------------------------------
		Posiciona os Nodes alvos em determinadas coordenadas x/y 
		absolutamente a partir da margem esquerda e do topo absoluto do documento.
		
		- x								: [int]		-> Coordenada X (horizontal)
		- y								: [int]		-> Coordenada X (horizontal)
	----------------------------------------------------------- */
	$.fn.absoluteCoords = function(x, y) {
		return this.each(function() {
			// Primeiramente posiciona o elemento alvo nas coordenadas 0,0 
			$(this).css({ 'left' : '0px', 'top' : '0px' });
								  
			// Resgata posição atual de cada node selecionado com relação a margem superior e esquerda
			var xZero = $.getoffset.scrollx(this);
			var yZero = $.getoffset.scrolly(this);
			
			// Calcula coordenada final
			x = (x - xZero) + 'px';
			y = (y - yZero) + 'px';

			// Aplica coordenadas nos eixos
			$(this).css({ 'left' : x, 'top' : y });
		});
	};





	/* -----------------------------------------------------------
		Calcula quando os nodes alvos ultrapassam os limites internos do node alvo
		e aplica nos mesmos coordenadas novas(top/left) para que os mesmos
		permaneçam dentro dos limites determinados.
		
		- nodeParent					: [string]	-> Node Pai dos Nodes selecionados que servirá de referencia para as coordenada setadas
	----------------------------------------------------------- */
	$.fn.insideNode = function(nodeParent) {
		return this.each(function() {
			// Verifica as coordenadas mínimas e máximas onde o node alvo deve estar contido
			var minX = $.getoffset.scrollx(nodeParent);
			var minY = $.getoffset.scrolly(nodeParent);
			var maxX = minX + $(nodeParent)[0].clientWidth;
			var maxY = minY + $(nodeParent)[0].clientHeight;

			// Resgata a largura, altura e coordenadas atuais do node alvo
			var nodeMinX = parseInt($(this).css('left').replace('px', ''));
			var nodeMinY = parseInt($(this).css('top').replace('px', ''));
			var nodeMaxX = nodeMinX + $(this)[0].clientWidth;
			var nodeMaxY = nodeMinY + $(this)[0].clientHeight;

			// Verifica Limites no Eixo Horizontal
			if(nodeMaxX > maxX) { returnX = nodeMinX - (nodeMaxX - maxX); $(this).css('left', returnX + 'px'); }
			if(nodeMinX < minX) { $(this).css('left', minX + 'px'); }
			
			// Verifica Limites no Eixo Vertical
			if(nodeMaxY > maxY) { returnY = nodeMinY - (nodeMaxY - maxY); $(this).css('top', returnY + 'px'); }
			if(nodeMinY < minY) { $(this).css('top', minY + 'px'); }
		});
	};
















	/* -----------------------------------------------------------
		APLICAÇÔES COMUNS NÂO AGREGADAS AO JQUERY
		Métodos à serem Setados On Demand.
	----------------------------------------------------------- */






	
	
	
	
	
	
	


	
	/* -----------------------------------------------------------
	Cria um Objeto que Carrega os Valores das Propriedades do Popup
		- url						: [string]	-> Url da página a ser aberta
		- popName					: [string]	-> Nome de controle do popup
		- isScroll					: OPTIONS [yes/no]	-> Seta se haverá barra de rolagem ou não
		- isResize					: OPTIONS [yes/no]	-> Define se a janela será redimensionavel
	
	Métodos:
		.setDimencion(isMax, w, h)	: Define as Dimensões do Popup
			isMax [false]			: [true/false]		-> Para Ocupar toda a tela
			w e h -> 				: [int]				-> respectiva largura e altura

		.setPosition(isCenter, t, l): Define a Posição do Popup na Tela
			isCenter [true] 		: [true/false]		-> Indica que deve ser aberto ao centro da tela
			t e l -> 				: [int]				-> coordenadas de abertura do popup na tela

		.openThis()					: Executa a abertura do Popup
	----------------------------------------------------------- */
	function CreatePopup(url, popName, Scroll, Resize) {
		var url = url;
		var popName = popName;
		var isScrollBars = Scroll;
		var isResizable = Resize;

		var isMaxArea = false;
		var width = null;
		var height = null;
		var isToCenter = true;
		var top = null;
		var left = null;
	
		var strPopUp = null;
	
		this.setDimencion = function(isMax, w, h) { isMaxArea = isMax; width = w; height = h; };
		this.setPosition = function (isCenter, t, l) { isToCenter = isCenter; top = t; left = l; };
		
		var createString = function () {
			tW = screen.width;
			tH = screen.height;
	
			if (isMaxArea == true) { W = tW; H = tH; }
			else { W = width; H = height; }
			popArea = 'Width='+ W + ', Height='+ H +', ';
			
			if (isToCenter == true) { L = (tW - width) / 2; T = (tH - height) / 2; }
			else { L = left; T = top; }
			popPosition = 'top='+ T +', left='+ L +', ';
			
			popCaracteres = 'scrollbars='+ isScrollBars +', resizable='+ isResizable;
			strPopUp = popArea + popPosition + popCaracteres;
		};
		
		this.openThis = function () { createString(); window.open(url, popName, strPopUp); };
	};





	/* -----------------------------------------------------------
		Cria efeito de 'rolagem suave' até a ancora definida.
			-	Procura por todas as Ancoras criadas e então procura por seus respectivos links setando o evento
				para a rolagem suave
	----------------------------------------------------------- */
	function AnchorAnimation() {
		// Para cada Anchor com ID setado
		$('a[id]').each(function() {
			Tanchor = '#' + $(this).attr('id');
			// Remove qualquer set anterior deste mesmo evento e seta novamente evitando duplicação
			$('a[href*=' + Tanchor + ']').unbind('click', aeon_AnchorAnimation);
			$('a[href*=' + Tanchor + ']').click(aeon_AnchorAnimation);
		});
	};
	// Procura Link com Class = ID e adiciona Função de Animação no evento onclick
	aeon_AnchorAnimation = function() {
		splita = this.href.split('#');
		anchorID = '#' + splita[1];
		
		// Resgata Top da Ancora
		var anchorTop = $.getoffset.scrolly(anchorID);
		if(anchorTop < 0) { anchorTop = 0; }

		// Anima Link e Retorna False, evitando o efeito padrão HTML
		$('html, body').animate({scrollTop: anchorTop + 'px'}, 300); 
		return false; 
	};





	/* -----------------------------------------------------------
		Verifica quais links não apontam para um local neste mesmo dominio ou
		quais possuem mimetype pré-definido em 'xvar_NewWindowMimeType' e os seta com o atributo 
		target="_blank" e com uma classe de controle 'blankPage'
	----------------------------------------------------------- */
	function LinkToAnotherPage() {
		$('a').each(function() {
			var thisHref = this.href;
			var isNewWindow = false;
			var mimes = xvar_NewWindowMimeType.split(',');
			// Não encontrando o Site atual na URL a ser Verificada e tendo esta o protocolo 'http://'
			if(thisHref.indexOf($.xdoc.sitename) == -1 && thisHref.indexOf('http://') != -1) { isNewWindow = true; }
			// Verifica se Arquivos com esta Extenção devem abrir em Outra tela
			for(j=0;j<mimes.length;j++) { if(thisHref.indexOf('.' + mimes[j]) != -1) { isNewWindow = true; } }
			// Seta Link para Abrir em Outra Janela
			if(isNewWindow == true) { this.target = '_blank'; $(this).addClass('blankPage'); }
		});
	};





	/* -----------------------------------------------------------
		Identifica Imagens que em seu atributo SRC tenham o sufixo 'xvar_ImgSufixNoHover' e 
		adiciona em todas uma função que fará o efeito mouseover e mouseout.
	----------------------------------------------------------- */
	function SetImgChangeOnOver() {
		$('img').each(function() {
			var thisSRC = this.src;
			if (thisSRC.indexOf(xvar_ImgSufixNoHover) != -1) {
				$(this).unbind('mouseover', aeon_SetImgChangeOnOver).unbind('mouseout', aeon_SetImgChangeOnOver);
				$(this).mouseover(aeon_SetImgChangeOnOver).mouseout(aeon_SetImgChangeOnOver);
			}
		});
	};
	aeon_SetImgChangeOnOver = function() {
		if (this.src.indexOf(xvar_ImgSufixNoHover) != -1) { this.src = this.src.replace(xvar_ImgSufixNoHover, xvar_ImgSufixHover); }
		else if (this.src.indexOf(xvar_ImgSufixHover) != -1) { this.src = this.src.replace(xvar_ImgSufixHover, xvar_ImgSufixNoHover); }
	};





	/* -----------------------------------------------------------
		Seta todos os elementos com o atributo 'title' com eventos mouseover e mouseout que 
		geram um ToolTip daquele elemento.
		- O tooltip aparece nas coordenadas x/y definidas em 'xvar_ToolTipX' e 'xvar_ToolTipY' a partir do ponteiro do mouse
		- O tooltip deve ser estilizado pelo css
	----------------------------------------------------------- */
	function SetToolTip() {
		$('*[title]').each(function() {
			// Se não for setado um texto no atributo 'title', não gerará o tooltip
			if(this.title != '') { 
				$(this).unbind('mouseover', aeon_SetToolTip_evtMouseOver).unbind('mouseout', aeon_SetToolTip_evtMouseOut);
				$(this).mouseover(aeon_SetToolTip_evtMouseOver).mouseout(aeon_SetToolTip_evtMouseOut);
			}		
		});
	};
	aeon_SetToolTip_evtMouseOver = function(e) {
		// Cria um elemento P e adiciona nele o conteudo do atributo 'title'
		newP = document.createElement('p'); newP.innerHTML = this.title; this.title = '';
		// Insere o novo conteudo e Seta a Posição do ToolTip e o torna visivel
		$(newP).appendTo(xvar_IDToolTip + ' .title');
		$(xvar_IDToolTip).DisplayBlock().absoluteCoords(e.pageX + xvar_ToolTipX, e.pageY + xvar_ToolTipY).insideNode(xvar_IDBoxPrincipal);
		if(xvar_IsIeVersion == '6') { $('select').css('visibility', 'hidden'); }
	};
	aeon_SetToolTip_evtMouseOut = function(e) {
		// Retorna o conteudo para o atributo 'title'
		// Torna o tooltip invisivel e apaga seu conteudo
		this.title = $(xvar_IDToolTip + ' .title p').text();
		$(xvar_IDToolTip).DisplayNone();
		$(xvar_IDToolTip + ' .title').empty();
		if(xvar_IsIeVersion == '6') { $('select').css('visibility', 'visible'); }
	};





	/* -----------------------------------------------------------
		Simula efeito :hover para os nodes passados.
	----------------------------------------------------------- */
	function SetHoverSupportForIE6(css) {
		$(css).unbind('mouseover', aeon_SetHoverSupportForIE6_over).unbind('mouseout', aeon_SetHoverSupportForIE6_out);
		$(css).mouseover(aeon_SetHoverSupportForIE6_over).mouseout(aeon_SetHoverSupportForIE6_out);
	};
	aeon_SetHoverSupportForIE6_over = function() { $(this).addClass('hover'); };
	aeon_SetHoverSupportForIE6_out = function() { $(this).removeClass('hover'); };





	/* -----------------------------------------------------------
		Procura por todas as imagens de um determinado node e ao final do load de todas
		executa o método passado adicionando seus parametros se informados.

		- css						: [string]	-> Node onde as imagens serão carregadas.
		- executeOnEnd				: [string]	-> string do Método(parametros) a ser executado ao final
	----------------------------------------------------------- */
	var aeon_ImagesToLoad = 0;
	var aeon_ImagesLoaded = 0;
	function WaitToLoadAllImages(css, executeOnEnd) {
		// Procura por todas as Imagens no node passado e reinicia variáveis de a´poio
		allImages = $(css + ' img');
		aeon_ImagesToLoad = allImages.length;
		aeon_ImagesLoaded = 0;
	
		// Para cada Imagem existente no node:
		arrImg = new Array();
		for (i = 0; i < aeon_ImagesToLoad; i++) {
			// Cria um objeto DOM da imagem e carrega ela, adicionando ao evento onload da mesma a função de controle
			// que dispara o método passado ao ler a última.
			arrImg[i] = document.createElement('img');
			arrImg[i].onload = function() {
				aeon_ImagesLoaded++;
				if (aeon_ImagesLoaded == aeon_ImagesToLoad) { eval(executeOnEnd); }
			};
			arrImg[i].src = allImages[i].src;
		}
	};





	/* -----------------------------------------------------------
		Seta Comando de abrir Modal em todos os <a rel="modal">
	----------------------------------------------------------- */
	function SetAnchorModal() {
		$('a[rel*="modal"]').unbind('click', aeon_SetAnchorModal);
		$('a[rel*="modal"]').click(aeon_SetAnchorModal);
	};
	aeon_SetAnchorModal = function() {
		rel = $(this).attr('rel').replace('modal ', '');
		// Se for um link para fechar o modal
		if (rel.indexOf('hide') != -1) { $.modal.HideModal(); }
		else { $.modal.LoadModal($(this).attr('href'), rel); return false; }
	};





	/* -----------------------------------------------------------
		Seta Comando de navegação por histórico conforme informações passadas em 
		<a rel="history -1">		-> [int negativos] Navega para traz
		<a rel="history 1">			-> [int positivos] Navega para frente
	----------------------------------------------------------- */
	function SetHistoryAnchor() {
		$('a[rel*="history"]').unbind('click', aeon_SetHistoryAnchor);
		$('a[rel*="history"]').click(aeon_SetHistoryAnchor);
	};
	aeon_SetHistoryAnchor = function() {
		rel = $(this).attr('rel').replace('history ', '');
		history.go(parseInt(rel));
		return false;
	};






	/* -----------------------------------------------------------
		Retorna true se o node alvo está vazio e false se ele contém conteúdo
	----------------------------------------------------------- */
	function IsNodeEmpty(css) {
		if ($(css)[0].firstChild) { return false; }
		else { return true; }
	};















	/* -----------------------------------------------------------
	Extensão do Jquery para uso de um Modal
	----------------------------------------------------------- */
	$.modal = {
	    aeon_LoadDocURL: null,
	    aeon_ActionsOnLoad: null,
	    aeon_ErrorOnLoad: 0,
	    aeon_IsRequestOn: false,
	    aeon_NodeReference: null,
	    aeon_TimeTransition: 500,
	    LoadModal: function(loadDocURL, actionsOnLoad) {
	        // Garante que apenas 1 requisição será feita por vez
	        if ($.modal.aeon_IsRequestOn == false) {
	            // Seta Variáveis
	            $.modal.aeon_LoadDocURL = loadDocURL;
	            $.modal.aeon_ActionsOnLoad = actionsOnLoad.split(' ');
	            $.modal.aeon_IsRequestOn = true;

	            $.modal.Modal_Start();
	        }
	    },
	    Modal_Start: function() {
	        // Se Modal já Está Aberto, Seta seu Tamanho Inicial
	        if ($('#boxModal').css('display') == 'block') {
	            w = $('#boxModal')[0].clientWidth; h = $('#boxModal')[0].clientHeight;
	            $('#boxModal').css({ 'width': w + 'px', 'height': h + 'px' });
	        }
	        // Limpa Conteudo do Node de Modal
	        $('#boxModal').empty();


	        // Faz Leitura do Conteúdo e Aplica-o no Node Alvo
	        $('#boxModal').load($.modal.aeon_LoadDocURL + ' #getThis');

	        // Ajustes Para Requisição Assincrona
	        $.ajax({
	            cache: false,
	            success: function() {
	                // Se ocorreu um falso positivo ou se o node ainda não foi carregado
	                if (IsNodeEmpty('#boxModal')) {
	                    if ($.modal.aeon_ErrorOnLoad < 1) { setTimeout('$.modal.Modal_WaitTest()', 3000); }
	                    else { location = $.modal.aeon_LoadDocURL; }
	                }
	                // Se o conteudo ja foi carregado, prossegue processamento
	                else { $.modal.Modal_PreSet(); }
	            },
	            error: function() { alert('Houve um erro ao requisitar este recurso.'); }
	        });
	    },
	    Modal_WaitTest: function() {
	        if (IsNodeEmpty('#boxModal')) { $.modal.aeon_ErrorOnLoad++; $.modal.Modal_Start(); }
	        else { $.modal.Modal_PreSet(); }
	    },
	    Modal_ReestartVariables: function() {
	        $.modal.aeon_LoadDocURL = null;
	        $.modal.aeon_ActionsOnLoad = null;
	        $.modal.aeon_ErrorOnLoad = 0;
	        $.modal.aeon_IsRequestOn = false;
	        $.modal.aeon_NodeReference = null;
	    },
	    Modal_PreSet: function() {
	        // Primeiramente Mostra e Expande Shadow, adicionando a função para fechar o mesmo
	        $('#boxShadow').DisplayBlock().extendNode('screen', '#boxBottom').unbind('click', $.modal.HideModal).click($.modal.HideModal);

	        // Evoca Funções de Ajustes para o Tipo de Modal Exigido
	        for (i = 0; i < $.modal.aeon_ActionsOnLoad.length; i++) {
	            exec = 'ModalAdjust_' + $.modal.aeon_ActionsOnLoad[i] + '()';

	            // Verifica se Modal Precisa ter suas Imagens Carregadas Previamente antes de Aparecer
	            if ($.modal.aeon_ActionsOnLoad[i] == 'imagegalery') { WaitToLoadAllImages('#boxModal', exec); }
	            else { eval(exec); }
	        }
	        SetAnchorModal();
	    },
	    Modal_SetPosition: function() {
	        // Alinha Modal Horizontalmente
	        $('#boxModal').alignToCenter('x');
	        // Calcula Altura e Ajusta Modal Verticalmente
	        var finaly = (($.getoffset.windowh() - $('#boxModal').height()) / 2) + $.getoffset.scrolly();
	        if (finaly < 0) { finaly = 0; }
	        // Seta Altura e Apresenta Modal
	        $('#boxModal').css('top', finaly);
	    },
	    Modal_SetAndShow: function() {
	        // Esconde conteudo sem que o mesmo perca seus atributos
	        $('#boxModal, #ModalBody').css('visibility', 'hidden');
	        show = function() {
	            $('#boxModal').show($.modal.aeon_TimeTransition, function() {
	                $.modal.aeon_ErrorOnLoad = 0;
	                $.modal.aeon_IsRequestOn = false;
	            });
	        };
	        setPosition = function() {
	            $('#boxModal, #ModalBody').DisplayBlock();
	            $.modal.Modal_SetPosition();
	            $('#boxModal').DisplayNone();
	            $('#boxModal, #ModalBody').css('visibility', 'visible');
	            setTimeout(show, 50);
	        };
	        // Em 50 milessegundos ajusta posição do modal e ao termino, mostra o mesmo
	        setTimeout(setPosition, 50);
	    },
	    Modal_FadeTransition: function() {
	        // Verifica se Modal está Aberto ou se deverá ser Aberto
	        isModalOpen = false;
	        if ($('#boxModal').css('display') == 'block') { isModalOpen = true; }

	        // Esconde conteudo sem que o mesmo perca seus atributos
	        if (isModalOpen == false) { $('#boxModal, #ModalBody, #ModalTransition').css('visibility', 'hidden'); }
	        else { $('#ModalTransition').css('visibility', 'hidden'); }

	        show = function() {
	            // Se está fechado, abre janela com .show
	            if (isModalOpen == false) {
	                $('#boxModal').show($.modal.aeon_TimeTransition, function() {
	                    $.modal.aeon_ErrorOnLoad = 0;
	                    $.modal.aeon_IsRequestOn = false;
	                });
	            }
	            // se está aberto, usa efeito .fadeIn
	            else {
	                $('#ModalTransition').fadeIn($.modal.aeon_TimeTransition, function() {
	                    $.modal.aeon_ErrorOnLoad = 0;
	                    $.modal.aeon_IsRequestOn = false;
	                });
	            }
	        };
	        setPosition = function() {
	            $('#boxModal, #ModalBody').DisplayBlock();
	            $.modal.Modal_SetPosition();
	            // Se está fechado, prepara para .show
	            if (isModalOpen == false) { $('#boxModal').DisplayNone(); }
	            // Se está aberto, prepara para .fadeIn
	            else { $('#ModalTransition').DisplayNone(); }

	            $('#boxModal, #ModalBody, #ModalTransition').css('visibility', 'visible');
	            setTimeout(show, 50);
	        };
	        setTimeout(setPosition, 50);
	    },
	    Modal_AnimateShow: function() {
	        // Verifica se Modal está Aberto ou se deverá ser Aberto
	        isModalOpen = false;
	        if ($('#boxModal').css('display') == 'block') { isModalOpen = true; }

	        // Abre Containers para Resgatar Informações das dimensões do modal
	        $('#boxModal, #ModalBody').DisplayBlock();


	        w = $($.modal.aeon_NodeReference)[0].clientWidth;
	        h = $('#ModalBody')[0].clientHeight;

	        padXBody = (parseInt($('#ModalBody').css('paddingLeft').replace('px', '')) + parseInt($('#ModalBody').css('paddingRight').replace('px', '')));
	        padYBody = (parseInt($('#ModalBody').css('paddingTop').replace('px', '')) + parseInt($('#ModalBody').css('paddingBottom').replace('px', '')));


	        // Esconde Imagem Principal e Box Modal
	        $('#ModalBody').DisplayNone();
	        if (isModalOpen == false) { $('#boxModal').DisplayNone(); }
	        else { $('#ModalBody').DisplayNone(0); }

	        // Ajusta o tamanho dos itens de Linha para a Largura da Imagem Principal
	        $('#ModalBody, #ModalBody .allLine').css('width', w);

	        // Calcula Largura Final Total do Corpo do Modal
	        wbody = w + padXBody;
	        hbody = h + padYBody;


	        // Calcula Coordenada X e Y em que o Modal tem que ficar
	        x = ($.getoffset.windoww() - wbody) / 2;
	        y = (($.getoffset.windowh() - hbody) / 2) + $.getoffset.scrolly();
	        if (y < 0) { y = 0; }

	        // Se está abrindo modal pela primeira vez
	        if (isModalOpen == false) { $.modal.Modal_SetAndShow(); }
	        else {
	            // Anima Alterações de tamanho e coordenadas do Modal
	            $('#boxModal').animate({
	                width: wbody,
	                height: hbody,
	                left: x,
	                top: y
	            }, $.modal.aeon_TimeTransition, '', function() {
	                $('#ModalBody').fadeIn($.modal.aeon_TimeTransition, function() {
	                    $.modal.aeon_ErrorOnLoad = 0;
	                    $.modal.aeon_IsRequestOn = false;
	                });
	            });
	        }
	    },
	    HideModal: function() {
	        $('#boxModal').hide($.modal.aeon_TimeTransition, function() {
	            $('#boxShadow').DisplayNone();
	            $.modal.Modal_ReestartVariables();
	            $('#boxModal').css({ 'width': 'auto', 'height': 'auto' });
	        }).empty();
	    }
	};