/**
  * @version 2.2.26@1
  * @change 2011-10-23 Little modification for compatibility with Mootools 1.4; Added CT_Tools.submitFormAdv()
  * @change 2011-10-20 Added CT_MetaData
  * @change 2011-10-15 WARNING: Breaks compatibility; Renamed processorMatchList > matchList, processorOnMatch > onMatch, processorOnProcess > onProcess
  * @change 2011-10-03 Added CT_Layer.documentContainer, CT_Layer.autoClose for optimized closing behaviour
  * @change 2011-09-29 CT_Layer fires "fill".
  * @change 2011-08-30 CT_Tools.loadAjax now fires unload-Event before loading the new content; Added CT_Tools.addAjaxEvents() for temporary ajax events
  * @change 2011-08-28 Small fix; Clean up; Added CT_Tools.prependBaseUrl; Added parameter url to CT_Tools.submitForm()
  * @change 2011-08-12 Optimized CT_LayerForm and CT_Tools.submitForm
  * @change 2011-07-28 Added CT_Tools.loadAjax(); Fix in CT_Processor; Added event handlers to CT_Layer (show, hide, load); Added CT_Layer.current.url; Renamed CT_Layer.close to CT_Layer.hide; WARNING: Breaks compatibility
  * @change 2011-07-17 CT_Tools.submitForm: Parameter button is optional
  * @change 2011-07-14 Added CT_Tools.submitForm(); CT_ClickItem: Opera flicker fix with additional class "CT_ClickItem_NoUp"
  * @change 2011-07-07 Added CT_HoverItem compatibility for image maps
  * @change 2011-07-06 Added CT_Processor.current as static reference
  * @change 2011-07-02 Added CT_Processor.registerProcessedCallback(), CT_Processor.unregisterProcessedCallback()
  * @change 2011-06-03 Little fix in CT_HoverItem
  * @change 2011-05-29 Checkboxes and radio buttons can have click state; fixes
  * @change 2011-05-28 Checkbox and radio button skins are also provided via CT_HoverItem and CT_ClickItem
  * @change 2011-05-21 Redesigned processor and redesigned classes to processor plugins
  * @change 2011-05-17 Added image preload for CT_HoverItem; Optimized Layer and renamed to CT_Layer
  * @change 2011-05-04 Removed imageLink; Changed icon classes to CT_HoverItem and CT_ClickItem
  */

/* Available plugins
	CT_HoverItem - Skins buttons, links, check boxes and radio buttons
	CT_Label
	CT_LayerLink
	CT_InlineForm
	CT_LayerForm
	CT_MetaData
*/

  /* Example processor plugin
var Test = new Class({
	initialize: function(el, matchedClassName){ }
});
Test.matchList = ["div.myClass", "img.myOtherClass", "form"]; // Optional
Test.onProcess = function(container){ }; // Optional
Test.onMatch = function(el, matchedClassName){ }; // Optional
*/

