if((typeof AFL_JS == 'undefined') || (typeof AFL_JS.Common == 'undefined'))
		throw("AFL_JS.Overlay requires the AFL JavaScript framework");

	var AnimatedOverlay = AFL_JS.AnimatedOverlay = new Object();
	
	AnimatedOverlay.Settings = {
		OverlayLayerId : 'popup_overlay',
		OverlayLayerContentId : 'animated_overlay_content',
		OverlayLayerCloseId : 'animated_overlay_content_close'
	}
			
	AnimatedOverlay.Storage = {
		HoldForById : {}	
	}
	
	AnimatedOverlay.IsOpened = null;
	
	AnimatedOverlay.Open = function(sClassName) {
		
		AnimatedOverlay.BuildOverlay(sClassName);

		AnimatedOverlay.ShowLoader();
		        
	}
	
	AnimatedOverlay.FixIETroubleObjects = function(bShow) {
		
		if(window.XMLHttpRequest) return;
		
		if(bShow) {
			$$('select', 'object', 'embed').each(function(node){ node.style.visibility = 'visible' });
		} else {
			$$('select', 'object', 'embed').each(function(node){ node.style.visibility = 'hidden' });
		}
	}
	
	AnimatedOverlay.BuildOverlay = function(sClassName) {
		
		if(AnimatedOverlay.IsOpened) return;
		
		var oBody = $$('body')[0];

		if(!$('animated_overlay')) {
			oBody.appendChild(Builder.node('div',{id:'animated_overlay'}));
		}
		
		$('animated_overlay').hide()
		
		AnimatedOverlay.FixIETroubleObjects(false);
						
		aPageSize = AnimatedOverlay.getPageSize();
				
		$('animated_overlay').setStyle({ 
			position: 'absolute',
			top: 0,
			left: 0,
			zIndex: '70',
			backgroundColor: '#000',
			width: aPageSize[0] + 'px', 
			height: aPageSize[1] + 'px' 
		});
		
		var sClassName = sClassName || '';
		
		if(!$(AnimatedOverlay.Settings.OverlayLayerContentId)) {
			oBody.appendChild(Builder.node('div',{id:AnimatedOverlay.Settings.OverlayLayerContentId, 'class': sClassName }));
			
			$(AnimatedOverlay.Settings.OverlayLayerContentId).hide();
			
			$(AnimatedOverlay.Settings.OverlayLayerContentId).setStyle({ 
				zIndex: '80'
			});
		} else {
			$(AnimatedOverlay.Settings.OverlayLayerContentId).className = sClassName;
		}
		
		AnimatedOverlay.IsOpened = true;
		
		new Effect.Appear($('animated_overlay'), { duration: 0.5, from: 0.0, to: 0.6 });
	}
	
	AnimatedOverlay.ShowLoader = function() {
				
		if($('animated_overlay_content_loaded')) {
			new Effect.Fade($(AnimatedOverlay.Settings.OverlayLayerContentId), { 
				duration: 0.3, 
				from: 1, 
				to: 0.0, 
				queue: {position: 'end', scope: 'aoloader' },
				afterFinish: (function() {
					Element.remove($('animated_overlay_content_loaded'));
					$(AnimatedOverlay.Settings.OverlayLayerContentId).appendChild(Builder.node('div',{id: 'animated_overlay_loader'}));
			        AnimatedOverlay.UpdatePosition();
			  		new Effect.Appear($(AnimatedOverlay.Settings.OverlayLayerContentId), { duration: 0.5, from: 0.0, to: 1, queue: {position: 'front', scope: 'aoloader' }});
				})
			});
		} else {
			$(AnimatedOverlay.Settings.OverlayLayerContentId).appendChild(Builder.node('div',{id: 'animated_overlay_loader'}));
	        
			AnimatedOverlay.UpdatePosition();
	  
			new Effect.Appear($(AnimatedOverlay.Settings.OverlayLayerContentId), { duration: 0.5, from: 0.0, to: 1, queue: {position: 'front', scope: 'aoloader' }});
		}
		
		

	}
	
	AnimatedOverlay.ShowById = function(sInnerId, sClassName) {
		
		var oElement = $(sInnerId);
		
		AnimatedOverlay.Storage.HoldForById[sInnerId] = {
			Parent: oElement,
			Content: oElement.innerHTML
		}
		
		oElement.innerHTML = null;
				
		AnimatedOverlay.BuildOverlay(sClassName);		
		AnimatedOverlay.ReplaceContent(AnimatedOverlay.Storage.HoldForById[sInnerId].Content);
		AnimatedOverlay.UpdatePosition();

		new Effect.Appear($('animated_overlay'), { duration: 0.5, from: 0.0, to: 0.6 });
		new Effect.Appear($(AnimatedOverlay.Settings.OverlayLayerContentId), { duration: 0.3, from: 0.0, to: 1 });
	}
	
	AnimatedOverlay.ShowByContent = function(sContent, sClassName) { //javascript alert()
		AnimatedOverlay.BuildOverlay(sClassName);		
		AnimatedOverlay.ReplaceContent(sContent);
		AnimatedOverlay.UpdatePosition();
		new Effect.Appear($('animated_overlay'), { duration: 0.5, from: 0.0, to: 0.6 });
		new Effect.Appear($(AnimatedOverlay.Settings.OverlayLayerContentId), { duration: 0.3, from: 0.0, to: 1 });
	}
	
	AnimatedOverlay.ShowByObject = function(oObject, sClassName) { //javascript alert()
		AnimatedOverlay.BuildOverlay(sClassName);		
		AnimatedOverlay.ReplaceContent(oObject);
		AnimatedOverlay.UpdatePosition();
		new Effect.Appear($('animated_overlay'), { duration: 0.5, from: 0.0, to: 0.6 });
		new Effect.Appear($(AnimatedOverlay.Settings.OverlayLayerContentId), { duration: 0.3, from: 0.0, to: 1 });
	}
	
	AnimatedOverlay.LoadById = function(sInnerId) {
		
		var oElement = $(sInnerId);
		
		AnimatedOverlay.Storage.HoldForById[sInnerId] = {
			Parent: oElement,
			Content: oElement.innerHTML
		}
		
		oElement.innerHTML = null;
		
		if($('animated_overlay_content')) {
		

			new Effect.Fade($(AnimatedOverlay.Settings.OverlayLayerContentId), { 
				duration: 0.3, 
				from: 1, 
				to: 0.0, 
				queue: {position: 'end', scope: 'aoloader' },
				afterFinish: (function() {
					AnimatedOverlay.ReplaceContent(AnimatedOverlay.Storage.HoldForById[sInnerId].Content);
					AnimatedOverlay.UpdatePosition();
					new Effect.Appear($(AnimatedOverlay.Settings.OverlayLayerContentId), { duration: 0.3, from: 0.0, to: 1 });
				})
			});
		
		} else {
			AnimatedOverlay.ShowByContent(AnimatedOverlay.Storage.HoldForById[sInnerId].Content);
		}

	}
	
	AnimatedOverlay.LoadByContent = function(sContent) {
		
		new Effect.Fade($(AnimatedOverlay.Settings.OverlayLayerContentId), { 
			duration: 0.3, 
			from: 1, 
			to: 0.0, 
			queue: {position: 'end', scope: 'aoloader' },
			afterFinish: (function() {
				AnimatedOverlay.ReplaceContent(sContent);
				AnimatedOverlay.UpdatePosition();
				new Effect.Appear($(AnimatedOverlay.Settings.OverlayLayerContentId), { duration: 0.3, from: 0.0, to: 1 });
			})
		});
	}
	
	AnimatedOverlay.ReplaceContent = function (mContent) {
		if($('animated_overlay_loader')) {
			Element.remove('animated_overlay_loader');
		}
		if($('animated_overlay_content_loaded')) {
			Element.remove('animated_overlay_content_loaded');
		}
		
		if(!$(AnimatedOverlay.Settings.OverlayLayerCloseId)) {
			//alert($('animated_overlay_content').id);
			
			var oElement = Builder.node('div',{id: AnimatedOverlay.Settings.OverlayLayerCloseId});
			$(AnimatedOverlay.Settings.OverlayLayerContentId).appendChild(oElement);
			
			Element.update(oElement, '<span>X</span>');
			
			$(AnimatedOverlay.Settings.OverlayLayerCloseId).observe('click', function() {AnimatedOverlay.Close()});
		}
		if(Object.isString(mContent)) {
			var oElement = Builder.node('div',{id: 'animated_overlay_content_loaded'});
			$(AnimatedOverlay.Settings.OverlayLayerContentId).appendChild(oElement);
			Element.update(oElement, mContent);
		} else {
			$(AnimatedOverlay.Settings.OverlayLayerContentId).appendChild(Builder.node('div',{id: 'animated_overlay_content_loaded'}).appendChild(mContent));
		}
	}
	
	
	AnimatedOverlay.UpdatePosition = function() {

		var Popup = $(AnimatedOverlay.Settings.OverlayLayerContentId);
				
		var xPopup = Element.getWidth(Popup);
		var yPopup = Element.getHeight(Popup);
				
		aOffsetSizes = document.viewport.getScrollOffsets();
		
		var xScroll = aOffsetSizes[0];
		var yScroll = aOffsetSizes[1];
		
		var xSize = AnimatedOverlay.getWindowWidth();
		var ySize = AnimatedOverlay.getWindowHeight();
		
		var iPositionLeft = Math.round(xSize/2)+xScroll-Math.round(xPopup/2);
		var iPositionTop  = Math.round(ySize/2)+yScroll-Math.round(yPopup/2);
			
		/*Element.setStyle({
			position: 'absolute',
			top: iPositionTop+'px',
			left: iPositionLeft+'px'
		});*/
		
		
		
		Popup.style.position = 'absolute';
		Popup.style.top = iPositionTop+'px';
		Popup.style.left = iPositionLeft+'px';
	}
		
	AnimatedOverlay.Close = function(PopupId, OverlayId) {
		
		if(!AnimatedOverlay.IsOpened) return;
		
		$H(AnimatedOverlay.Storage.HoldForById).each(function(aPair){
			if(aPair !=null && aPair[1] != null) {
				aPair[1].Parent.innerHTML = aPair[1].Content;
				AnimatedOverlay.Storage.HoldForById[aPair[0]] = null;
			}
		});		
		
		if($(AnimatedOverlay.Settings.OverlayLayerContentId)) {
			new Effect.Fade(AnimatedOverlay.Settings.OverlayLayerContentId, {afterFinish: function() {Element.remove(AnimatedOverlay.Settings.OverlayLayerContentId)}});
		} 
		
		new Effect.Fade('animated_overlay', {afterFinish: function() { 
			Element.remove('animated_overlay');
			AnimatedOverlay.FixIETroubleObjects(true);
		}});
		
		AnimatedOverlay.IsOpened = false;
	}
	
	AnimatedOverlay.getPageSize = function() {
        
	    var xScroll, yScroll;
		
		if (window.innerHeight && window.scrollMaxY) {	
			xScroll = window.innerWidth + window.scrollMaxX;
			yScroll = window.innerHeight + window.scrollMaxY;
		} else if (document.body.scrollHeight > document.body.offsetHeight){ // all but Explorer Mac
			xScroll = document.body.scrollWidth;
			yScroll = document.body.scrollHeight;
		} else { // Explorer Mac...would also work in Explorer 6 Strict, Mozilla and Safari
			xScroll = document.body.offsetWidth;
			yScroll = document.body.offsetHeight;
		}
		
		var windowWidth, windowHeight;
		
		if (self.innerHeight) {	// all except Explorer
			if(document.documentElement.clientWidth){
				windowWidth = document.documentElement.clientWidth; 
			} else {
				windowWidth = self.innerWidth;
			}
			windowHeight = self.innerHeight;
		} else if (document.documentElement && document.documentElement.clientHeight) { // Explorer 6 Strict Mode
			windowWidth = document.documentElement.clientWidth;
			windowHeight = document.documentElement.clientHeight;
		} else if (document.body) { // other Explorers
			windowWidth = document.body.clientWidth;
			windowHeight = document.body.clientHeight;
		}	
		
		// for small pages with total height less then height of the viewport
		if(yScroll < windowHeight){
			pageHeight = windowHeight;
		} else { 
			pageHeight = yScroll;
		}
	
		// for small pages with total width less then width of the viewport
		if(xScroll < windowWidth){	
			pageWidth = xScroll;		
		} else {
			pageWidth = windowWidth;
		}

		return [pageWidth,pageHeight];
	}
	
	AnimatedOverlay.getWindowHeight = function() {

		var windowHeight = 0;
		if (typeof(window.innerHeight) == 'number') {
			windowHeight = window.innerHeight;
		}
		else {
			if (document.documentElement && document.documentElement.clientHeight) {
				windowHeight = document.documentElement.clientHeight;
			}
			else {
				if (document.body && document.body.clientHeight) {
					windowHeight = document.body.clientHeight;
				}
			}
		}
		return windowHeight;
	}
	
	AnimatedOverlay.getWindowWidth = function() {

		var windowWidth = 0;
		if (typeof(window.innerWidth) == 'number') {
			windowWidth = window.innerWidth;
		}
		else {
			if (document.documentElement && document.documentElement.clientWidth) {
				windowWidth = document.documentElement.clientWidth;
			}
			else {
				if (document.body && document.body.clientWidth) {
					windowWidth = document.body.clientWidth;
				}
			}
		}
		return windowWidth;
	}