// Include external JS-Files
/*'/js/general/ease/json/json.js'*/
var includeFiles = [
	'/js/general/ease/ajaxslt/misc.js',					
	'/js/general/ease/ajaxslt/dom.js',					
	'/js/general/ease/ajaxslt/xpath.js',					
	'/js/general/ease/ajaxslt/xslt.js'
];

var head = document.getElementsByTagName('head')[0];
var jsTag = [];
for (var i = 0; i < includeFiles.length; i++)
{
	jsTag[i] = document.createElement('script');
	jsTag[i].setAttribute('src',includeFiles[i]);
	head.appendChild(jsTag[i]);
}

// Disable logging by Google AJAXSLT
logging__ = false;
logging = false;
xsltdebug = false;
xpathdebug = false;

/*
 * Object Ease
 * Create the Ease object, on which all following functions and classes depend
 *
 */
var Ease = (Ease && typeof Ease == 'object') ? Ease :
{
	version : '0.7',
	author : 'Tobias Mueller, Cologne, Germany',
	copyright : 'Tobias Mueller, Cologne, Germany',
	errorReporting : 1
};

/*
 *
 * Object Ease.Errors
 *
 */
Ease.Errors =
{
	create : function(msg)
	{
		if (Ease.errorReporting == 1)
		{
			throw new Error(msg);
		}
		else if (Ease.errorReporting == 2)
		{
			Ease.Errors.report(msg);
			
			return true;
		}
		else
		{
			return true;
		}
	},
	
	report : function(msg,file,line)
	{
		if (Ease.errorReporting == 1)
		{
			return false;
		}
		else if (Ease.errorReporting == 2)
		{
			var logParams = '';
			logParams += 'message=' + msg
			logParams += file ? '&file=' + file : '';
			
			var ErrorLog = new Ease.Ajax('/ease/log/ease.log.write.php',{ params:logParams, method:'POST' });
			ErrorLog.handleRequest();
			
			return true;
		}
		else
		{
			return true;
		}
	}
};

/*
 *
 * Object Ease.UA
 *
 */
Ease.UA =
{
	getSystem : navigator.platform.toLowerCase(),
	getAgent : navigator.userAgent.toLowerCase(),
	hasDOM : false,
	hasAjax : false,
	isOpera : false,
	isIE : false,
	isKHTML : false,
	isGecko : false,
	isOperaVersion : null,
	isIEVersion : null,
	isGeckoBuildDate : null,
	
	check : function()
	{
		if (this.getSystem.indexOf('mac') != -1)
			this.isSystem = 'mac';
		else if (this.getSystem.indexOf('win') != -1)
			this.isSystem = 'win';
		else
			this.isSystem = 'other';
		
		this.hasDOM = (document.getElementById && document.createElement) ? true : false;
		this.hasAjax = (this.hasDOM && (window.XMLHttpRequest || window.ActiveXObject)) ? true : false;
		
		if (this.hasDOM)
		{
			if (window.opera)
			{
				this.isOpera = true;
				this.getOperaVersion();
			}
			
			if (document.all && !this.isOpera)
			{
				this.isIE = true;
				this.isIEMac = (this.isSystem == 'mac') ? true : false;
				if (!this.isIEMac)
					this.getIEVersion();
			}
			
			this.isKHTML = (document.clientWidth) ? true : false;
			
			if (!this.isKHTML && !this.isIE && !this.isOpera && window.updateCommands)
			{
				this.isGecko = true;
				this.getGeckoBuildDate();
			}
		}
		else
		{
			Ease.Errors.create('Ease.UA.check(): This browser does not support DOM.');
		}
	},
	
	getOperaVersion : function()
	{
		this.isOperaVersion = 
			(!document.addEventListener) ? 6 :
			(document.addEventListener && !document.getElementsByTagNameNS) ? 7 : 
			(document.getElementsByTagNameNS && !document.designMode) ? 8 :
			(document.designMode) ? 9 :
			'undefined';
	},
	
	getIEVersion : function()
	{
		this.isIEVersion = 
			(!document.createEventObject) ? 5 :
			(document.createEventObject && !document.compatMode) ? 5.5 : 
			(document.compatMode && !window.XMLHttpRequest) ? 6 :
			(window.XMLHttpRequest) ? 7 :
			'undefined';
	},
	
	getGeckoBuildDate : function()
	{
		this.isGeckoBuildDate = new Number(this.getAgent.match(/.*gecko\/(\d{8}).*/)[1]);
	}
};

if (Ease.UA && Ease.Errors)
{
	window.onerror = Ease.Errors.report;
	Ease.UA.check();
}

/*
 *
 * Object Ease.DOM
 *
 */