var CT_Tools = new Class();
CT_Tools.baseUrl = '';
CT_Tools.ajaxOnLoaded = null;
CT_Tools.ajaxPrefix = '';
CT_Tools.loadAjax = function(url, data, target, callback, failureCallback){
	if(target){
		target.fireEvent('unload');
		
		var unloadHandler = target.retrieve('CT_UnloadHandler');
		if(unloadHandler){
			unloadHandler();
			target.store('CT_UnloadHandler', null);
		}
	}
	
	var req = new Request({evalScripts:true});
	if(failureCallback) req.onFailure = failureCallback;
	req.onSuccess = function(data){
		if(target){
			target.innerHTML = data;
			
			if(CT_Processor.current)
				CT_Processor.current.process(target);
			
			target.fireEvent('loaded');
		}
		if(callback) callback(data);
		
		if(CT_Tools.ajaxOnLoaded){
			CT_Tools.ajaxOnLoaded();
			CT_Tools.ajaxOnLoaded = null;
		}
	};
	if(url.indexOf('://') == -1){
		if(CT_Tools.ajaxPrefix && url.substr(0, CT_Tools.ajaxPrefix.length) != CT_Tools.ajaxPrefix)
			url = CT_Tools.ajaxPrefix + url;
		
		url = CT_Tools.prependBaseUrl(url);
	}
	
	req.send({url:url, method:"post", data:data});
}
CT_Tools.prependBaseUrl = function(url){
	if(url.indexOf('://') == -1) return CT_Tools.baseUrl + url;
	return url;
}
CT_Tools.submitFormAdv = function(form, url, button, target, successCallback, errorCallback){
	if(form.get('tag') != 'form')
		form = form.getParent('form');

	if(url) form.set('action', url);

	if(button){
		if(typeOf(button) != "string") button = button.get('name');

		var defaultButton = $$$('CT_Form_SubmitButton', form);
		if(!defaultButton){
			defaultButton = new Element('input', {type:'hidden', name:'CT_Form_SubmitButton', value: button});
			form.adopt(defaultButton);
		}else defaultButton.set('value', button);
	}

	form.set('send', {evalScripts: true,
		onComplete: function(data){
			if(target){
				target.innerHTML = data;
				CT_Processor.current.process(target);
			}

			if(successCallback) successCallback(data);
		},
		onFailure: errorCallback
	});
	form.send();

	return false;
}
CT_Tools.submitForm = function(element, button, url){
	element = $(element);
	if(element.get('tag') != 'form')
		element = element.getParent('form');
	
	if(button != null){
		var submitInput = $$$('CT_Form_SubmitButton', element);
		if(submitInput) submitInput.value = button;
		else{
			submitInput = new Element('input', {type:'hidden', name:'CT_Form_SubmitButton', value:button});
			element.adopt(submitInput);
		}
	}
	
	if(url){
		url = CT_Tools.prependBaseUrl(url);
		element.action = url;
	}
	
	if(element.retrieve('CT_InlineForm')) element.retrieve('CT_InlineForm').submit();
	else if(element.retrieve('CT_LayerForm')) element.retrieve('CT_LayerForm').submit();
	else element.submit();
	
	return false;
}
CT_Tools.ajaxEventStore = {};
CT_Tools.addAjaxEvents = function(events, ajaxContainer){
	if(!CT_Tools.ajaxEventStore[ajaxContainer]) CT_Tools.ajaxEventStore[ajaxContainer] = [];
	var i;
	
	if(ajaxContainer){
		var cb = function(){
			if(!CT_Tools.ajaxEventStore[ajaxContainer]) return;
			
			var store = CT_Tools.ajaxEventStore[ajaxContainer];
			
			for(i = 0; i < store.length; i++)
				store[i][0].removeEvent(store[i][1], store[i][2]);
			
			delete(CT_Tools.ajaxEventStore[ajaxContainer]);
		};
		
		ajaxContainer.store('CT_UnloadHandler', cb);
	}
	
	for(i = 0; i < events.length; i++){
		CT_Tools.ajaxEventStore[ajaxContainer].push(events[i]);
		events[i][0].addEvent(events[i][1], events[i][2]);
	}
}

var CT_Processor = new Class({
	initialize: function(){
		this.matchList = [];
		this.plugins = [];
		this.processedCallbacks = [];
		CT_Processor.current = this;
	},
	registerAll: function(){ this.registerList([CT_HoverItem, CT_Label, CT_LayerLink, CT_InlineForm, CT_LayerForm]); },
	registerProcessedCallback: function(callback){
		this.processedCallbacks.push(callback);
	},
	unregisterProcessedCallback: function(callback){
		var j;
		for(j = 0; j < this.processedCallbacks.length; j++){
			if(this.processedCallbacks[j] == callback){
				this.processedCallbacks.splice(j, 1);
				return;
			}
		}
	},
	register: function(plugin){
		if(!plugin) return;

		this.plugins.push(plugin);

		if(plugin.matchList)
			this.matchList.push(plugin.matchList.join(','));
	},
	registerList: function(pluginList){
		for(var i = 0; i < pluginList.length; i++) this.register(pluginList[i]);
	},
	process: function(container){
		var i, j, k;

		var el;
		var plg;

		var elements = container.getElements(this.matchList.join(','));

		for(i = 0; i < elements.length; i++){
			el = elements[i];
			for(j = 0; j < this.plugins.length; j++){
				plg = this.plugins[j];

				if(plg.matchList){
					for(k = 0; k < plg.matchList.length; k++){
						if(el.match(plg.matchList[k])){
							if(plg.onMatch)
								plg.onMatch(el, plg.matchList[k]);
							else new plg(el, plg.matchList[k]);
						}
					}
				}
			}
		}

		for(j = 0; j < this.plugins.length; j++){
			if(this.plugins[j].onProcess)
				this.plugins[j].onProcess(container);
		}

		for(j = 0; j < this.processedCallbacks.length; j++)
			this.processedCallbacks[j](container);
	}
});
CT_Processor.current = null;

