// 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'
];
includeFiles = [];
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;
};