Ease.DOM =
{
	getElems : function()
	{
		if (Ease.UA.hasDOM)
		{
			var args = arguments;
			var elems = [];
			var elem = null;
			
			for (var i = 0; i < args.length; i++)
			{
				if (typeof args[i] == 'string')
				{
					elem = document.getElementById(args[i]) || null;
				}
				else if (typeof args[i] == 'object')
				{
					if (args[i].method != null && args[i].find != null)
					{
						elem = this.getElemsBy(args[i]);
						if (elem && args[i].index != null)
						{
							elem = elem.length > args[i].index
								? elem[args[i].index]
								: null;
						}
					}
					else
						elem = args[i];
				}
				
				if (elem == null)
					Ease.Errors.create('Ease.DOM.getElems(): element not found, argument index: ' + i);
				
				if (args.length == 1)
					return elem;
				
				elems.push(elem);
			}
			
			return elems;
		}
	},
	
	getElemsBy : function(argsObj)
	{
		if (Ease.UA.hasDOM)
		{
			var elem = null;
	
			var args =
			{
				method : argsObj.method.toLowerCase() || null,
				elem : argsObj.find || null,
				parentNode : argsObj.parentNode || document
			}
			
			if (typeof args.method == 'string' && typeof args.elem == 'string')
			{
				switch (args.method)
				{
					case 'name' :
						elem = args.parentNode.getElementsByName(args.elem);
						break;
					case 'classname' :
						elem = this.getElemsByClassName(args.elem,args.parentNode);
						break;
					case 'tagname' :
						elem = args.parentNode.getElementsByTagName(args.elem);
						break;
				}
				
				if (elem == null)
					Ease.Errors.create('Ease.DOM.getElemsBy(): element not found.');
				
				return elem && elem.length >= 1
					? elem 
					: null;
			}
		}
	},
	
	getElemsByClassName : function(className,parentNode)
	{
		if (Ease.UA.hasDOM)
		{
			parentNode = typeof parentNode == 'object'
				? parentNode
				: document;
			var allElems = parentNode.getElementsByTagName('*');
			var elemsWithClass = [];
			
			for (var i = 0; i < allElems.length; i++)
			{
				if (allElems[i].className.match(new RegExp('\\b' + className + '\\b')))
					elemsWithClass.push(allElems[i]);
			}
			
			return elemsWithClass.length > 0
				? elemsWithClass
				: {};
		}
	},
	
	parseXMLFromString : function(data)
	{
		if (data && typeof data == 'string')
		{
			var domDoc = null;
			
			try
			{
				domDoc = new ActiveXObject('MSXML2.DOMDocument.3.0');
				domDoc.async = false;
				domDoc.loadXML(data);
			}
			catch (e)
			{
				try
				{
					if (Ease.UA.isGecko)
						domDoc = (new DOMParser()).parseFromString(data, 'text/xml');
					else
						domDoc = xmlParse(data);
				}
				catch (e)
				{
					Ease.Errors.create('Ease.DOM.parseXMLFromString(): XML parsing failed.');
				}
			}
			
			return domDoc;
		}
	},
	
	parseHTMLFromString : function(data)
	{
		if (data && typeof data == 'string')
		{
			var domNode = null;
			var wrapperElem = document.createElement('div');
			
			wrapperElem.innerHTML = data;
			
			if (wrapperElem.childNodes.length <= 1)
			{
				domNode = wrapperElem.firstChild;
			}
			else
			{
				domNode = [];
				
				for (var i = 0; i < wrapperElem.childNodes.length; i++)
					domNode.push(wrapperElem.childNodes[i]);
			}
			
			return domNode;
		}
			
		return data;
	},
	
	xslTransform : function(xml, xsl, retObj)
	{
		if (xml && xsl)
		{
			var output = null;
			
			xml = typeof xml == 'object' ? xml : this.parseXMLFromString(xml);
			xsl = typeof xsl == 'object' ? xsl : this.parseXMLFromString(xsl);
			
			try
			{
				var xmlDoc = null;
				var xslDoc = null;
				
				xmlDoc = new ActiveXObject('MSXML2.DOMDocument.3.0');
				xmlDoc.async = false;
				xmlDoc.load(xml);
				
				xslDoc = new ActiveXObject('MSXML2.DOMDocument.3.0');
				xslDoc.async = false;
				xslDoc.load(xsl);
				
				output = xmlDoc.transformNode(xslDoc);
				
				if (retObj == true)
					output = this.parseHTMLFromString(output);
			}
			catch (e)
			{
				try
				{
					if (Ease.UA.isGecko)
					{
						var xsltProcessor = null;
						var outputDoc = null;
						var outputXML = null;
						
						xsltProcessor = new XSLTProcessor();
						xsltProcessor.importStylesheet(xsl);
						
						output = xsltProcessor.transformToFragment(xml,document);
						
						if (retObj == false)
							output = (new XMLSerializer()).serializeToString(output);
					}
					else
					{
						output = xsltProcess(xml, xsl);
						
						if (retObj == true)
							output = this.parseHTMLFromString(output);
					}
				}
				catch (e)
				{
					Ease.Errors.create('Ease.DOM.xslTransform(): XSL transformation failed.');
				}
			}
			
			return output;
		}
	},
	
	findFirstElementNode : function(parentNode)
	{
		if (typeof parentNode == 'object')
		{
			var count = 0;
			
			while (parentNode.childNodes[count].nodeType != 1)
			{
				count++;
			}
			
			return parentNode.childNodes[count];
		}
	},
	
	removeChildNode : function(parentNode, node)
	{
		parentNode = Ease.DOM.getElems(parentNode).firstChild;
		node = Ease.DOM.getElems(node);
		parentNode.removeChild(node);
	},
	
	removeAllChildNodes : function(parentNode)
	{
		parentNode = Ease.DOM.getElems(parentNode);
		parentNode.innerHTML = '';
	},
	
	appendChild : function(elem,appendTo,insertBefore)
	{
		if (appendTo && typeof appendTo == 'object')
		{
			if (insertBefore && typeof insertBefore == 'object')
				appendTo.insertBefore(elem,insertBefore);
			else
				appendTo.appendChild(elem);
		}
	},
	
	createElement : function(element,attributes,content,appendTo,insertBefore)
	{
		var elem = document.createElement(element);
		
		if (attributes && typeof attributes == 'object')
		{
			for (var attr in attributes)
			{
				if (attr.toLowerCase() != 'class')
					elem.setAttribute(attr.toLowerCase(),attributes[attr]);
				else
					elem.className = attributes[attr];
			}
		}
		
		if (content)
		{
			if (typeof content == 'string')
				var content = document.createTextNode(content);
				
			if (content.nodeType)
				elem.appendChild(content);
		}
		
		if (appendTo && typeof appendTo == 'object')
		{
			this.appendChild(elem,appendTo,insertBefore);
		}
		else
		{
			return elem;
		}
	},
	
	getDimensions : function(obj)
	{
		if (Ease.UA.hasDOM)
		{
			obj = Ease.DOM.getElems(obj);
			
			var dimensions =
			{
				width : obj.offsetWidth,
				height : obj.offsetHeight
			};
			
			return dimensions;
		}
	},
		
	getPosition : function(obj)
	{
		if (Ease.UA.hasDOM)
		{
			obj = Ease.DOM.getElems(obj);
			var position =
			{ 
				x : 0,
				y : 0
			};
			
			do
			{
				position.x += obj.offsetLeft;
				position.y += obj.offsetTop;
			}
			while (obj = obj.offsetParent);
			
			return position;
		}
	}
};