/* Maps JSON-data of var-tags to _data-attribute */
var CT_MetaData = new Class();
CT_MetaData.onMatch = function(el, match){
	el.getParent().store('_data', JSON.decode(el.innerHTML));
	el.destroy();
}
CT_MetaData.matchList = ["var"];

/* Verknüpft ein Label mit einer Image-Checkbox bzw. einem Image-RadioButton. */
var CT_Label = new Class({
	Binds: ['onClick', 'onOver', 'onOut'],
	initialize: function(element, match){
		this.element = element;

		this.input = $(this.element.get('for'));
		this.element.addEvent('click', this.onClick);
		this.element.addEvent('mouseover', this.onOver);
		this.element.addEvent('mouseout', this.onOut);
	},
	onClick: function(e){
		this.input.retrieve('CT_SkinnedInputElement').onDisplayClicked();
		e.stop();
	},
	onOver: function(e){
		this.input.retrieve('CT_SkinnedInputElement').onDisplayOver();
		e.stop();
	},
	onOut: function(e){
		this.input.retrieve('CT_SkinnedInputElement').onDisplayOut();
		e.stop();
	}
});
CT_Label.matchList = ["label"];
CT_Label.onMatch = function(el, match){
	if(el.get('for') && $(el.get('for')) && $(el.get('for')).retrieve('CT_SkinnedInputElement'))
		new CT_Label(el);
};

/* Ermöglicht eine gestaltete Checkbox. Wird mit der Klasse CT_HoverItem kombiniert, um die Bilddarstellung und Hoverzustände zu ermöglichen. */
var CT_CheckboxElement = new Class({
	Binds: ['onElementChanged', 'onDisplayClicked'],

	initialize: function(element, match){
		this.element = element;
		this.element.addEvent('change', this.onElementChanged);
		this.element.store('CT_SkinnedInputElement', this);

		// Add display
		this.display = new Element('a', {'class': this.element.get('class'), href:'.', title: this.element.get('title')});
		this.display.inject(this.element, 'before');
		this.display.addEvent('click', this.onDisplayClicked);
		new CT_HoverItem(this.display, match);

		// Hide element
		this.element.setStyle('display', 'none');

		// Set initial state
		if(this.element.get('checked'))
			this.set(true);
	},
	onElementChanged: function(e){
		this.display.store('CT_Toggled', this.element.get('checked'));
		this.display.fireEvent('refresh');
	},
	onDisplayClicked: function(e){
		this.set(!this.element.get('checked'));

		if(e) e.stop();
	},
	onDisplayOver: function(e){
		this.display.fireEvent('mouseover');
	},
	onDisplayOut: function(e){
		this.display.fireEvent('mouseout');
	},
	set: function(val){
		this.element.set('checked', val);
		this.display.store('CT_Toggled', val);
		this.display.fireEvent('refresh');
	}
});

/* Ermöglicht einen gestalteten Radiobutton. Wird mit der Klasse CT_HoverItem kombiniert, um die Bilddarstellung und Hoverzustände zu ermöglichen. */
var CT_RadioElement = new Class({
	Binds: ['onElementChanged', 'onDisplayClicked'],

	initialize: function(element, match){
		this.element = element;
		this.element.addEvent('change', this.onElementChanged);
		this.element.store('CT_SkinnedInputElement', this);

		this.storeId = 'CT_InputRadioButton_'+this.element.get('name');

		// Get container form
		this.form = element.getParent('form');
		if(this.form == null) this.form = $(document.body);

		// Add item to radio button group
		if(!this.form.retrieve(this.storeId))
			this.form.store(this.storeId, [this]);
		else{
			var elements = this.form.retrieve(this.storeId);
			elements.push(this);
			this.form.store(this.storeId, elements);
		}

		// Add display
		this.display = new Element('a', {'class': this.element.get('class'), href:'.', title: this.element.get('title')});
		this.display.inject(this.element, 'before');
		this.display.addEvent('click', this.onDisplayClicked);
		new CT_HoverItem(this.display, match);

		// Hide element
		this.element.setStyle('display', 'none');

		// Set initial state
		if(this.element.get('checked'))
			this.set(true);
	},
	onElementChanged: function(e){
		this.display.store('CT_Toggled', this.element.get('checked'));
		this.display.fireEvent('refresh');

		if(this.element.get('checked')){
			var elements = this.form.retrieve(this.storeId);
			for(var i = 0; i < elements.length; i++){
				var el = elements[i];
				if(el != this)
					el.set(false);
			}
		}
	},
	onDisplayClicked: function(e){
		this.element.set('checked', !this.element.get('checked'));
		this.element.fireEvent('change');
		e.stop();
	},
	onDisplayOver: function(e){
		this.display.fireEvent('mouseover');
	},
	onDisplayOut: function(e){
		this.display.fireEvent('mouseout');
	},
	set: function(val){
		this.element.set('checked', val);
		this.display.store('CT_Toggled', val);
		this.display.fireEvent('refresh');
	}
});

/* Richtet Hoverzustände für ein Element ein, das eine Hintergrundgrafik nutzt. Schema: ...-normal. , ...-over, ...-click. */
var CT_HoverItem = new Class({
	Binds: ['onOver', 'onOut', 'onRefresh', 'onDown', 'onUp'],

	initialize: function(element, match){
		this.mouseInside = false;
		
		var target = element.get("usemap") ? $(element.get("usemap").substr(1)) : element;

		this.element = element;
		target.addEvent('mouseover', this.onOver);
		target.addEvent('mouseout', this.onOut);
		target.addEvent('refresh', this.onRefresh);

		if(match === true || match == ".CT_ClickItem"){
			target.addEvent('mousedown', this.onDown);
			if(!element.hasClass("CT_ClickItem_NoUp"))
				target.addEvent('mouseup', this.onUp);
			this.clickState = true;
		}else
			this.clickState = false;

		// Preload images
		var img = new Image();
		img.src = this._getVal(true);
		img = new Image();
		img.src = this._getVal(true).replace(/-normal\./, "-over.");
		if(this.clickState){
			img = new Image();
			img.src = this._getVal(true).replace(/-normal\./, "-click.");
		}
	},

	onDown: function(){
		var url = this._getVal();
		url = url.replace(/-normal\./,"-click.");
		url = url.replace(/-over\./,"-click.");
		this._setVal(url);
	},
	onUp: function(){
		var url = this._getVal();
		url = url.replace(/-click\./,"-over.");
		this._setVal(url);
	},
	onOver: function(e){
		if(e)
			this.mouseInside = true;
		var url = this._getVal();
		url = url.replace(/-click\./,"-over.");
		url = url.replace(/-normal\./,"-over.");
		this._setVal(url);
	},
	onOut: function(e){
		if(e)
			this.mouseInside = false;
		var toggled = this.element.retrieve("CT_Toggled");

		var url = this._getVal();

		if(toggled){
			if(this.clickState){
				url = url.replace(/-normal\./,"-click.");
				url = url.replace(/-over\./,"-click.");
			}else{
				url = url.replace(/-normal\./,"-over.");
				url = url.replace(/-click\./,"-over.");
			}
		}else{
			url = url.replace(/-over\./,"-normal.");
			url = url.replace(/-click\./,"-normal.");
		}
		this._setVal(url);
	},
	onRefresh: function(){
		if(this.element.retrieve("CT_Toggled")){
			if(this.clickState)
				this.onDown();
			else
				this.onOver();
		}else if(this.mouseInside)
			this.onOver();
		else
			this.onOut();
	},
	_getVal: function(stripped){
		if(this.element.tagName.toLowerCase() == "img")
			return this.element.get("src");
		else{
			var src = this.element.getStyle("background-image");
			if(!stripped) return src;
			src = src.match(/url\([\"']?([^"']+)[\"']?\)/);
			if(src) return src[1];
			return "";
		}
	},
	_setVal: function(val, stripped){
		if(this.element.tagName.toLowerCase() == "img")
			this.element.set("src", val);
		else{
			if(stripped) this.element.setStyle('background-image', 'url("'+val+'")');
			else this.element.setStyle('background-image', val);
		}
	}
});
CT_HoverItem.matchList = [".CT_HoverItem", ".CT_ClickItem"];
CT_HoverItem.onMatch = function(el, match){
	if(el.get('tag') == 'input'){
		if(el.get('type') == 'checkbox')
			new CT_CheckboxElement(el, match);
		else if(el.get('type') == 'radio')
			new CT_RadioElement(el, match);
		else new CT_HoverItem(el, match);
	}else new CT_HoverItem(el, match);
}