/*
 *
 * Object Ease.Forms
 *
 */
Ease.Forms =
{
	getElem : function(form,element,parentNode)
	{
		if (Ease.UA.hasDOM)
		{
			parentNode = typeof parentNode == 'object' 
				? parentNode
				: document;
	
			var formElem = parentNode.forms[form].elements[element];
			
			return formElem && typeof formElem == 'object' 
				? formElem
				: null;
		}
	},
	
	createRequestStr : function(form,parentNode)
	{
		if (Ease.UA.hasDOM)
		{
			if (typeof form == 'string' || typeof form == 'number')
			{
				parentNode = typeof parentNode == 'object' 
					? parentNode
					: document;
				form = parentNode.forms[form];
			}
			
			if (typeof form != 'object')
				return '';
			
			var formElems = form.elements;
			
			var reqStr = '';
			var count = 0;
			var options;
			
			for (var i = 0; i < formElems.length; i++)
			{
				if (formElems[i].name)
				{
					if (!(formElems[i].type.toLowerCase() == 'radio') && !(formElems[i].type.toLowerCase() == 'checkbox'))
					{
						if (!formElems[i].multiple)
						{
							reqStr += count > 0 ? '&' : '?';
							reqStr += formElems[i].name;
							reqStr += '=';
							reqStr += formElems[i].value;
						}
						else
						{
							options = formElems[i].options;
							
							for (var j = 0; j < options.length; j++)
							{
								if (options[j].selected == true)
								{
									reqStr += count > 0 ? '&' : '?';
									reqStr += formElems[i].name;
									reqStr += '=';
									reqStr += options[j].value;
								}
							}
						}
					}
					else
					{
						if (formElems[i].checked == true)
						{
							reqStr += count > 0 ? '&' : '?';
							reqStr += formElems[i].name;
							reqStr += '=';
							reqStr += formElems[i].value;
						}
					}
					
					count++;
				}
			}
			
			reqStr = typeof encodeURI == 'function' ? encodeURI(reqStr) : escape(reqStr);
			
			return reqStr;
		}
	}
};

/*
 *
 * Object Ease.Ajax
 *
 */