/* Wird auf Links angewendet, die als Layer angezeigt werden sollen. */
var CT_LayerLink = new Class({
	Binds: ['onClick'],

	initialize: function(linkEl, match){
		this.link = linkEl;
		this.link.addEvent('click', this.onClick);
	},

	onClick: function(e){
		var url = this.link.get('href');
		if(url.indexOf('://') == -1)
			url = CT_LayerLink.layerUrlPrefix + url;

		CT_Layer.current.load(url);
		e.stop();
	}
});
CT_LayerLink.layerUrlPrefix = '';
CT_LayerLink.matchList = ["a.CT_LayerLink"];

/* Anpassung von Formularen, die auf die Hauptseite abgeschickt werden. */
var CT_InlineForm = new Class({
	Binds: ['onKeyPress', 'onReturnKey', 'onSubmit'],

	initialize: function(el, match){
		el.store('CT_InlineForm', this);
		
		this.initForm(el);
	},
	initForm: function(el){
		this.form = el;
		this.form.addEvent('keypress', this.onKeyPress);
		this.form.addEvent('submit', this.onSubmit);
		
		this.defaultButton = $$$('CT_Form_SubmitButton', this.form);
		if(this.defaultButton == null){
			this.defaultButton = new Element('input', {type:'hidden', name:'CT_Form_SubmitButton'});
			this.form.adopt(this.defaultButton);
		}
	},
	submit: function(){
		this.onSubmit();
	},
	onReturnKey: function(){
		var currentDefBtn = this.form.getElements('input.defaultButton');
		if(currentDefBtn)
			this.defaultButton.value = currentDefBtn.get('name');
		
		return true;
	},
	onSubmit: function(e){
		this.form.submit();
	},
	onKeyPress: function(e){
		var target;
		if(e.keyCode == 13){
			target = e.target ? e.target : event.srcElement;
			if(target && target.nodeName.toLowerCase() != "textarea"){
				if(!this.onReturnKey())
					e.stop();
			}
		}
	}
});
CT_InlineForm.matchList = ["form.CT_InlineForm"];

/* Anpassung von Formularen, die in einen Layer abgeschickt werden. */
var CT_LayerForm = new Class({
	Extends: CT_InlineForm,
	Binds: ['onComplete', 'onClickButton', 'onKeyPress'],

	initialize: function(el, match){
		el.store('CT_LayerForm', this);
		
		el.addEvent('keypress', this.onKeyPress);
		
		this.initForm(el);
		
		var els = this.form.getElements('input');
		if(els.length > 0){
			for(var i = 0; i < els.length; i++){
				var el = els[i];

				if(el.get('type') == 'submit')
					el.addEvent('click', this.onClickButton);
			}
		}
	},
	
	onKeyPress: function(event){
		var target;
		if(event.key == 'enter'){
			target = event.target ? event.target : event.srcElement;
			if(target && target.nodeName.toLowerCase() != "textarea"){
				event.stop();
				this.onSubmit();
			}
		}
	},
	
	onSubmit: function(e){
		this.form.set('send', {evalScripts: true, onComplete: this.onComplete});
		this.form.send();
		if(e)
			e.stop();
	},
	onComplete: function(response){
		CT_Layer.current.fill(response);
	},
	onClickButton: function(e){
		var target = $(e.target ? e.target : e.srcElement);
		if(target && target.nodeName.toLowerCase() == "input"){
			this.defaultButton.value = target.get('name');
			this.onSubmit();
		}
		e.stop();
	}
});
CT_LayerForm.matchList = ["form.CT_LayerForm"];