Ease.Ajax = 
{
	postHeader : ['Content-Type','application/x-www-form-urlencoded;'],
	noCacheHeader : ['If-Modified-Since','Sat, 1 Jan 2000 00:00:00 GMT'],
	msXMLObjs : ['MSXML2.XMLHTTP.5.0','MSXML2.XMLHTTP.4.0','MSXML2.XMLHTTP.3.0','MSXML2.XMLHTTP','Microsoft.XMLHTTP'],
	
	createRequest : function()
	{
		if (Ease.UA.hasAjax)
		{
			var req = null;
			
			if (window.XMLHttpRequest)
			{
				req = new XMLHttpRequest();
			}
			else if (window.ActiveXObject)
			{
				for (var i = 0; i < Ease.Ajax.msXMLObjs.length; i++)
				{
					try
					{
						req = new ActiveXObject(Ease.Ajax.msXMLObjs[i]);
						break;
					}
					catch (e)
					{
						continue;
					}
				}
			}
			
			if (req != null)
				return req;
			
			Ease.Errors.create('Ease.Ajax.createRequest(): Could not create a XMLHttpRequest.');
		}
	},
	
	handleRequest : function(url,req,properties)
	{
		if (req != null)
		{
			var props = {
				url : url,
				method : 'GET',
				async : true,
				params : null,
				exec : function() { return true; },
				headers : null,
				useCache : false
			};
			
			if (properties && typeof properties == 'object')
			{
				for (var prop in properties)
					props[prop] = properties[prop];
			}
			
			if (req.overrideMimeType)
				req.overrideMimeType('text/xml');
			
			var self = this;
			req.onreadystatechange = function()
			{
				Ease.Ajax.doOnLoad(req,props);
			};
			
			props.method = props.method.toUpperCase();
			if (props.method == 'POST')
			{
				contentTypeIndex = null;
				contentType = null;
				postCharset = null;

				if (props.headers)
				{
					contentTypeIndex = parseInt(props.headers.contains('Content-Type'))
					if (contentTypeIndex != -1)
					{
						contentType = props.headers[parseInt(contentTypeIndex)+1]
						postCharset = contentType.slice(contentType.indexOf(';')+1);
						props.headers.splice(contentTypeIndex,2)
					}
						
					if (props.headers.contains(Ease.Ajax.postHeader[1]) == -1)
						props.headers.push(Ease.Ajax.postHeader[0],postCharset ? Ease.Ajax.postHeader[1] + ' ' + postCharset : Ease.Ajax.postHeader[1]);
				}
				else
				{
					props.headers = [Ease.Ajax.postHeader[0],Ease.Ajax.postHeader[1]];
				}
			}
			else if (props.method == 'GET' && props.params != null) 
			{
				props.url += '?' + props.params;
				props.params = null;
			}
			
			if (props.useCache == false)
			{
				if (props.headers)
					props.headers.push(Ease.Ajax.noCacheHeader[0],Ease.Ajax.noCacheHeader[1]);
				else
					props.headers = Ease.Ajax.noCacheHeader;
			}
			
			req.open(props.method, props.url, props.async);

			if (props.headers)
			{
				for (var i = 0; i < props.headers.length-1; i+=2)
				{
					req.setRequestHeader(props.headers[i],props.headers[i+1]);
					//alert('Wert: ' + props.headers[i] + '\nEigenschaft: ' + props.headers[i+1])
				}
			}
			
			req.send(props.params);
		}
		else
		{
			Ease.Errors.create('Ease.Ajax.handleRequest(): The XMLHttpRequest has failed.');
		}
	},
	
	doOnLoad : function(req,props)
	{
		if (req != null && req.readyState == 4)
		{
			if (req.status == 200 || req.status == 0)
			{
				props.exec();
			}
			else
			{
				Ease.Errors.create('Ease.Ajax.doOnLoad(): The XMLHttpRequest has failed. Error status: ' + req.status);
			}
		}
	}
}

/*
 * Class Ease.Ajax.Request
 * var Ajax = new Ease.Ajax('test.xml',{ params:'abc=true&xyz=true', method:'post', async:true });
 * 
 */
Ease.Ajax.Request = function(url,properties)
{
	this.req = null;
	if (Ease.UA.hasAjax)
	{
		this.url = url;
		this.method = 'GET';
		this.async = true;
		this.params = null;
		this.useForm = false;
		this.responseText = null;
		this.responseXML = null;
		this.responseJSON = null;
		
		if (properties && typeof properties == 'object')
		{
			for (var prop in properties)
			{
				this[prop] = properties[prop];
			}
		}
		
		if (typeof this.useForm == 'number' || this.useForm)
			this.getFormData();
		
		this.req = Ease.Ajax.createRequest();
	}
}