/** Creates a layer */
var CT_Layer = new Class({
	Extends: this.Events,
	Binds: ['show', 'hide', 'fill', 'onDocumentClick', 'onKeyPress', 'onRequestFailure'],
	initialize: function(){
		CT_Layer.current = this;
		this.documentContainer = null;
		this.autoClose = true;
		this.visible = false;
		this.layer = new Element('div', {'class':'CT_Layer'});
		this.url = null;
		
		$(document.body).adopt(this.layer);
		
		this.layer.fade('hide');
		
		this.request = new Request({evalScripts: true});
		this.request.onFailure = this.onRequestFailure;
		this.request.onSuccess = this.fill;
	},
	show: function(){
		if(this.visible) return;
		
		this.visible = true;
		this.layer.fade('in');
		
		if(this.autoClose){
			$(document.body).addEvent('click', this.onDocumentClick);
			$(document.body).addEvent('keypress', this.onKeyPress);
		}
		
		this.fireEvent('show');
	},
	hide: function(e){
		if(e) e.stop();
		
		if(!this.visible) return;
		
		this.visible = false;
		this.fireEvent('hide');
		this.url = null;
		this.layer.fade('out');
		$(document.body).removeEvent('click', this.onDocumentClick);
		$(document.body).removeEvent('keypress', this.onKeyPress);
	},
	load: function(url, vars){
		this.url = url;
		
		this.fireEvent('load');
		
		// Prepare url
		if(url.search(/^[a-z]+:\/\//) == -1){
			// If starts with slash prepend domain
			if(url.substr(0, 1) == '/')
				url = window.location.protocol + "/" + window.location.host + url;
			else{
				var basePath = $$('base');
				
				// If basepath
				if(basePath.length > 0){
					basePath = basePath[0].href;
					basePath = basePath.substring(0, basePath.lastIndexOf("/")) + "/";
					url = basePath + url;
					
				// Otherwise use current location
				}else
					url = window.location.protocol + "/" + window.location.host + window.location.pathname + url;
			}
		}
		
		
		if(vars) this.request.send({url:url, method:'post', data:vars});
		else this.request.send({url:url});
	},
	fill: function(content){
		this.fireEvent('fill');
		this.layer.innerHTML = content;
		
		p.process(this.layer);
		
		this.show();
	},
	
	onDocumentClick: function(e){
	if((this.documentContainer == null && !isChildOf(e.target, this.layer, true)) || (this.documentContainer && isChildOf(e.target, this.documentContainer, true)))
		this.hide();
	},
	onKeyPress: function(e){
		if(e.key == 'esc') this.hide();
	},
	onRequestFailure: function(){ }
});
CT_Layer.current = null;

/** Sucht nach einem Element mit bestimmtem Namen (nicht ID), das sich in einem anderen Element befindet. */
function $$$(nodeName, parentNode){
	var el = document.getElementsByName(nodeName);
	if(el){
		if(parentNode == null)
			return $(el[0]);
		else{
			for(i = 0; i < el.length; i++){
				if(isChildOf(el[i], parentNode, true)) return $(el[i]);
			}
		}
	}
	return null;
}

/** Prüft, ob sich das Element in einem anderen befindet. */
function isChildOf(node, container, containerIsNode){
	while(node.parentNode != null){
		if(containerIsNode == true){
			if(node == container) return true;
		}else
			if(node.id == container) return true;
		node = node.parentNode;
	}
	return false;
}

/** Führt eine verzögerte Weiterleitung aus. */
function delayedForwarding(url, delaySeconds){
	setTimeout('window.location.href="'+url+'"', delaySeconds*1000);
}

/* Ajax-basierter Tooltip, der beim Überfahren eines Elements angefragt und angezeigt wird. */
/*var ToolTipElement = new Class({
	Binds: ['onOver', 'onOut', 'onRequestFinished'],
	initialize: function(element){
		this.element = element;
		this.element.scrollTo(0,0);
		this.element.addEvent('mouseover', this.onOver);
		this.element.addEvent('mouseout', this.onOut);
	},
	onOver: function(e){
		var el = $(document.body).retrieve('toolTipContainer');
		el.fade('in');
		el.empty();

		if(this.requestResult)
			el.innerHTML = this.requestResult;
		else{
			var req = new Request.HTML({update: el, onSuccess: this.onRequestFinished});
			var data = this.element.retrieve('Tip');
			req.get($(document.body).retrieve('toolTipCallback')(el, data[0], data[1]));
		}

		var pos = this.element.getCoordinates();
		el.setPosition({x:pos.right + 20, y:pos.top});
	},
	onOut: function(e){
		var el = $(document.body).retrieve('toolTipContainer');
		el.fade('out');
	},
	onRequestFinished: function(tree, elements, html, script){
		this.requestResult = html;
	}
});*/