Ease.Ajax.Request.prototype =
{
	getFormData : function()
	{
		var form = this.useForm;
		
		if (typeof form == 'string' || typeof form == 'number')
			form = document.forms[form];
		
		this.url = form.action;
		this.params = Ease.Forms.createRequestStr(form);
	},
	
	// AjaxTest.handleRequest({ exec:function(){ alert(AjaxTest.request.responseText) }, headers:['Content-Type','application/x-www-form-urlencoded'] });
	handle : function(properties)
	{
		if (this.req != null)
		{
			var self = this;
			var props =
			{
				method : this.method,
				async : this.async,
				params : this.params,
				exec : function()
				{
					self.standardExec();
				},
				headers : null,
				useCache : false,
				json : false,
				jsonSecure : false
			}
			
			if (properties && typeof properties == 'object')
			{
				for (var prop in properties)
				{
					if (typeof properties[prop] == 'function' && prop == 'exec')
					{
						props['exec'] = function()
						{
							self.standardExec();
							properties.exec();
						}
					}
					else
					{
						props[prop] = properties[prop];
					}
				}
			}
			
			this.standardExec = function()
			{
				self.responseText = self.req.responseText;
				self.responseXML = self.req.responseXML;
				
				if (props.json)
					self.responseJSON = Ease.JSON.strToJSONObj(self.responseText);
				else if (props.jsonSecure)
					self.responseJSON = Ease.JSON.parseJSON(self.responseText);
			};
			
			Ease.Ajax.handleRequest(this.url,this.req,props);
		}
	},
	
	// AjaxTest.handleJSON({ exec:function(){alert(AjaxTest.responseJSON)} });
	handleJSON : function(properties)
	{
		if (this.req != null)
		{
			var self = this;
			var exec = properties.exec || function() { };
			
			properties = properties || {};
			properties.json = true;
			properties.exec = function()
			{
				self.responseJSON.handleJSON();
				exec();
			}
			
			this.handle(properties);
		}
	},
	
	// AjaxTest.handleXML({ xslUrl:'test.xsl', xslParams:'abc=true&xyz=true', xslApplyTo:'ShowTest', exec:function(){alert(AjaxTest.xslOutput)} headers:['Content-Type','application/x-www-form-urlencoded'] });
	handleXML : function(xslUrl,properties)
	{
		if (this.req != null)
		{
			this.headers = null;
			this.useCache = false;
			this.xslUrl = xslUrl;
			this.xslParams = null;
			this.xslMethod = 'GET';
			this.xslAsync = true;
			this.xslHeaders = null;
			this.xslUseCache = false
			this.applyMethod = 'MS';
			this.applyBefore = null;
			this.target = null;
			this.clearTarget = null;
			this.removeFromTarget = null;
			this.exec = null;
			
			this.responseXSL = null;
			this.xslOutput = null;
			this.xslReq = null;
			
			if (properties && typeof properties == 'object')
			{
				for (var prop in properties)
					this[prop] = properties[prop];
			}
			
			var self = this;
			this.handle(
			{
				useCache : this.useCache,
				headers : this.headers,
				exec : function()
				{
					self.xslReq = new Ease.Ajax.Request(self.xslUrl,{ params:self.xslParams, method:self.xslMethod, async:self.xslAsync });
					self.xslReq.handle(
					{
						useCache : self.xslUseCache,
						headers : self.xslHeaders,
						exec : function()
						{
							var retObj = self.applyMethod == 'W3C' ? true : false;
							
							self.responseXSL = self.xslReq.responseXML;
							self.xslOutput = Ease.DOM.xslTransform(self.responseXML, self.responseXSL, retObj);
							
							if (self.target)
							{
								if (self.applyMethod == 'W3C')
								{
									if (self.clearTarget)
										Ease.DOM.removeAllChildNodes(self.clearTarget);
									else if (self.removeFromTarget)
										Ease.DOM.removeChildNode(self.removeFromTarget);
									
									if (self.applyBefore && !self.clearTarget)
									{
										self.applyBefore = Ease.DOM.getElems(self.applyBefore);
										
										if (self.xslOutput.length)
										{
											for (var i = 0; i < self.xslOutput.length; i++)
												Ease.DOM.getElems(self.target).insertBefore(self.xslOutput[i], self.applyBefore);
										}
										else
										{
											Ease.DOM.getElems(self.target).insertBefore(self.xslOutput, self.applyBefore);
										}
									}
									else
									{
										if (self.xslOutput.length)
										{
											for (var i = 0; i < self.xslOutput.length; i++)
												Ease.DOM.getElems(self.target).appendChild(self.xslOutput[i]);
										}
										else
										{
											Ease.DOM.getElems(self.target).appendChild(self.xslOutput);
										}
									}
									
								}
								else
								{
									Ease.DOM.getElems(self.target).innerHTML = self.xslOutput;
								}
							}
							
							if (self.exec)
								self.exec();
						}
					});
				}
			});
		}
	}
};

/*
 *
 * Object Ease.JSON
 *
 */
Ease.JSON =
{
	objToJSONString : function(obj)
	{
		return obj.toJSONString();
	},
	
	arrToJSONString : function(arr)
	{
		return arr.toJSONString();
	},
	
	parseJSON : function(str)
	{
		return str.parseJSON();
	},
	
	strToJSONObj : function(str)
	{
		return eval('(' + str + ')');
	}
};

/*
 *
 * Object Ease.Events
 *
 */
Ease.Events =
{
	add : function(obj,handler,func,capture)
	{
		if (Ease.UA.hasDOM)
		{
			obj = Ease.DOM.getElems(obj);

			if (obj.addEventListener)
				obj.addEventListener(handler,func,capture);
			else if (obj.attachEvent)
				obj.attachEvent('on' + handler,func);
			else
				obj['on' + handler] = func;
		}
	},
	
	remove : function(obj,handler,func,capture)
	{
		if (Ease.UA.hasDOM)
		{
			obj = Ease.DOM.getElems(obj);
			
			if (obj.removeEventListener)
				obj.removeEventListener(handler,func,capture);
			else if (obj.detachEvent)
				obj.detachEvent('on' + handler,func);
			else
				obj['on' + handler] = null;
		}
	},
	
	preventDefault : function(e)
	{
		var e = e ? e : window.event;
		
		if (e.preventDefault)
			e.preventDefault();
		else if (Ease.UA.isIE)
			e.returnValue = false;
		else
			return false;
	},

	stopPropagation : function(e)
	{
		var e = e ? e : window.event;
		
		if (e.stopPropagation)
			e.stopPropagation();
		else if (Ease.UA.isIE)
			e.cancelBubble = true;
	},
	
	findMouse : function(e)
	{
		if (Ease.UA.hasDOM)
		{
			var xOffset, yOffset;
			var e = e ? e : window.event;
			
			if (Ease.UA.isIE)
			{
				if (document.documentElement && (document.documentElement.scrollLeft || document.documentElement.scrollTop))
				{
					xOffset = document.documentElement.scrollLeft;
					yOffset = document.documentElement.scrollTop;
				}
				else if (document.body)
				{
					xOffset = document.body.scrollLeft;
					yOffset = document.body.scrollTop;
				}
			}
			else
			{
				xOffset = window.pageXOffset;
				yOffset = window.pageYOffset;
			}
			
			var position =
			{
				x : e.clientX,
				y : e.clientY,
				xOffset : e.clientX + xOffset,
				yOffset : e.clientY + yOffset
			}
			
			return position;
		}
	}
};

/*
 *
 * Object Ease.CSS
 *
 */
Ease.CSS =
{
	setDisplay : function()
	{
		if (Ease.UA.hasDOM)
		{
			var args = arguments;
			
			for (var i = 0; i < args.length-1; i+=2)
				Ease.DOM.getElems(args[i]).style.display = args[i+1];
		}
	},
	
	setVisibility : function()
	{
		if (Ease.UA.hasDOM)
		{
			var args = arguments;
			
			for (var i = 0; i < args.length-1; i+=2)
				Ease.DOM.getElems(args[i]).style.visibility = args[i+1];
		}
	},
	
	setPosition : function()
	{
		if (Ease.UA.hasDOM)
		{
			var args = arguments, objStyle;
			
			for (var i = 0; i < args.length-2; i+=3)
			{
				objStyle = Ease.DOM.getElems(args[i]).style;
				objStyle.left = args[i+1] + 'px';
				objStyle.top = args[i+2] + 'px';
			}
		}
	},
	
	setClip : function()
	{
		if (Ease.UA.hasDOM)
		{
			var args = arguments;
			
			for (var i = 0; i<args.length-4; i+=5)
				Ease.DOM.getElems(args[i]).style.clip = 'rect('+ args[i+1] +'px, ' + args[i+2] + 'px, ' + args[i+3] + 'px, ' + args[i+4] + 'px)';
		}
	},
	
	setOpacity : function(obj,opac)
	{
		if (Ease.UA.hasDOM)
		{
			obj = Ease.DOM.getElems(obj);
			
			if (obj.filters)
			{
				obj.style.filter = 'alpha(opacity=' + opac * 100 +')';
			}
			else
			{
				obj.style.opacity = opac;
				obj.style.setProperty('-moz-opacity',opac,'');
				obj.style.setProperty('-khtml-opacity',opac,'');
			}
		}
	},
	
	addClass : function(obj,className)
	{
		if (Ease.UA.hasDOM)
		{
			obj = Ease.DOM.getElems(obj);
			
			if (obj.className && !obj.className.match(new RegExp('\\b' + className + '\\b')))
				obj.className += obj.className + ' ' + className;
			else if (!obj.className)
				obj.className = className;
		}
	},
	
	setClass : function(obj,className)
	{
		if (Ease.UA.hasDOM)
		{
			obj = Ease.DOM.getElems(obj);
			
			obj.className = className;
		}
	},
	
	removeClass : function(obj,className)
	{
		if (Ease.UA.hasDOM)
		{
			obj = Ease.DOM.getElems(obj);
			
			if (obj.className.match(new RegExp('\\b' + className + '\\b')))
				obj.className.replace(new RegExp('\\' + className + '\\'),'');
		}
	}
};

/*
 *
 * Object Ease.Dyn
 *
 */
Ease.Dyn = Ease.Dyn || {};

/*
 *
 * Class Ease.Dyn.Drag
 *
 */
Ease.Dyn.dragZ = 10000;
Ease.Dyn.Drag = function(dragElem,elem,properties)
{
	this.init = false;
	
	if (Ease.UA.hasDOM)
	{
		this.dragElem = Ease.DOM.getElems(dragElem);
		this.dragElem.style.cursor = 'move';
		this.elem = Ease.DOM.getElems(elem);
		this.position = Ease.DOM.getPosition(this.elem)
		this.startX = this.position.x;
		this.startY = this.position.y;
		this.startZ = null;
		this.doOnStart = null;
		this.doOnDrag = null;
		this.doOnStop = null;
		
		if (properties && typeof properties == 'object')
		{
			for (var prop in properties)
				this[prop] = properties[prop];
		}
		
		var self = this;
		Ease.Events.add(this.dragElem,'mousedown',self.startDragFunc = function(e) { self.startDrag(e); },false);
		
		this.init = true;
	}
};

Ease.Dyn.Drag.prototype =
{
	startDrag : function(e)
	{
		if (this.init)
		{
			this.elemPosX = parseInt(this.elem.style.left) || this.startX;
			this.elemPosY = parseInt(this.elem.style.top) || this.startY;
			
			this.mousePos = Ease.Events.findMouse(e);
			this.dragPosX = this.mousePos.xOffset - this.elemPosX;
			this.dragPosY = this.mousePos.yOffset - this.elemPosY;
			
			this.stopZ = this.startZ || Ease.Dyn.dragZ;
			this.elem.style.zIndex = Ease.Dyn.dragZ;
			
			var self = this;
			Ease.Events.add(document,'mousemove',self.dragFunc = function(e) { self.drag(e); },false);
			Ease.Events.add(document,'mouseup',self.stopDragFunc = function(e) { self.stopDrag(e); },false);
			
			if (this.doOnStart)
				this.doOnStart();
			
			Ease.Events.stopPropagation(e);
			Ease.Events.preventDefault(e);
		}
	},
	
	drag : function(e)
	{
		this.mousePos = Ease.Events.findMouse(e);
		this.elemPosX = this.mousePos.xOffset - this.dragPosX;
		this.elemPosY = this.mousePos.yOffset - this.dragPosY;
		this.elemPosX = (this.elemPosX > 0) ? this.elemPosX : 0;
		this.elemPosY = (this.elemPosY > 0) ? this.elemPosY : 0;
		
		Ease.CSS.setPosition(this.elem,this.elemPosX,this.elemPosY);
		
		if (this.doOnDrag)
			this.doOnDrag();
		
		Ease.Events.stopPropagation(e);
		Ease.Events.preventDefault(e);
	},
	
	stopDrag : function(e)
	{
		var self = this;
		Ease.Events.remove(document,'mousemove',self.dragFunc,false);
		Ease.Events.remove(document,'mouseup',self.stopDragFunc,false);
		
		this.elem.style.zIndex = this.stopZ;
		Ease.Dyn.dragZ++;
		
		if (this.doOnStop)
			this.doOnStop();
		
		Ease.Events.stopPropagation(e);
		Ease.Events.preventDefault(e);
	}
};

/*
 *
 * Object Ease.Dyn.Tooltip
 *
 */
Ease.Dyn.Tooltip = Ease.Dyn.Tooltip || {};
Ease.Dyn.Tooltip.init = function(autoCreate,distanceX,distanceY)
{
	if (Ease.UA.hasDOM)
	{
		Ease.Dyn.Tooltip.tipElem = document.createElement('div');
		Ease.Dyn.Tooltip.tipElem.setAttribute('id','Tooltip');
		
		var tipBody = Ease.DOM.getElems({ method:'tagname', find:'body' })[0];
		tipBody.appendChild(Ease.Dyn.Tooltip.tipElem);
		
		Ease.Dyn.Tooltip.init = true;
		
		if (autoCreate == true)
		{
			var tipArr = [];
			var tipCount = 0;
			var findElems = !Ease.UA.isIE || Ease.UA.isIEVersion > 5.5 ? '*' : 'a';
			var allElems = Ease.DOM.getElemsBy({ method:'tagname', find:findElems });
			
			distanceX = typeof distanceX == 'number' ? distanceX : 20;
			distanceY = typeof distanceY == 'number' ? distanceY : 0;
			
			for (var i = 0; i < allElems.length; i++)
			{
				if (allElems[i].title != '')
				{
					tipArr[tipCount] = new Ease.Dyn.Tooltip.Tip(allElems[i],allElems[i].title,distanceX,distanceY);
					tipCount++
				}
			}
		}
	}
};

/*
 *
 * Class Ease.Dyn.Tooltip.Tip
 *
 */
Ease.Dyn.Tooltip.Tip = function(elem,content,distanceX,distanceY)
{
	if (Ease.Dyn.Tooltip.init)
	{
		this.elem = Ease.DOM.getElems(elem);
		
		if (!this.elem)
			return false;
		
		if (!this.elem.title != '')
			this.elem.title = '';
		
		this.content = content;
		this.distanceX = distanceX;
		this.distanceY = distanceY;
		this.show = false;
		
		var self = this;
		Ease.Events.add(this.elem,'mouseover',function(e) { self.showTip(e); },false);
		Ease.Events.add(this.elem,'mousemove',function(e) { self.positionTip(e); },false);
		Ease.Events.add(this.elem,'mouseout',function() { self.hideTip(); },false);
	}
};

Ease.Dyn.Tooltip.Tip.prototype =
{
	showHide : function()
	{
		if (this.show)
		{
			Ease.CSS.setDisplay(Ease.Dyn.Tooltip.tipElem,'inline');
			Ease.CSS.setVisibility(Ease.Dyn.Tooltip.tipElem,'visible');
		}
		else
		{
			Ease.CSS.setDisplay(Ease.Dyn.Tooltip.tipElem,'none');
			Ease.CSS.setVisibility(Ease.Dyn.Tooltip.tipElem,'hidden');
		}
	},
	
	positionTip : function(e)
	{
		this.mousePos = Ease.Events.findMouse(e);
		this.posX = this.mousePos.xOffset + this.distanceX;
		this.posY = this.mousePos.yOffset + this.distanceY;
		
		Ease.CSS.setPosition(Ease.Dyn.Tooltip.tipElem,this.posX,this.posY);
		
		Ease.Events.stopPropagation(e);
		Ease.Events.preventDefault(e);
	},
	
	showTip : function(e)
	{
		Ease.Dyn.Tooltip.tipElem.innerHTML = this.content;
		this.show = true;
		this.showHide();
		
		Ease.Events.stopPropagation(e);
		Ease.Events.preventDefault(e);
	},
	
	hideTip : function()
	{
		this.show = false;
		this.showHide();
		Ease.Dyn.Tooltip.tipElem.innerHTML = '';
	}
};

/*
 *
 * Class Ease.Dyn.Slideout
 *
 */
Ease.Dyn.Slideout = function(slideElem,slideElemHeight,slideElemWidth,slideStepDivider,slideStepMin,slideTimeout,keepPlace)
{
	if (Ease.UA.hasDOM)
	{
		this.slideElem = slideElem;
		this.slideElemHeight = slideElemHeight;
		this.slideElemWidth = slideElemWidth;
		this.slideStepDivider = slideStepDivider;
		this.slideStepMin = slideStepMin;
		this.slideTimeout = slideTimeout;
		this.keepPlace = keepPlace;
		this.slideXStandard = true;
		this.slideYStandard = true;
		this.initDone = false;
	}
}

Ease.Dyn.Slideout.prototype =
{
	init : function()
	{
		if (Ease.UA.hasDOM)
		{
			this.slideElem = Ease.DOM.getElems(this.slideElem);
			this.contentElem = Ease.DOM.findFirstElementNode(this.slideElem);
			this.slideElemHeight = this.slideElem.offsetHeight;
			this.contentElemHeight = this.contentElem.offsetHeight;
			this.slideElemWidth = this.slideElem.offsetWidth;
			this.contentElemWidth = this.contentElem.offsetWidth;
			this.slidedOut = false;
			this.sliding = false;
			this.slidedOutY = false;
			this.slidingY = false;
			this.initDone = true;
		}
	},

	action : function(properties)
	{
		if (this.initDone && !this.sliding && !this.slidingY)
		{
			this.slideX = this.slideXStandard;
			this.slideY = this.slideYStandard;
			
			if (properties)
			{
				for (prop in properties)
					this[prop] = properties[prop];
			}
			
			if (this.slideX)
				this.slideHeight();
			
			if (this.slideY)
				this.slideWidth();

			if (arguments.length > 0)
				this.nextFunc = arguments[0];
			else
				this.nextFunc = null;
		}
	},

	slideHeight : function()
	{
		if (!this.sliding)
		{
			if (!this.slidedOut) 
			{
				this.slideElem.style.display = 'block';
				this.slideElem.style.visibility = 'visible';
			}
				
			this.slideElem.style.overflow = 'hidden';
			this.slideElemHeight = !this.slidedOut ? 0 : this.contentElem.offsetHeight; 
			this.contentElemHeight = !this.slidedOut ? this.contentElem.offsetHeight : this.slideElemHeight;
			this.slideSteps = Math.round(this.contentElemHeight / this.slideStepDivider);
			this.sliding = true;
		}
		
		this.slideElemHeight += !this.slidedOut ? this.slideSteps : -this.slideSteps;
		this.slideSteps -= (this.slideSteps > this.slideStepMin) ? Math.round(this.slideSteps / this.slideStepDivider) : 0;
		this.slideElem.style.height = this.slideElemHeight + 'px';
		
		if ( (!this.slidedOut 
				&& (this.slideElemHeight < this.contentElemHeight - this.slideSteps)) 
					|| (this.slidedOut
						&& (this.slideElemHeight >= this.slideSteps)) )
		{
			var self = this;
			window.setTimeout(function(){self.slideHeight();},this.slideTimeout);
		}
		else
		{
			this.slideElem.style.height = !this.slidedOut ? 'auto' : '1px';
			
			if (this.slidedOut) 
			{
				this.slideElem.style.visibility = 'hidden';
				
				if (!this.keepPlace)
					this.slideElem.style.display = 'none';
			}
			
			this.slidedOut = this.slidedOut ? false : true;
			this.sliding = false;
		}
	},

	slideWidth : function()
	{
		if (!this.slidingY)
		{
			if (!this.slidedOutY) 
			{
				this.slideElem.style.display = 'block';
				this.slideElem.style.visibility = 'visible';
			}
				
			this.slideElem.style.overflow = 'hidden';
			this.slideElemWidth = !this.slidedOutY ? 0 : this.contentElem.offsetWidth; 
			this.contentElemWidth = !this.slidedOut ? this.contentElem.offsetWidth : this.slideElemWidth;
			this.slideStepsY = Math.round(this.contentElemWidth / this.slideStepDivider);
			this.slidingY = true;
		}
		
		this.slideElemWidth += !this.slidedOutY ? this.slideStepsY : -this.slideStepsY;
		this.slideStepsY -= (this.slideStepsY > this.slideStepMin) ? Math.round(this.slideStepsY / this.slideStepDivider) : 0;
		this.slideElem.style.width = this.slideElemWidth + 'px';
		
		if ( (!this.slidedOutY 
				&& (this.slideElemWidth < this.contentElemWidth - this.slideStepsY)) 
					|| (this.slidedOutY
						&& (this.slideElemWidth >= this.slideStepsY)) )
		{
			var self = this;
			window.setTimeout(function(){self.slideWidth();},this.slideTimeout);
		}
		else
		{
			this.slideElem.style.width = !this.slidedOutY ? 'auto' : '1px';
			
			if (this.slidedOutY)
			{
				this.slideElem.style.visibility = 'hidden';
				
				if (!this.keepPlace)
					this.slideElem.style.display = 'none';
			}
			
			this.slidedOutY = this.slidedOutY ? false : true;
			this.slidingY = false;
		}
	}
};

Array.prototype.contains = function(searchStr)
{
	for(var result=[], i = 0; i < this.length; i++)
	{
		if(this[i] == searchStr)
			result[result.length] = i;
	}
	
	return result.length ? result : -1;
};