/*
 * Ext JS Library 2.1
 * Copyright(c) 2006-2008, Ext JS, LLC.
 * licensing@extjs.com
 * 
 * http://extjs.com/license
 */


Ext.DomHelper = function() {
    var tempTableEl = null;
    var emptyTags = /^(?:br|frame|hr|img|input|link|meta|range|spacer|wbr|area|param|col)$/i;
    var tableRe = /^table|tbody|tr|td$/i;

    var createHtml = function(o) {
        if (typeof o == 'string') {
            return o;

        }
        var b = "";
        if (Ext.isArray(o)) {
            for (var i = 0, l = o.length; i < l; i++) {
                b += createHtml(o[i]);
            }
            return b;
        }
        if (!o.tag) {
            o.tag = "div";

        }
        b += "<" + o.tag;
        for (var attr in o) {
            if (attr == "tag" || attr == "children" || attr == "cn" || attr == "html" || typeof o[attr] == "function") continue;
            if (attr == "style") {
                var s = o["style"];
                if (typeof s == "function") {
                    s = s.call();

                }
                if (typeof s == "string") {
                    b += ' style="' + s + '"';

                } else if (typeof s == "object") {
                    b += ' style="';
                    for (var key in s) {
                        if (typeof s[key] != "function") {
                            b += key + ":" + s[key] + ";";

                        }

                    }
                    b += '"';

                }

            } else {
                if (attr == "cls") {
                    b += ' class="' + o["cls"] + '"';

                } else if (attr == "htmlFor") {
                    b += ' for="' + o["htmlFor"] + '"';

                } else {
                    b += " " + attr + '="' + o[attr] + '"';

                }

            }

        }
        if (emptyTags.test(o.tag)) {
            b += "/>";

        } else {
            b += ">";
            var cn = o.children || o.cn;
            if (cn) {
                b += createHtml(cn);

            } else if (o.html) {
                b += o.html;

            }
            b += "</" + o.tag + ">";

        }
        return b;

    };


    var createDom = function(o, parentNode) {
        var el;
        if (Ext.isArray(o)) {
            el = document.createDocumentFragment();
            for (var i = 0, l = o.length; i < l; i++) {
                createDom(o[i], el);

            }

        } else if (typeof o == "string") {
            el = document.createTextNode(o);

        } else {
            el = document.createElement(o.tag || 'div');
            var useSet = !!el.setAttribute;
            for (var attr in o) {
                if (attr == "tag" || attr == "children" || attr == "cn" || attr == "html" || attr == "style" || typeof o[attr] == "function") continue;
                if (attr == "cls") {
                    el.className = o["cls"];

                } else {
                    if (useSet) el.setAttribute(attr, o[attr]);
                    else el[attr] = o[attr];

                }

            }
            Ext.DomHelper.applyStyles(el, o.style);
            var cn = o.children || o.cn;
            if (cn) {
                createDom(cn, el);

            } else if (o.html) {
                el.innerHTML = o.html;

            }

        }
        if (parentNode) {
            parentNode.appendChild(el);

        }
        return el;

    };

    var ieTable = function(depth, s, h, e) {
        tempTableEl.innerHTML = [s, h, e].join('');
        var i = -1,
        el = tempTableEl;
        while (++i < depth) {
            el = el.firstChild;

        }
        return el;

    };

    var ts = '<table>',
    te = '</table>',
    tbs = ts + '<tbody>',
    tbe = '</tbody>' + te,
    trs = tbs + '<tr>',
    tre = '</tr>' + tbe;


    var insertIntoTable = function(tag, where, el, html) {
        if (!tempTableEl) {
            tempTableEl = document.createElement('div');

        }
        var node;
        var before = null;
        if (tag == 'td') {
            if (where == 'afterbegin' || where == 'beforeend') {
                return;

            }
            if (where == 'beforebegin') {
                before = el;
                el = el.parentNode;

            } else {
                before = el.nextSibling;
                el = el.parentNode;

            }
            node = ieTable(4, trs, html, tre);

        }
        else if (tag == 'tr') {
            if (where == 'beforebegin') {
                before = el;
                el = el.parentNode;
                node = ieTable(3, tbs, html, tbe);

            } else if (where == 'afterend') {
                before = el.nextSibling;
                el = el.parentNode;
                node = ieTable(3, tbs, html, tbe);

            } else {
                if (where == 'afterbegin') {
                    before = el.firstChild;

                }
                node = ieTable(4, trs, html, tre);

            }

        } else if (tag == 'tbody') {
            if (where == 'beforebegin') {
                before = el;
                el = el.parentNode;
                node = ieTable(2, ts, html, te);

            } else if (where == 'afterend') {
                before = el.nextSibling;
                el = el.parentNode;
                node = ieTable(2, ts, html, te);

            } else {
                if (where == 'afterbegin') {
                    before = el.firstChild;

                }
                node = ieTable(3, tbs, html, tbe);

            }

        } else {
            if (where == 'beforebegin' || where == 'afterend') {
                return;

            }
            if (where == 'afterbegin') {
                before = el.firstChild;

            }
            node = ieTable(2, ts, html, te);

        }
        el.insertBefore(node, before);
        return node;

    };


    return {

        useDom: false,
        markup: function(o) {
            return createHtml(o);

        },
        applyStyles: function(el, styles) {
            if (styles) {
                el = Ext.fly(el);
                if (typeof styles == "string") {
                    var re = /\s?([a-z\-]*)\:\s?([^;]*);?/gi;
                    var matches;
                    while ((matches = re.exec(styles)) != null) {
                        el.setStyle(matches[1], matches[2]);

                    }

                } else if (typeof styles == "object") {
                    for (var style in styles) {
                        el.setStyle(style, styles[style]);

                    }

                } else if (typeof styles == "function") {
                    Ext.DomHelper.applyStyles(el, styles.call());

                }

            }

        },
        insertHtml: function(where, el, html) {
            where = where.toLowerCase();
            if (el.insertAdjacentHTML) {
                if (tableRe.test(el.tagName)) {
                    var rs;
                    if (rs = insertIntoTable(el.tagName.toLowerCase(), where, el, html)) {
                        return rs;

                    }

                }
                switch (where) {
                    case "beforebegin":
                    el.insertAdjacentHTML('BeforeBegin', html);
                    return el.previousSibling;
                    case "afterbegin":
                    el.insertAdjacentHTML('AfterBegin', html);
                    return el.firstChild;
                    case "beforeend":
                    el.insertAdjacentHTML('BeforeEnd', html);
                    return el.lastChild;
                    case "afterend":
                    el.insertAdjacentHTML('AfterEnd', html);
                    return el.nextSibling;

                }
                throw 'Illegal insertion point -> "' + where + '"';

            }
            var range = el.ownerDocument.createRange();
            var frag;
            switch (where) {
                case "beforebegin":
                range.setStartBefore(el);
                frag = range.createContextualFragment(html);
                el.parentNode.insertBefore(frag, el);
                return el.previousSibling;
                case "afterbegin":
                if (el.firstChild) {
                    range.setStartBefore(el.firstChild);
                    frag = range.createContextualFragment(html);
                    el.insertBefore(frag, el.firstChild);
                    return el.firstChild;

                } else {
                    el.innerHTML = html;
                    return el.firstChild;

                }
                case "beforeend":
                if (el.lastChild) {
                    range.setStartAfter(el.lastChild);
                    frag = range.createContextualFragment(html);
                    el.appendChild(frag);
                    return el.lastChild;

                } else {
                    el.innerHTML = html;
                    return el.lastChild;

                }
                case "afterend":
                range.setStartAfter(el);
                frag = range.createContextualFragment(html);
                el.parentNode.insertBefore(frag, el.nextSibling);
                return el.nextSibling;

            }
            throw 'Illegal insertion point -> "' + where + '"';

        },
        insertBefore: function(el, o, returnElement) {
            return this.doInsert(el, o, returnElement, "beforeBegin");

        },
        insertAfter: function(el, o, returnElement) {
            return this.doInsert(el, o, returnElement, "afterEnd", "nextSibling");

        },
        insertFirst: function(el, o, returnElement) {
            return this.doInsert(el, o, returnElement, "afterBegin", "firstChild");

        },
        doInsert: function(el, o, returnElement, pos, sibling) {
            el = Ext.getDom(el);
            var newNode;
            if (this.useDom) {
                newNode = createDom(o, null);
                (sibling === "firstChild" ? el: el.parentNode).insertBefore(newNode, sibling ? el[sibling] : el);

            } else {
                var html = createHtml(o);
                newNode = this.insertHtml(pos, el, html);

            }
            return returnElement ? Ext.get(newNode, true) : newNode;

        },
        append: function(el, o, returnElement) {
            el = Ext.getDom(el);
            var newNode;
            if (this.useDom) {
                newNode = createDom(o, null);
                el.appendChild(newNode);

            } else {
                var html = createHtml(o);
                newNode = this.insertHtml("beforeEnd", el, html);

            }
            return returnElement ? Ext.get(newNode, true) : newNode;

        },
        overwrite: function(el, o, returnElement) {
            el = Ext.getDom(el);
            el.innerHTML = createHtml(o);
            return returnElement ? Ext.get(el.firstChild, true) : el.firstChild;

        },
        createTemplate: function(o) {
            var html = createHtml(o);
            return new Ext.Template(html);

        }

    };

} ();


Ext.Template = function(html) {
    var a = arguments;
    if (Ext.isArray(html)) {
        html = html.join("");

    } else if (a.length > 1) {
        var buf = [];
        for (var i = 0, len = a.length; i < len; i++) {
            if (typeof a[i] == 'object') {
                Ext.apply(this, a[i]);

            } else {
                buf[buf.length] = a[i];

            }

        }
        html = buf.join('');

    }

    this.html = html;
    if (this.compiled) {
        this.compile();

    }

};
Ext.Template.prototype = {

    applyTemplate: function(values) {
        if (this.compiled) {
            return this.compiled(values);

        }
        var useF = this.disableFormats !== true;
        var fm = Ext.util.Format,
        tpl = this;
        var fn = function(m, name, format, args) {
            if (format && useF) {
                if (format.substr(0, 5) == "this.") {
                    return tpl.call(format.substr(5), values[name], values);

                } else {
                    if (args) {
                        var re = /^\s*['"](.*)["']\s*$/;
                        args = args.split(',');
                        for (var i = 0, len = args.length; i < len; i++) {
                            args[i] = args[i].replace(re, "$1");

                        }
                        args = [values[name]].concat(args);

                    } else {
                        args = [values[name]];

                    }
                    return fm[format].apply(fm, args);

                }

            } else {
                return values[name] !== undefined ? values[name] : "";

            }

        };
        return this.html.replace(this.re, fn);

    },
    set: function(html, compile) {
        this.html = html;
        this.compiled = null;
        if (compile) {
            this.compile();

        }
        return this;

    },
    disableFormats: false,
    re: /\{([\w-]+)(?:\:([\w\.]*)(?:\((.*?)?\))?)?\}/g,
    compile: function() {
        var fm = Ext.util.Format;
        var useF = this.disableFormats !== true;
        var sep = Ext.isGecko ? "+": ",";
        var fn = function(m, name, format, args) {
            if (format && useF) {
                args = args ? ',' + args: "";
                if (format.substr(0, 5) != "this.") {
                    format = "fm." + format + '(';

                } else {
                    format = 'this.call("' + format.substr(5) + '", ';
                    args = ", values";

                }

            } else {
                args = '';
                format = "(values['" + name + "'] == undefined ? '' : ";

            }
            return "'" + sep + format + "values['" + name + "']" + args + ")" + sep + "'";

        };
        var body;
        if (Ext.isGecko) {
            body = "this.compiled = function(values){ return '" + 
            this.html.replace(/\\/g, '\\\\').replace(/(\r\n|\n)/g, '\\n').replace(/'/g, "\\'").replace(this.re, fn) + 
            "';};";

        } else {
            body = ["this.compiled = function(values){ return ['"];
            body.push(this.html.replace(/\\/g, '\\\\').replace(/(\r\n|\n)/g, '\\n').replace(/'/g, "\\'").replace(this.re, fn));
            body.push("'].join('');};");
            body = body.join('');

        }
        eval(body);
        return this;

    },
    call: function(fnName, value, allValues) {
        return this[fnName](value, allValues);

    },
    insertFirst: function(el, values, returnElement) {
        return this.doInsert('afterBegin', el, values, returnElement);

    },
    insertBefore: function(el, values, returnElement) {
        return this.doInsert('beforeBegin', el, values, returnElement);

    },
    insertAfter: function(el, values, returnElement) {
        return this.doInsert('afterEnd', el, values, returnElement);

    },
    append: function(el, values, returnElement) {
        return this.doInsert('beforeEnd', el, values, returnElement);

    },
    doInsert: function(where, el, values, returnEl) {
        el = Ext.getDom(el);
        var newNode = Ext.DomHelper.insertHtml(where, el, this.applyTemplate(values));
        return returnEl ? Ext.get(newNode, true) : newNode;

    },
    overwrite: function(el, values, returnElement) {
        el = Ext.getDom(el);
        el.innerHTML = this.applyTemplate(values);
        return returnElement ? Ext.get(el.firstChild, true) : el.firstChild;

    }

};

Ext.Template.prototype.apply = Ext.Template.prototype.applyTemplate;

Ext.DomHelper.Template = Ext.Template;


Ext.Template.from = function(el, config) {
    el = Ext.getDom(el);
    return new Ext.Template(el.value || el.innerHTML, config || '');

};


Ext.DomQuery = function() {
    var cache = {},
    simpleCache = {},
    valueCache = {};
    var nonSpace = /\S/;
    var trimRe = /^\s+|\s+$/g;
    var tplRe = /\{(\d+)\}/g;
    var modeRe = /^(\s?[\/>+~]\s?|\s|$)/;
    var tagTokenRe = /^(#)?([\w-\*]+)/;
    var nthRe = /(\d*)n\+?(\d*)/,
    nthRe2 = /\D/;

    function child(p, index) {
        var i = 0;
        var n = p.firstChild;
        while (n) {
            if (n.nodeType == 1) {
                if (++i == index) {
                    return n;

                }

            }
            n = n.nextSibling;

        }
        return null;

    };

    function next(n) {
        while ((n = n.nextSibling) && n.nodeType != 1);
        return n;

    };

    function prev(n) {
        while ((n = n.previousSibling) && n.nodeType != 1);
        return n;

    };

    function children(d) {
        var n = d.firstChild,
        ni = -1;
        while (n) {
            var nx = n.nextSibling;
            if (n.nodeType == 3 && !nonSpace.test(n.nodeValue)) {
                d.removeChild(n);

            } else {
                n.nodeIndex = ++ni;

            }
            n = nx;

        }
        return this;

    };

    function byClassName(c, a, v) {
        if (!v) {
            return c;

        }
        var r = [],
        ri = -1,
        cn;
        for (var i = 0, ci; ci = c[i]; i++) {
            if ((' ' + ci.className + ' ').indexOf(v) != -1) {
                r[++ri] = ci;

            }

        }
        return r;

    };

    function attrValue(n, attr) {
        if (!n.tagName && typeof n.length != "undefined") {
            n = n[0];

        }
        if (!n) {
            return null;

        }
        if (attr == "for") {
            return n.htmlFor;

        }
        if (attr == "class" || attr == "className") {
            return n.className;

        }
        return n.getAttribute(attr) || n[attr];


    };

    function getNodes(ns, mode, tagName) {
        var result = [],
        ri = -1,
        cs;
        if (!ns) {
            return result;

        }
        tagName = tagName || "*";
        if (typeof ns.getElementsByTagName != "undefined") {
            ns = [ns];

        }
        if (!mode) {
            for (var i = 0, ni; ni = ns[i]; i++) {
                cs = ni.getElementsByTagName(tagName);
                for (var j = 0, ci; ci = cs[j]; j++) {
                    result[++ri] = ci;

                }

            }

        } else if (mode == "/" || mode == ">") {
            var utag = tagName.toUpperCase();
            for (var i = 0, ni, cn; ni = ns[i]; i++) {
                cn = ni.children || ni.childNodes;
                for (var j = 0, cj; cj = cn[j]; j++) {
                    if (cj.nodeName == utag || cj.nodeName == tagName || tagName == '*') {
                        result[++ri] = cj;

                    }

                }

            }

        } else if (mode == "+") {
            var utag = tagName.toUpperCase();
            for (var i = 0, n; n = ns[i]; i++) {
                while ((n = n.nextSibling) && n.nodeType != 1);
                if (n && (n.nodeName == utag || n.nodeName == tagName || tagName == '*')) {
                    result[++ri] = n;

                }

            }

        } else if (mode == "~") {
            for (var i = 0, n; n = ns[i]; i++) {
                while ((n = n.nextSibling) && (n.nodeType != 1 || (tagName == '*' || n.tagName.toLowerCase() != tagName)));
                if (n) {
                    result[++ri] = n;

                }

            }

        }
        return result;

    };

    function concat(a, b) {
        if (b.slice) {
            return a.concat(b);

        }
        for (var i = 0, l = b.length; i < l; i++) {
            a[a.length] = b[i];

        }
        return a;

    }

    function byTag(cs, tagName) {
        if (cs.tagName || cs == document) {
            cs = [cs];

        }
        if (!tagName) {
            return cs;

        }
        var r = [],
        ri = -1;
        tagName = tagName.toLowerCase();
        for (var i = 0, ci; ci = cs[i]; i++) {
            if (ci.nodeType == 1 && ci.tagName.toLowerCase() == tagName) {
                r[++ri] = ci;

            }

        }
        return r;

    };

    function byId(cs, attr, id) {
        if (cs.tagName || cs == document) {
            cs = [cs];

        }
        if (!id) {
            return cs;

        }
        var r = [],
        ri = -1;
        for (var i = 0, ci; ci = cs[i]; i++) {
            if (ci && ci.id == id) {
                r[++ri] = ci;
                return r;

            }

        }
        return r;

    };

    function byAttribute(cs, attr, value, op, custom) {
        var r = [],
        ri = -1,
        st = custom == "{";
        var f = Ext.DomQuery.operators[op];
        for (var i = 0, ci; ci = cs[i]; i++) {
            var a;
            if (st) {
                a = Ext.DomQuery.getStyle(ci, attr);

            }
            else if (attr == "class" || attr == "className") {
                a = ci.className;

            } else if (attr == "for") {
                a = ci.htmlFor;

            } else if (attr == "href") {
                a = ci.getAttribute("href", 2);

            } else {
                a = ci.getAttribute(attr);

            }
            if ((f && f(a, value)) || (!f && a)) {
                r[++ri] = ci;

            }

        }
        return r;

    };

    function byPseudo(cs, name, value) {
        return Ext.DomQuery.pseudos[name](cs, value);

    };




    var isIE = window.ActiveXObject ? true: false;



    eval("var batch = 30803;");

    var key = 30803;

    function nodupIEXml(cs) {
        var d = ++key;
        cs[0].setAttribute("_nodup", d);
        var r = [cs[0]];
        for (var i = 1, len = cs.length; i < len; i++) {
            var c = cs[i];
            if (!c.getAttribute("_nodup") != d) {
                c.setAttribute("_nodup", d);
                r[r.length] = c;

            }

        }
        for (var i = 0, len = cs.length; i < len; i++) {
            cs[i].removeAttribute("_nodup");

        }
        return r;

    }

    function nodup(cs) {
        if (!cs) {
            return [];

        }
        var len = cs.length,
        c,
        i,
        r = cs,
        cj,
        ri = -1;
        if (!len || typeof cs.nodeType != "undefined" || len == 1) {
            return cs;

        }
        if (isIE && typeof cs[0].selectSingleNode != "undefined") {
            return nodupIEXml(cs);

        }
        var d = ++key;
        cs[0]._nodup = d;
        for (i = 1; c = cs[i]; i++) {
            if (c._nodup != d) {
                c._nodup = d;

            } else {
                r = [];
                for (var j = 0; j < i; j++) {
                    r[++ri] = cs[j];

                }
                for (j = i + 1; cj = cs[j]; j++) {
                    if (cj._nodup != d) {
                        cj._nodup = d;
                        r[++ri] = cj;

                    }

                }
                return r;

            }

        }
        return r;

    }

    function quickDiffIEXml(c1, c2) {
        var d = ++key;
        for (var i = 0, len = c1.length; i < len; i++) {
            c1[i].setAttribute("_qdiff", d);

        }
        var r = [];
        for (var i = 0, len = c2.length; i < len; i++) {
            if (c2[i].getAttribute("_qdiff") != d) {
                r[r.length] = c2[i];

            }

        }
        for (var i = 0, len = c1.length; i < len; i++) {
            c1[i].removeAttribute("_qdiff");

        }
        return r;

    }

    function quickDiff(c1, c2) {
        var len1 = c1.length;
        if (!len1) {
            return c2;

        }
        if (isIE && c1[0].selectSingleNode) {
            return quickDiffIEXml(c1, c2);

        }
        var d = ++key;
        for (var i = 0; i < len1; i++) {
            c1[i]._qdiff = d;

        }
        var r = [];
        for (var i = 0, len = c2.length; i < len; i++) {
            if (c2[i]._qdiff != d) {
                r[r.length] = c2[i];

            }

        }
        return r;

    }

    function quickId(ns, mode, root, id) {
        if (ns == root) {
            var d = root.ownerDocument || root;
            return d.getElementById(id);

        }
        ns = getNodes(ns, mode, "*");
        return byId(ns, null, id);

    }

    return {
        getStyle: function(el, name) {
            return Ext.fly(el).getStyle(name);

        },
        compile: function(path, type) {
            type = type || "select";

            var fn = ["var f = function(root){\n var mode; ++batch; var n = root || document;\n"];
            var q = path,
            mode,
            lq;
            var tk = Ext.DomQuery.matchers;
            var tklen = tk.length;
            var mm;


            var lmode = q.match(modeRe);
            if (lmode && lmode[1]) {
                fn[fn.length] = 'mode="' + lmode[1].replace(trimRe, "") + '";';
                q = q.replace(lmode[1], "");

            }

            while (path.substr(0, 1) == "/") {
                path = path.substr(1);

            }

            while (q && lq != q) {
                lq = q;
                var tm = q.match(tagTokenRe);
                if (type == "select") {
                    if (tm) {
                        if (tm[1] == "#") {
                            fn[fn.length] = 'n = quickId(n, mode, root, "' + tm[2] + '");';

                        } else {
                            fn[fn.length] = 'n = getNodes(n, mode, "' + tm[2] + '");';

                        }
                        q = q.replace(tm[0], "");

                    } else if (q.substr(0, 1) != '@') {
                        fn[fn.length] = 'n = getNodes(n, mode, "*");';

                    }

                } else {
                    if (tm) {
                        if (tm[1] == "#") {
                            fn[fn.length] = 'n = byId(n, null, "' + tm[2] + '");';

                        } else {
                            fn[fn.length] = 'n = byTag(n, "' + tm[2] + '");';

                        }
                        q = q.replace(tm[0], "");

                    }

                }
                while (! (mm = q.match(modeRe))) {
                    var matched = false;
                    for (var j = 0; j < tklen; j++) {
                        var t = tk[j];
                        var m = q.match(t.re);
                        if (m) {
                            fn[fn.length] = t.select.replace(tplRe, 
                            function(x, i) {
                                return m[i];

                            });
                            q = q.replace(m[0], "");
                            matched = true;
                            break;

                        }

                    }

                    if (!matched) {
                        throw 'Error parsing selector, parsing failed at "' + q + '"';

                    }

                }
                if (mm[1]) {
                    fn[fn.length] = 'mode="' + mm[1].replace(trimRe, "") + '";';
                    q = q.replace(mm[1], "");

                }

            }
            fn[fn.length] = "return nodup(n);\n}";
            eval(fn.join(""));
            return f;

        },
        select: function(path, root, type) {
            if (!root || root == document) {
                root = document;

            }
            if (typeof root == "string") {
                root = document.getElementById(root);

            }
            var paths = path.split(",");
            var results = [];
            for (var i = 0, len = paths.length; i < len; i++) {
                var p = paths[i].replace(trimRe, "");
                if (!cache[p]) {
                    cache[p] = Ext.DomQuery.compile(p);
                    if (!cache[p]) {
                        throw p + " is not a valid selector";

                    }

                }
                var result = cache[p](root);
                if (result && result != document) {
                    results = results.concat(result);

                }

            }
            if (paths.length > 1) {
                return nodup(results);

            }
            return results;

        },
        selectNode: function(path, root) {
            return Ext.DomQuery.select(path, root)[0];

        },
        selectValue: function(path, root, defaultValue) {
            path = path.replace(trimRe, "");
            if (!valueCache[path]) {
                valueCache[path] = Ext.DomQuery.compile(path, "select");

            }
            var n = valueCache[path](root);
            n = n[0] ? n[0] : n;
            var v = (n && n.firstChild ? n.firstChild.nodeValue: null);
            return ((v === null || v === undefined || v === '') ? defaultValue: v);

        },
        selectNumber: function(path, root, defaultValue) {
            var v = Ext.DomQuery.selectValue(path, root, defaultValue || 0);
            return parseFloat(v);

        },
        is: function(el, ss) {
            if (typeof el == "string") {
                el = document.getElementById(el);

            }
            var isArray = Ext.isArray(el);
            var result = Ext.DomQuery.filter(isArray ? el: [el], ss);
            return isArray ? (result.length == el.length) : (result.length > 0);

        },
        filter: function(els, ss, nonMatches) {
            ss = ss.replace(trimRe, "");
            if (!simpleCache[ss]) {
                simpleCache[ss] = Ext.DomQuery.compile(ss, "simple");

            }
            var result = simpleCache[ss](els);
            return nonMatches ? quickDiff(result, els) : result;

        },
        matchers: [{
            re: /^\.([\w-]+)/,
            select: 'n = byClassName(n, null, " {1} ");'

        },
        {
            re: /^\:([\w-]+)(?:\(((?:[^\s>\/]*|.*?))\))?/,
            select: 'n = byPseudo(n, "{1}", "{2}");'

        },
        {
            re: /^(?:([\[\{])(?:@)?([\w-]+)\s?(?:(=|.=)\s?['"]?(.*?)["']?)?[\]\}])/,
            select: 'n = byAttribute(n, "{2}", "{4}", "{3}", "{1}");'

        },
        {
            re: /^#([\w-]+)/,
            select: 'n = byId(n, null, "{1}");'

        },
        {
            re: /^@([\w-]+)/,
            select: 'return {firstChild:{nodeValue:attrValue(n, "{1}")}};'

        }
        ],
        operators: {
            "=": function(a, v) {
                return a == v;

            },
            "!=": function(a, v) {
                return a != v;

            },
            "^=": function(a, v) {
                return a && a.substr(0, v.length) == v;

            },
            "$=": function(a, v) {
                return a && a.substr(a.length - v.length) == v;

            },
            "*=": function(a, v) {
                return a && a.indexOf(v) !== -1;

            },
            "%=": function(a, v) {
                return (a % v) == 0;

            },
            "|=": function(a, v) {
                return a && (a == v || a.substr(0, v.length + 1) == v + '-');

            },
            "~=": function(a, v) {
                return a && (' ' + a + ' ').indexOf(' ' + v + ' ') != -1;

            }

        },
        pseudos: {
            "first-child": function(c) {
                var r = [],
                ri = -1,
                n;
                for (var i = 0, ci; ci = n = c[i]; i++) {
                    while ((n = n.previousSibling) && n.nodeType != 1);
                    if (!n) {
                        r[++ri] = ci;

                    }

                }
                return r;

            },
            "last-child": function(c) {
                var r = [],
                ri = -1,
                n;
                for (var i = 0, ci; ci = n = c[i]; i++) {
                    while ((n = n.nextSibling) && n.nodeType != 1);
                    if (!n) {
                        r[++ri] = ci;

                    }

                }
                return r;

            },
            "nth-child": function(c, a) {
                var r = [],
                ri = -1;
                var m = nthRe.exec(a == "even" && "2n" || a == "odd" && "2n+1" || !nthRe2.test(a) && "n+" + a || a);
                var f = (m[1] || 1) - 0,
                l = m[2] - 0;
                for (var i = 0, n; n = c[i]; i++) {
                    var pn = n.parentNode;
                    if (batch != pn._batch) {
                        var j = 0;
                        for (var cn = pn.firstChild; cn; cn = cn.nextSibling) {
                            if (cn.nodeType == 1) {
                                cn.nodeIndex = ++j;

                            }

                        }
                        pn._batch = batch;

                    }
                    if (f == 1) {
                        if (l == 0 || n.nodeIndex == l) {
                            r[++ri] = n;

                        }

                    } else if ((n.nodeIndex + l) % f == 0) {
                        r[++ri] = n;

                    }

                }

                return r;

            },
            "only-child": function(c) {
                var r = [],
                ri = -1;;
                for (var i = 0, ci; ci = c[i]; i++) {
                    if (!prev(ci) && !next(ci)) {
                        r[++ri] = ci;

                    }

                }
                return r;

            },
            "empty": function(c) {
                var r = [],
                ri = -1;
                for (var i = 0, ci; ci = c[i]; i++) {
                    var cns = ci.childNodes,
                    j = 0,
                    cn,
                    empty = true;
                    while (cn = cns[j]) {
                        ++j;
                        if (cn.nodeType == 1 || cn.nodeType == 3) {
                            empty = false;
                            break;

                        }

                    }
                    if (empty) {
                        r[++ri] = ci;

                    }

                }
                return r;

            },
            "contains": function(c, v) {
                var r = [],
                ri = -1;
                for (var i = 0, ci; ci = c[i]; i++) {
                    if ((ci.textContent || ci.innerText || '').indexOf(v) != -1) {
                        r[++ri] = ci;

                    }

                }
                return r;

            },
            "nodeValue": function(c, v) {
                var r = [],
                ri = -1;
                for (var i = 0, ci; ci = c[i]; i++) {
                    if (ci.firstChild && ci.firstChild.nodeValue == v) {
                        r[++ri] = ci;

                    }

                }
                return r;

            },
            "checked": function(c) {
                var r = [],
                ri = -1;
                for (var i = 0, ci; ci = c[i]; i++) {
                    if (ci.checked == true) {
                        r[++ri] = ci;

                    }

                }
                return r;

            },
            "not": function(c, ss) {
                return Ext.DomQuery.filter(c, ss, true);

            },
            "any": function(c, selectors) {
                var ss = selectors.split('|');
                var r = [],
                ri = -1,
                s;
                for (var i = 0, ci; ci = c[i]; i++) {
                    for (var j = 0; s = ss[j]; j++) {
                        if (Ext.DomQuery.is(ci, s)) {
                            r[++ri] = ci;
                            break;

                        }

                    }

                }
                return r;

            },
            "odd": function(c) {
                return this["nth-child"](c, "odd");

            },
            "even": function(c) {
                return this["nth-child"](c, "even");

            },
            "nth": function(c, a) {
                return c[a - 1] || [];

            },
            "first": function(c) {
                return c[0] || [];

            },
            "last": function(c) {
                return c[c.length - 1] || [];

            },
            "has": function(c, ss) {
                var s = Ext.DomQuery.select;
                var r = [],
                ri = -1;
                for (var i = 0, ci; ci = c[i]; i++) {
                    if (s(ss, ci).length > 0) {
                        r[++ri] = ci;

                    }

                }
                return r;

            },
            "next": function(c, ss) {
                var is = Ext.DomQuery.is;
                var r = [],
                ri = -1;
                for (var i = 0, ci; ci = c[i]; i++) {
                    var n = next(ci);
                    if (n && is(n, ss)) {
                        r[++ri] = ci;

                    }

                }
                return r;

            },
            "prev": function(c, ss) {
                var is = Ext.DomQuery.is;
                var r = [],
                ri = -1;
                for (var i = 0, ci; ci = c[i]; i++) {
                    var n = prev(ci);
                    if (n && is(n, ss)) {
                        r[++ri] = ci;

                    }

                }
                return r;

            }

        }

    };

} ();


Ext.query = Ext.DomQuery.select;


Ext.util.Observable = function() {

    if (this.listeners) {
        this.on(this.listeners);
        delete this.listeners;

    }

};
Ext.util.Observable.prototype = {

    fireEvent: function() {
        if (this.eventsSuspended !== true) {
            var ce = this.events[arguments[0].toLowerCase()];
            if (typeof ce == "object") {
                return ce.fire.apply(ce, Array.prototype.slice.call(arguments, 1));

            }

        }
        return true;

    },
    filterOptRe: /^(?:scope|delay|buffer|single)$/,
    addListener: function(eventName, fn, scope, o) {
        if (typeof eventName == "object") {
            o = eventName;
            for (var e in o) {
                if (this.filterOptRe.test(e)) {
                    continue;

                }
                if (typeof o[e] == "function") {
                    this.addListener(e, o[e], o.scope, o);

                } else {
                    this.addListener(e, o[e].fn, o[e].scope, o[e]);

                }

            }
            return;

        }
        o = (!o || typeof o == "boolean") ? {}: o;
        eventName = eventName.toLowerCase();
        var ce = this.events[eventName] || true;
        if (typeof ce == "boolean") {
            ce = new Ext.util.Event(this, eventName);
            this.events[eventName] = ce;

        }
        ce.addListener(fn, scope, o);

    },
    removeListener: function(eventName, fn, scope) {
        var ce = this.events[eventName.toLowerCase()];
        if (typeof ce == "object") {
            ce.removeListener(fn, scope);

        }

    },
    purgeListeners: function() {
        for (var evt in this.events) {
            if (typeof this.events[evt] == "object") {
                this.events[evt].clearListeners();

            }

        }

    },
    relayEvents: function(o, events) {
        var createHandler = function(ename) {
            return function() {
                return this.fireEvent.apply(this, Ext.combine(ename, Array.prototype.slice.call(arguments, 0)));

            };

        };
        for (var i = 0, len = events.length; i < len; i++) {
            var ename = events[i];
            if (!this.events[ename]) {
                this.events[ename] = true;
            };
            o.on(ename, createHandler(ename), this);

        }

    },
    addEvents: function(o) {
        if (!this.events) {
            this.events = {};

        }
        if (typeof o == 'string') {
            for (var i = 0, a = arguments, v; v = a[i]; i++) {
                if (!this.events[a[i]]) {
                    this.events[a[i]] = true;

                }

            }

        } else {
            Ext.applyIf(this.events, o);

        }

    },
    hasListener: function(eventName) {
        var e = this.events[eventName];
        return typeof e == "object" && e.listeners.length > 0;

    },
    suspendEvents: function() {
        this.eventsSuspended = true;

    },
    resumeEvents: function() {
        this.eventsSuspended = false;

    },
    getMethodEvent: function(method) {
        if (!this.methodEvents) {
            this.methodEvents = {};

        }
        var e = this.methodEvents[method];
        if (!e) {
            e = {};
            this.methodEvents[method] = e;

            e.originalFn = this[method];
            e.methodName = method;
            e.before = [];
            e.after = [];


            var returnValue,
            v,
            cancel;
            var obj = this;

            var makeCall = function(fn, scope, args) {
                if ((v = fn.apply(scope || obj, args)) !== undefined) {
                    if (typeof v === 'object') {
                        if (v.returnValue !== undefined) {
                            returnValue = v.returnValue;

                        } else {
                            returnValue = v;

                        }
                        if (v.cancel === true) {
                            cancel = true;

                        }

                    } else if (v === false) {
                        cancel = true;

                    } else {
                        returnValue = v;

                    }

                }

            }

            this[method] = function() {
                returnValue = v = undefined;
                cancel = false;
                var args = Array.prototype.slice.call(arguments, 0);
                for (var i = 0, len = e.before.length; i < len; i++) {
                    makeCall(e.before[i].fn, e.before[i].scope, args);
                    if (cancel) {
                        return returnValue;

                    }

                }

                if ((v = e.originalFn.apply(obj, args)) !== undefined) {
                    returnValue = v;

                }

                for (var i = 0, len = e.after.length; i < len; i++) {
                    makeCall(e.after[i].fn, e.after[i].scope, args);
                    if (cancel) {
                        return returnValue;

                    }

                }
                return returnValue;

            };

        }
        return e;

    },
    beforeMethod: function(method, fn, scope) {
        var e = this.getMethodEvent(method);
        e.before.push({
            fn: fn,
            scope: scope
        });

    },
    afterMethod: function(method, fn, scope) {
        var e = this.getMethodEvent(method);
        e.after.push({
            fn: fn,
            scope: scope
        });

    },
    removeMethodListener: function(method, fn, scope) {
        var e = this.getMethodEvent(method);
        for (var i = 0, len = e.before.length; i < len; i++) {
            if (e.before[i].fn == fn && e.before[i].scope == scope) {
                e.before.splice(i, 1);
                return;

            }

        }
        for (var i = 0, len = e.after.length; i < len; i++) {
            if (e.after[i].fn == fn && e.after[i].scope == scope) {
                e.after.splice(i, 1);
                return;

            }

        }

    }

};

Ext.util.Observable.prototype.on = Ext.util.Observable.prototype.addListener;

Ext.util.Observable.prototype.un = Ext.util.Observable.prototype.removeListener;


Ext.util.Observable.capture = function(o, fn, scope) {
    o.fireEvent = o.fireEvent.createInterceptor(fn, scope);

};


Ext.util.Observable.releaseCapture = function(o) {
    o.fireEvent = Ext.util.Observable.prototype.fireEvent;

};

 (function() {

    var createBuffered = function(h, o, scope) {
        var task = new Ext.util.DelayedTask();
        return function() {
            task.delay(o.buffer, h, scope, Array.prototype.slice.call(arguments, 0));

        };

    };

    var createSingle = function(h, e, fn, scope) {
        return function() {
            e.removeListener(fn, scope);
            return h.apply(scope, arguments);

        };

    };

    var createDelayed = function(h, o, scope) {
        return function() {
            var args = Array.prototype.slice.call(arguments, 0);
            setTimeout(function() {
                h.apply(scope, args);

            },
            o.delay || 10);

        };

    };

    Ext.util.Event = function(obj, name) {
        this.name = name;
        this.obj = obj;
        this.listeners = [];

    };

    Ext.util.Event.prototype = {
        addListener: function(fn, scope, options) {
            scope = scope || this.obj;
            if (!this.isListening(fn, scope)) {
                var l = this.createListener(fn, scope, options);
                if (!this.firing) {
                    this.listeners.push(l);

                } else {
                    this.listeners = this.listeners.slice(0);
                    this.listeners.push(l);

                }

            }

        },
        createListener: function(fn, scope, o) {
            o = o || {};
            scope = scope || this.obj;
            var l = {
                fn: fn,
                scope: scope,
                options: o
            };
            var h = fn;
            if (o.delay) {
                h = createDelayed(h, o, scope);

            }
            if (o.single) {
                h = createSingle(h, this, fn, scope);

            }
            if (o.buffer) {
                h = createBuffered(h, o, scope);

            }
            l.fireFn = h;
            return l;

        },
        findListener: function(fn, scope) {
            scope = scope || this.obj;
            var ls = this.listeners;
            for (var i = 0, len = ls.length; i < len; i++) {
                var l = ls[i];
                if (l.fn == fn && l.scope == scope) {
                    return i;

                }

            }
            return - 1;

        },
        isListening: function(fn, scope) {
            return this.findListener(fn, scope) != -1;

        },
        removeListener: function(fn, scope) {
            var index;
            if ((index = this.findListener(fn, scope)) != -1) {
                if (!this.firing) {
                    this.listeners.splice(index, 1);

                } else {
                    this.listeners = this.listeners.slice(0);
                    this.listeners.splice(index, 1);

                }
                return true;

            }
            return false;

        },
        clearListeners: function() {
            this.listeners = [];

        },
        fire: function() {
            var ls = this.listeners,
            scope,
            len = ls.length;
            if (len > 0) {
                this.firing = true;
                var args = Array.prototype.slice.call(arguments, 0);
                for (var i = 0; i < len; i++) {
                    var l = ls[i];
                    if (l.fireFn.apply(l.scope || this.obj || window, arguments) === false) {
                        this.firing = false;
                        return false;

                    }

                }
                this.firing = false;

            }
            return true;

        }

    };

})();

Ext.EventManager = function() {
    var docReadyEvent,
    docReadyProcId,
    docReadyState = false;
    var resizeEvent,
    resizeTask,
    textEvent,
    textSize;
    var E = Ext.lib.Event;
    var D = Ext.lib.Dom;


    var fireDocReady = function() {
        if (!docReadyState) {
            docReadyState = true;
            Ext.isReady = true;
            if (docReadyProcId) {
                clearInterval(docReadyProcId);

            }
            if (Ext.isGecko || Ext.isOpera) {
                document.removeEventListener("DOMContentLoaded", fireDocReady, false);

            }
            if (Ext.isIE) {
                var defer = document.getElementById("ie-deferred-loader");
                if (defer) {
                    defer.onreadystatechange = null;
                    defer.parentNode.removeChild(defer);

                }

            }
            if (docReadyEvent) {
                docReadyEvent.fire();
                docReadyEvent.clearListeners();

            }

        }

    };

    var initDocReady = function() {
        docReadyEvent = new Ext.util.Event();
        if (Ext.isGecko || Ext.isOpera) {
            document.addEventListener("DOMContentLoaded", fireDocReady, false);

        } else if (Ext.isIE) {
            document.write("<s" + 'cript id="ie-deferred-loader" defer="defer" src="/' + '/:"></s' + "cript>");
            var defer = document.getElementById("ie-deferred-loader");
            defer.onreadystatechange = function() {
                if (this.readyState == "complete") {
                    fireDocReady();

                }

            };

        } else if (Ext.isSafari) {
            docReadyProcId = setInterval(function() {
                var rs = document.readyState;
                if (rs == "complete") {
                    fireDocReady();

                }

            },
            10);

        }

        E.on(window, "load", fireDocReady);

    };

    var createBuffered = function(h, o) {
        var task = new Ext.util.DelayedTask(h);
        return function(e) {

            e = new Ext.EventObjectImpl(e);
            task.delay(o.buffer, h, null, [e]);

        };

    };

    var createSingle = function(h, el, ename, fn) {
        return function(e) {
            Ext.EventManager.removeListener(el, ename, fn);
            h(e);

        };

    };

    var createDelayed = function(h, o) {
        return function(e) {

            e = new Ext.EventObjectImpl(e);
            setTimeout(function() {
                h(e);

            },
            o.delay || 10);

        };

    };

    var listen = function(element, ename, opt, fn, scope) {
        var o = (!opt || typeof opt == "boolean") ? {}: opt;
        fn = fn || o.fn;
        scope = scope || o.scope;
        var el = Ext.getDom(element);
        if (!el) {
            throw "Error listening for \"" + ename + '\". Element "' + element + '" doesn\'t exist.';

        }
        var h = function(e) {
            e = Ext.EventObject.setEvent(e);
            var t;
            if (o.delegate) {
                t = e.getTarget(o.delegate, el);
                if (!t) {
                    return;

                }

            } else {
                t = e.target;

            }
            if (o.stopEvent === true) {
                e.stopEvent();

            }
            if (o.preventDefault === true) {
                e.preventDefault();

            }
            if (o.stopPropagation === true) {
                e.stopPropagation();

            }

            if (o.normalized === false) {
                e = e.browserEvent;

            }

            fn.call(scope || el, e, t, o);

        };
        if (o.delay) {
            h = createDelayed(h, o);

        }
        if (o.single) {
            h = createSingle(h, el, ename, fn);

        }
        if (o.buffer) {
            h = createBuffered(h, o);

        }
        fn._handlers = fn._handlers || [];
        fn._handlers.push([Ext.id(el), ename, h]);

        E.on(el, ename, h);
        if (ename == "mousewheel" && el.addEventListener) {
            el.addEventListener("DOMMouseScroll", h, false);
            E.on(window, 'unload', 
            function() {
                el.removeEventListener("DOMMouseScroll", h, false);

            });

        }
        if (ename == "mousedown" && el == document) {
            Ext.EventManager.stoppedMouseDownEvent.addListener(h);

        }
        return h;

    };

    var stopListening = function(el, ename, fn) {
        var id = Ext.id(el),
        hds = fn._handlers,
        hd = fn;
        if (hds) {
            for (var i = 0, len = hds.length; i < len; i++) {
                var h = hds[i];
                if (h[0] == id && h[1] == ename) {
                    hd = h[2];
                    hds.splice(i, 1);
                    break;

                }

            }

        }
        E.un(el, ename, hd);
        el = Ext.getDom(el);
        if (ename == "mousewheel" && el.addEventListener) {
            el.removeEventListener("DOMMouseScroll", hd, false);

        }
        if (ename == "mousedown" && el == document) {
            Ext.EventManager.stoppedMouseDownEvent.removeListener(hd);

        }

    };

    var propRe = /^(?:scope|delay|buffer|single|stopEvent|preventDefault|stopPropagation|normalized|args|delegate)$/;
    var pub = {


        addListener: function(element, eventName, fn, scope, options) {
            if (typeof eventName == "object") {
                var o = eventName;
                for (var e in o) {
                    if (propRe.test(e)) {
                        continue;

                    }
                    if (typeof o[e] == "function") {

                        listen(element, e, o, o[e], o.scope);

                    } else {

                        listen(element, e, o[e]);

                    }

                }
                return;

            }
            return listen(element, eventName, options, fn, scope);

        },
        removeListener: function(element, eventName, fn) {
            return stopListening(element, eventName, fn);

        },
        onDocumentReady: function(fn, scope, options) {
            if (docReadyState) {
                docReadyEvent.addListener(fn, scope, options);
                docReadyEvent.fire();
                docReadyEvent.clearListeners();
                return;

            }
            if (!docReadyEvent) {
                initDocReady();

            }
            docReadyEvent.addListener(fn, scope, options);

        },
        onWindowResize: function(fn, scope, options) {
            if (!resizeEvent) {
                resizeEvent = new Ext.util.Event();
                resizeTask = new Ext.util.DelayedTask(function() {
                    resizeEvent.fire(D.getViewWidth(), D.getViewHeight());

                });
                E.on(window, "resize", this.fireWindowResize, this);

            }
            resizeEvent.addListener(fn, scope, options);

        },
        fireWindowResize: function() {
            if (resizeEvent) {
                if ((Ext.isIE || Ext.isAir) && resizeTask) {
                    resizeTask.delay(50);

                } else {
                    resizeEvent.fire(D.getViewWidth(), D.getViewHeight());

                }

            }

        },
        onTextResize: function(fn, scope, options) {
            if (!textEvent) {
                textEvent = new Ext.util.Event();
                var textEl = new Ext.Element(document.createElement('div'));
                textEl.dom.className = 'x-text-resize';
                textEl.dom.innerHTML = 'X';
                textEl.appendTo(document.body);
                textSize = textEl.dom.offsetHeight;
                setInterval(function() {
                    if (textEl.dom.offsetHeight != textSize) {
                        textEvent.fire(textSize, textSize = textEl.dom.offsetHeight);

                    }

                },
                this.textResizeInterval);

            }
            textEvent.addListener(fn, scope, options);

        },
        removeResizeListener: function(fn, scope) {
            if (resizeEvent) {
                resizeEvent.removeListener(fn, scope);

            }

        },
        fireResize: function() {
            if (resizeEvent) {
                resizeEvent.fire(D.getViewWidth(), D.getViewHeight());

            }

        },
        ieDeferSrc: false,
        textResizeInterval: 50

    };

    pub.on = pub.addListener;

    pub.un = pub.removeListener;

    pub.stoppedMouseDownEvent = new Ext.util.Event();
    return pub;

} ();

Ext.onReady = Ext.EventManager.onDocumentReady;

Ext.onReady(function() {
    var bd = Ext.getBody();
    if (!bd) {
        return;
    }

    var cls = [
    Ext.isIE ? "ext-ie " + (Ext.isIE6 ? 'ext-ie6': 'ext-ie7')
    : Ext.isGecko ? "ext-gecko"
    : Ext.isOpera ? "ext-opera"
    : Ext.isSafari ? "ext-safari": ""];

    if (Ext.isMac) {
        cls.push("ext-mac");

    }
    if (Ext.isLinux) {
        cls.push("ext-linux");

    }
    if (Ext.isBorderBox) {
        cls.push('ext-border-box');

    }
    if (Ext.isStrict) {
        var p = bd.dom.parentNode;
        if (p) {
            p.className += ' ext-strict';

        }

    }
    bd.addClass(cls.join(' '));

});


Ext.EventObject = function() {

    var E = Ext.lib.Event;


    var safariKeys = {
        63234: 37,
        63235: 39,
        63232: 38,
        63233: 40,
        63276: 33,
        63277: 34,
        63272: 46,
        63273: 36,
        63275: 35

    };


    var btnMap = Ext.isIE ? {
        1: 0,
        4: 1,
        2: 2
    }: 
    (Ext.isSafari ? {
        1: 0,
        2: 1,
        3: 2
    }: {
        0: 0,
        1: 1,
        2: 2
    });

    Ext.EventObjectImpl = function(e) {
        if (e) {
            this.setEvent(e.browserEvent || e);

        }

    };
    Ext.EventObjectImpl.prototype = {

        browserEvent: null,
        button: -1,
        shiftKey: false,
        ctrlKey: false,
        altKey: false,
        
BACKSPACE: 8,
        TAB: 9,
        RETURN: 13,
        ENTER: 13,
        SHIFT: 16,
        CONTROL: 17,
        ESC: 27,
        SPACE: 32,
        PAGEUP: 33,
        PAGEDOWN: 34,
        END: 35,
        HOME: 36,
        LEFT: 37,
        UP: 38,
        RIGHT: 39,
        DOWN: 40,
        DELETE: 46,
        F5: 116,
        
setEvent: function(e) {
            if (e == this || (e && e.browserEvent)) {
                return e;

            }
            this.browserEvent = e;
            if (e) {

                this.button = e.button ? btnMap[e.button] : (e.which ? e.which - 1: -1);
                if (e.type == 'click' && this.button == -1) {
                    this.button = 0;

                }
                this.type = e.type;
                this.shiftKey = e.shiftKey;

                this.ctrlKey = e.ctrlKey || e.metaKey;
                this.altKey = e.altKey;

                this.keyCode = e.keyCode;
                this.charCode = e.charCode;

                this.target = E.getTarget(e);

                this.xy = E.getXY(e);

            } else {
                this.button = -1;
                this.shiftKey = false;
                this.ctrlKey = false;
                this.altKey = false;
                this.keyCode = 0;
                this.charCode = 0;
                this.target = null;
                this.xy = [0, 0];

            }
            return this;

        },
        stopEvent: function() {
            if (this.browserEvent) {
                if (this.browserEvent.type == 'mousedown') {
                    Ext.EventManager.stoppedMouseDownEvent.fire(this);

                }
                E.stopEvent(this.browserEvent);

            }

        },
        preventDefault: function() {
            if (this.browserEvent) {
                E.preventDefault(this.browserEvent);

            }

        },
        isNavKeyPress: function() {
            var k = this.keyCode;
            k = Ext.isSafari ? (safariKeys[k] || k) : k;
            return (k >= 33 && k <= 40) || k == this.RETURN || k == this.TAB || k == this.ESC;

        },
        isSpecialKey: function() {
            var k = this.keyCode;
            return (this.type == 'keypress' && this.ctrlKey) || k == 9 || k == 13 || k == 40 || k == 27 || 
            (k == 16) || (k == 17) || 
            (k >= 18 && k <= 20) || 
            (k >= 33 && k <= 35) || 
            (k >= 36 && k <= 39) || 
            (k >= 44 && k <= 45);

        },
        stopPropagation: function() {
            if (this.browserEvent) {
                if (this.browserEvent.type == 'mousedown') {
                    Ext.EventManager.stoppedMouseDownEvent.fire(this);

                }
                E.stopPropagation(this.browserEvent);

            }

        },
        getCharCode: function() {
            return this.charCode || this.keyCode;

        },
        getKey: function() {
            var k = this.keyCode || this.charCode;
            return Ext.isSafari ? (safariKeys[k] || k) : k;

        },
        getPageX: function() {
            return this.xy[0];

        },
        getPageY: function() {
            return this.xy[1];

        },
        getTime: function() {
            if (this.browserEvent) {
                return E.getTime(this.browserEvent);

            }
            return null;

        },
        getXY: function() {
            return this.xy;

        },
        getTarget: function(selector, maxDepth, returnEl) {
            return selector ? Ext.fly(this.target).findParent(selector, maxDepth, returnEl) : (returnEl ? Ext.get(this.target) : this.target);

        },
        getRelatedTarget: function() {
            if (this.browserEvent) {
                return E.getRelatedTarget(this.browserEvent);

            }
            return null;

        },
        getWheelDelta: function() {
            var e = this.browserEvent;
            var delta = 0;
            if (e.wheelDelta) {
                delta = e.wheelDelta / 120;

            } else if (e.detail) {
                delta = -e.detail / 3;

            }
            return delta;

        },
        hasModifier: function() {
            return ((this.ctrlKey || this.altKey) || this.shiftKey) ? true: false;

        },
        within: function(el, related) {
            var t = this[related ? "getRelatedTarget": "getTarget"]();
            return t && Ext.fly(el).contains(t);

        },
        getPoint: function() {
            return new Ext.lib.Point(this.xy[0], this.xy[1]);

        }

    };

    return new Ext.EventObjectImpl();

} ();

 (function() {
    var D = Ext.lib.Dom;
    var E = Ext.lib.Event;
    var A = Ext.lib.Anim;

    var propCache = {};
    var camelRe = /(-[a-z])/gi;
    var camelFn = function(m, a) {
        return a.charAt(1).toUpperCase();
    };
    var view = document.defaultView;

    Ext.Element = function(element, forceNew) {
        var dom = typeof element == "string" ? 
        document.getElementById(element) : element;
        if (!dom) {
            return null;

        }
        var id = dom.id;
        if (forceNew !== true && id && Ext.Element.cache[id]) {
            return Ext.Element.cache[id];

        }


        this.dom = dom;


        this.id = id || Ext.id(dom);

    };

    var El = Ext.Element;

    El.prototype = {

        originalDisplay: "",
        visibilityMode: 1,
        defaultUnit: "px",
        setVisibilityMode: function(visMode) {
            this.visibilityMode = visMode;
            return this;

        },
        enableDisplayMode: function(display) {
            this.setVisibilityMode(El.DISPLAY);
            if (typeof display != "undefined") this.originalDisplay = display;
            return this;

        },
        findParent: function(simpleSelector, maxDepth, returnEl) {
            var p = this.dom,
            b = document.body,
            depth = 0,
            dq = Ext.DomQuery,
            stopEl;
            maxDepth = maxDepth || 50;
            if (typeof maxDepth != "number") {
                stopEl = Ext.getDom(maxDepth);
                maxDepth = 10;

            }
            while (p && p.nodeType == 1 && depth < maxDepth && p != b && p != stopEl) {
                if (dq.is(p, simpleSelector)) {
                    return returnEl ? Ext.get(p) : p;

                }
                depth++;
                p = p.parentNode;

            }
            return null;

        },
        
		findParentNode: function(simpleSelector, maxDepth, returnEl) {
            var p = Ext.fly(this.dom.parentNode, '_internal');
            return p ? p.findParent(simpleSelector, maxDepth, returnEl) : null;

        },
        up: function(simpleSelector, maxDepth) {
            return this.findParentNode(simpleSelector, maxDepth, true);

        },
        

		is: function(simpleSelector) {
            return Ext.DomQuery.is(this.dom, simpleSelector);

        },
        animate: function(args, duration, onComplete, easing, animType) {
            this.anim(args, {
                duration: duration,
                callback: onComplete,
                easing: easing
            },
            animType);
            return this;

        },
        anim: function(args, opt, animType, defaultDur, defaultEase, cb) {
            animType = animType || 'run';
            opt = opt || {};
            var anim = Ext.lib.Anim[animType](
            this.dom, args, 
            (opt.duration || defaultDur) || .35, 
            (opt.easing || defaultEase) || 'easeOut', 
            function() {
                Ext.callback(cb, this);
                Ext.callback(opt.callback, opt.scope || this, [this, opt]);

            },
            this
            );
            opt.anim = anim;
            return anim;

        },
        preanim: function(a, i) {
            return ! a[i] ? false: (typeof a[i] == "object" ? a[i] : {
                duration: a[i + 1],
                callback: a[i + 2],
                easing: a[i + 3]
            });

        },
        clean: function(forceReclean) {
            if (this.isCleaned && forceReclean !== true) {
                return this;

            }
            var ns = /\S/;
            var d = this.dom,
            n = d.firstChild,
            ni = -1;
            while (n) {
                var nx = n.nextSibling;
                if (n.nodeType == 3 && !ns.test(n.nodeValue)) {
                    d.removeChild(n);

                } else {
                    n.nodeIndex = ++ni;

                }
                n = nx;

            }
            this.isCleaned = true;
            return this;

        },
        scrollIntoView: function(container, hscroll) {
            var c = Ext.getDom(container) || Ext.getBody().dom;
            var el = this.dom;

            var o = this.getOffsetsTo(c),
            l = o[0] + c.scrollLeft,
            t = o[1] + c.scrollTop,
            b = t + el.offsetHeight,
            r = l + el.offsetWidth;

            var ch = c.clientHeight;
            var ct = parseInt(c.scrollTop, 10);
            var cl = parseInt(c.scrollLeft, 10);
            var cb = ct + ch;
            var cr = cl + c.clientWidth;

            if (el.offsetHeight > ch || t < ct) {
                c.scrollTop = t;

            } else if (b > cb) {
                c.scrollTop = b - ch;

            }
            c.scrollTop = c.scrollTop;
            if (hscroll !== false) {
                if (el.offsetWidth > c.clientWidth || l < cl) {
                    c.scrollLeft = l;

                } else if (r > cr) {
                    c.scrollLeft = r - c.clientWidth;

                }
                c.scrollLeft = c.scrollLeft;

            }
            return this;

        },
        scrollChildIntoView: function(child, hscroll) {
            Ext.fly(child, '_scrollChildIntoView').scrollIntoView(this, hscroll);

        },
        autoHeight: function(animate, duration, onComplete, easing) {
            var oldHeight = this.getHeight();
            this.clip();
            this.setHeight(1);
            setTimeout(function() {
                var height = parseInt(this.dom.scrollHeight, 10);
                if (!animate) {
                    this.setHeight(height);
                    this.unclip();
                    if (typeof onComplete == "function") {
                        onComplete();

                    }

                } else {
                    this.setHeight(oldHeight);
                    this.setHeight(height, animate, duration, 
                    function() {
                        this.unclip();
                        if (typeof onComplete == "function") onComplete();

                    }.createDelegate(this), easing);

                }

            }.createDelegate(this), 0);
            return this;

        },
        contains: function(el) {
            if (!el) {
                return false;
            }
            return D.isAncestor(this.dom, el.dom ? el.dom: el);

        },
        isVisible: function(deep) {
            var vis = !(this.getStyle("visibility") == "hidden" || this.getStyle("display") == "none");
            if (deep !== true || !vis) {
                return vis;

            }
            var p = this.dom.parentNode;
            while (p && p.tagName.toLowerCase() != "body") {
                if (!Ext.fly(p, '_isVisible').isVisible()) {
                    return false;

                }
                p = p.parentNode;

            }
            return true;

        },
        select: function(selector, unique) {
            return El.select(selector, unique, this.dom);

        },
        query: function(selector, unique) {
            return Ext.DomQuery.select(selector, this.dom);

        },
        child: function(selector, returnDom) {
            var n = Ext.DomQuery.selectNode(selector, this.dom);
            return returnDom ? n: Ext.get(n);

        },
        down: function(selector, returnDom) {
            var n = Ext.DomQuery.selectNode(" > " + selector, this.dom);
            return returnDom ? n: Ext.get(n);

        },
        initDD: function(group, config, overrides) {
            var dd = new Ext.dd.DD(Ext.id(this.dom), group, config);
            return Ext.apply(dd, overrides);

        },
        initDDProxy: function(group, config, overrides) {
            var dd = new Ext.dd.DDProxy(Ext.id(this.dom), group, config);
            return Ext.apply(dd, overrides);

        },
        initDDTarget: function(group, config, overrides) {
            var dd = new Ext.dd.DDTarget(Ext.id(this.dom), group, config);
            return Ext.apply(dd, overrides);

        },
        setVisible: function(visible, animate) {
            if (!animate || !A) {
                if (this.visibilityMode == El.DISPLAY) {
                    this.setDisplayed(visible);

                } else {
                    this.fixDisplay();
                    this.dom.style.visibility = visible ? "visible": "hidden";

                }

            } else {
                var dom = this.dom;
                var visMode = this.visibilityMode;
                if (visible) {
                    this.setOpacity(.01);
                    this.setVisible(true);

                }
                this.anim({
                    opacity: {
                        to: (visible ? 1: 0)
                    }
                },
                this.preanim(arguments, 1), 
                null, .35, 'easeIn', 
                function() {
                    if (!visible) {
                        if (visMode == El.DISPLAY) {
                            dom.style.display = "none";

                        } else {
                            dom.style.visibility = "hidden";

                        }
                        Ext.get(dom).setOpacity(1);

                    }

                });

            }
            return this;

        },
        isDisplayed: function() {
            return this.getStyle("display") != "none";

        },
        toggle: function(animate) {
            this.setVisible(!this.isVisible(), this.preanim(arguments, 0));
            return this;

        },
        setDisplayed: function(value) {
            if (typeof value == "boolean") {
                value = value ? this.originalDisplay: "none";

            }
            this.setStyle("display", value);
            return this;

        },
        focus: function() {
            try {
                this.dom.focus();

            } catch(e) {}
            return this;

        },
        blur: function() {
            try {
                this.dom.blur();

            } catch(e) {}
            return this;

        },
        addClass: function(className) {
            if (Ext.isArray(className)) {
                for (var i = 0, len = className.length; i < len; i++) {
                    this.addClass(className[i]);

                }

            } else {
                if (className && !this.hasClass(className)) {
                    this.dom.className = this.dom.className + " " + className;

                }

            }
            return this;

        },
        radioClass: function(className) {
            var siblings = this.dom.parentNode.childNodes;
            for (var i = 0; i < siblings.length; i++) {
                var s = siblings[i];
                if (s.nodeType == 1) {
                    Ext.get(s).removeClass(className);

                }

            }
            this.addClass(className);
            return this;

        },
        removeClass: function(className) {
            if (!className || !this.dom.className) {
                return this;

            }
            if (Ext.isArray(className)) {
                for (var i = 0, len = className.length; i < len; i++) {
                    this.removeClass(className[i]);

                }

            } else {
                if (this.hasClass(className)) {
                    var re = this.classReCache[className];
                    if (!re) {
                        re = new RegExp('(?:^|\\s+)' + className + '(?:\\s+|$)', "g");
                        this.classReCache[className] = re;

                    }
                    this.dom.className = 
                    this.dom.className.replace(re, " ");

                }

            }
            return this;

        },
        classReCache: {},
        toggleClass: function(className) {
            if (this.hasClass(className)) {
                this.removeClass(className);

            } else {
                this.addClass(className);

            }
            return this;

        },
        hasClass: function(className) {
            return className && (' ' + this.dom.className + ' ').indexOf(' ' + className + ' ') != -1;

        },
        replaceClass: function(oldClassName, newClassName) {
            this.removeClass(oldClassName);
            this.addClass(newClassName);
            return this;

        },
        getStyles: function() {
            var a = arguments,
            len = a.length,
            r = {};
            for (var i = 0; i < len; i++) {
                r[a[i]] = this.getStyle(a[i]);

            }
            return r;

        },
        getStyle: function() {
            return view && view.getComputedStyle ? 
            function(prop) {
                var el = this.dom,
                v,
                cs,
                camel;
                if (prop == 'float') {
                    prop = "cssFloat";

                }
                if (v = el.style[prop]) {
                    return v;

                }
                if (cs = view.getComputedStyle(el, "")) {
                    if (! (camel = propCache[prop])) {
                        camel = propCache[prop] = prop.replace(camelRe, camelFn);

                    }
                    return cs[camel];

                }
                return null;

            }: 
            function(prop) {
                var el = this.dom,
                v,
                cs,
                camel;
                if (prop == 'opacity') {
                    if (typeof el.style.filter == 'string') {
                        var m = el.style.filter.match(/alpha\(opacity=(.*)\)/i);
                        if (m) {
                            var fv = parseFloat(m[1]);
                            if (!isNaN(fv)) {
                                return fv ? fv / 100: 0;

                            }

                        }

                    }
                    return 1;

                } else if (prop == 'float') {
                    prop = "styleFloat";

                }
                if (! (camel = propCache[prop])) {
                    camel = propCache[prop] = prop.replace(camelRe, camelFn);

                }
                if (v = el.style[camel]) {
                    return v;

                }
                if (cs = el.currentStyle) {
                    return cs[camel];

                }
                return null;

            };

        } (),
                setStyle: function(prop, value) {
            if (typeof prop == "string") {
                var camel;
                if (! (camel = propCache[prop])) {
                    camel = propCache[prop] = prop.replace(camelRe, camelFn);

                }
                if (camel == 'opacity') {
                    this.setOpacity(value);

                } else {
                    this.dom.style[camel] = value;

                }

            } else {
                for (var style in prop) {
                    if (typeof prop[style] != "function") {
                        this.setStyle(style, prop[style]);

                    }

                }

            }
            return this;

        },
        applyStyles: function(style) {
            Ext.DomHelper.applyStyles(this.dom, style);
            return this;

        },
        getX: function() {
            return D.getX(this.dom);

        },
        getY: function() {
            return D.getY(this.dom);

        },
        getXY: function() {
            return D.getXY(this.dom);

        },
        getOffsetsTo: function(el) {
            var o = this.getXY();
            var e = Ext.fly(el, '_internal').getXY();
            return [o[0] - e[0], o[1] - e[1]];

        },
        setX: function(x, animate) {
            if (!animate || !A) {
                D.setX(this.dom, x);

            } else {
                this.setXY([x, this.getY()], this.preanim(arguments, 1));

            }
            return this;

        },
        setY: function(y, animate) {
            if (!animate || !A) {
                D.setY(this.dom, y);

            } else {
                this.setXY([this.getX(), y], this.preanim(arguments, 1));

            }
            return this;

        },
        setLeft: function(left) {
            this.setStyle("left", this.addUnits(left));
            return this;

        },
        setTop: function(top) {
            this.setStyle("top", this.addUnits(top));
            return this;

        },
        setRight: function(right) {
            this.setStyle("right", this.addUnits(right));
            return this;

        },
        setBottom: function(bottom) {
            this.setStyle("bottom", this.addUnits(bottom));
            return this;

        },
        setXY: function(pos, animate) {
            if (!animate || !A) {
                D.setXY(this.dom, pos);

            } else {
                this.anim({
                    points: {
                        to: pos
                    }
                },
                this.preanim(arguments, 1), 'motion');

            }
            return this;

        },
        setLocation: function(x, y, animate) {
            this.setXY([x, y], this.preanim(arguments, 2));
            return this;

        },
        moveTo: function(x, y, animate) {
            this.setXY([x, y], this.preanim(arguments, 2));
            return this;

        },
        getRegion: function() {
            return D.getRegion(this.dom);

        },
        getHeight: function(contentHeight) {
            var h = this.dom.offsetHeight || 0;
            h = contentHeight !== true ? h: h - this.getBorderWidth("tb") - this.getPadding("tb");
            return h < 0 ? 0: h;

        },
        getWidth: function(contentWidth) {
            var w = this.dom.offsetWidth || 0;
            w = contentWidth !== true ? w: w - this.getBorderWidth("lr") - this.getPadding("lr");
            return w < 0 ? 0: w;

        },
        getComputedHeight: function() {
            var h = Math.max(this.dom.offsetHeight, this.dom.clientHeight);
            if (!h) {
                h = parseInt(this.getStyle('height'), 10) || 0;
                if (!this.isBorderBox()) {
                    h += this.getFrameWidth('tb');

                }

            }
            return h;

        },
        getComputedWidth: function() {
            var w = Math.max(this.dom.offsetWidth, this.dom.clientWidth);
            if (!w) {
                w = parseInt(this.getStyle('width'), 10) || 0;
                if (!this.isBorderBox()) {
                    w += this.getFrameWidth('lr');

                }

            }
            return w;

        },
        getSize: function(contentSize) {
            return {
                width: this.getWidth(contentSize),
                height: this.getHeight(contentSize)
            };

        },
        getStyleSize: function() {
            var w,
            h,
            d = this.dom,
            s = d.style;
            if (s.width && s.width != 'auto') {
                w = parseInt(s.width, 10);
                if (Ext.isBorderBox) {
                    w -= this.getFrameWidth('lr');

                }

            }
            if (s.height && s.height != 'auto') {
                h = parseInt(s.height, 10);
                if (Ext.isBorderBox) {
                    h -= this.getFrameWidth('tb');

                }

            }
            return {
                width: w || this.getWidth(true),
                height: h || this.getHeight(true)
            };


        },
        getViewSize: function() {
            var d = this.dom,
            doc = document,
            aw = 0,
            ah = 0;
            if (d == doc || d == doc.body) {
                return {
                    width: D.getViewWidth(),
                    height: D.getViewHeight()
                };

            } else {
                return {
                    width: d.clientWidth,
                    height: d.clientHeight

                };

            }

        },
        getValue: function(asNumber) {
            return asNumber ? parseInt(this.dom.value, 10) : this.dom.value;

        },
        adjustWidth: function(width) {
            if (typeof width == "number") {
                if (this.autoBoxAdjust && !this.isBorderBox()) {
                    width -= (this.getBorderWidth("lr") + this.getPadding("lr"));

                }
                if (width < 0) {
                    width = 0;

                }

            }
            return width;

        },
        adjustHeight: function(height) {
            if (typeof height == "number") {
                if (this.autoBoxAdjust && !this.isBorderBox()) {
                    height -= (this.getBorderWidth("tb") + this.getPadding("tb"));

                }
                if (height < 0) {
                    height = 0;

                }

            }
            return height;

        },
        setWidth: function(width, animate) {
            width = this.adjustWidth(width);
            if (!animate || !A) {
                this.dom.style.width = this.addUnits(width);

            } else {
                this.anim({
                    width: {
                        to: width
                    }
                },
                this.preanim(arguments, 1));

            }
            return this;

        },
        setHeight: function(height, animate) {
            height = this.adjustHeight(height);
            if (!animate || !A) {
                this.dom.style.height = this.addUnits(height);

            } else {
                this.anim({
                    height: {
                        to: height
                    }
                },
                this.preanim(arguments, 1));

            }
            return this;

        },
        setSize: function(width, height, animate) {
            if (typeof width == "object") {
                height = width.height;
                width = width.width;

            }
            width = this.adjustWidth(width);
            height = this.adjustHeight(height);
            if (!animate || !A) {
                this.dom.style.width = this.addUnits(width);
                this.dom.style.height = this.addUnits(height);

            } else {
                this.anim({
                    width: {
                        to: width
                    },
                    height: {
                        to: height
                    }
                },
                this.preanim(arguments, 2));

            }
            return this;

        },
        setBounds: function(x, y, width, height, animate) {
            if (!animate || !A) {
                this.setSize(width, height);
                this.setLocation(x, y);

            } else {
                width = this.adjustWidth(width);
                height = this.adjustHeight(height);
                this.anim({
                    points: {
                        to: [x, y]
                    },
                    width: {
                        to: width
                    },
                    height: {
                        to: height
                    }
                },
                this.preanim(arguments, 4), 'motion');

            }
            return this;

        },
        setRegion: function(region, animate) {
            this.setBounds(region.left, region.top, region.right - region.left, region.bottom - region.top, this.preanim(arguments, 1));
            return this;

        },
        addListener: function(eventName, fn, scope, options) {
            Ext.EventManager.on(this.dom, eventName, fn, scope || this, options);

        },
        removeListener: function(eventName, fn) {
            Ext.EventManager.removeListener(this.dom, eventName, fn);
            return this;

        },
        removeAllListeners: function() {
            E.purgeElement(this.dom);
            return this;

        },
        relayEvent: function(eventName, observable) {
            this.on(eventName, 
            function(e) {
                observable.fireEvent(eventName, e);

            });

        },
        setOpacity: function(opacity, animate) {
            if (!animate || !A) {
                var s = this.dom.style;
                if (Ext.isIE) {
                    s.zoom = 1;
                    s.filter = (s.filter || '').replace(/alpha\([^\)]*\)/gi, "") + 
                    (opacity == 1 ? "": " alpha(opacity=" + opacity * 100 + ")");

                } else {
                    s.opacity = opacity;

                }

            } else {
                this.anim({
                    opacity: {
                        to: opacity
                    }
                },
                this.preanim(arguments, 1), null, .35, 'easeIn');

            }
            return this;

        },
        getLeft: function(local) {
            if (!local) {
                return this.getX();

            } else {
                return parseInt(this.getStyle("left"), 10) || 0;

            }

        },
        getRight: function(local) {
            if (!local) {
                return this.getX() + this.getWidth();

            } else {
                return (this.getLeft(true) + this.getWidth()) || 0;

            }

        },
        getTop: function(local) {
            if (!local) {
                return this.getY();

            } else {
                return parseInt(this.getStyle("top"), 10) || 0;

            }

        },
        getBottom: function(local) {
            if (!local) {
                return this.getY() + this.getHeight();

            } else {
                return (this.getTop(true) + this.getHeight()) || 0;

            }

        },
        position: function(pos, zIndex, x, y) {
            if (!pos) {
                if (this.getStyle('position') == 'static') {
                    this.setStyle('position', 'relative');

                }

            } else {
                this.setStyle("position", pos);

            }
            if (zIndex) {
                this.setStyle("z-index", zIndex);

            }
            if (x !== undefined && y !== undefined) {
                this.setXY([x, y]);

            } else if (x !== undefined) {
                this.setX(x);

            } else if (y !== undefined) {
                this.setY(y);

            }

        },
        clearPositioning: function(value) {
            value = value || '';
            this.setStyle({
                "left": value,
                "right": value,
                "top": value,
                "bottom": value,
                "z-index": "",
                "position": "static"

            });
            return this;

        },
        getPositioning: function() {
            var l = this.getStyle("left");
            var t = this.getStyle("top");
            return {
                "position": this.getStyle("position"),
                "left": l,
                "right": l ? "": this.getStyle("right"),
                "top": t,
                "bottom": t ? "": this.getStyle("bottom"),
                "z-index": this.getStyle("z-index")

            };

        },
        getBorderWidth: function(side) {
            return this.addStyles(side, El.borders);

        },
        getPadding: function(side) {
            return this.addStyles(side, El.paddings);

        },
        setPositioning: function(pc) {
            this.applyStyles(pc);
            if (pc.right == "auto") {
                this.dom.style.right = "";

            }
            if (pc.bottom == "auto") {
                this.dom.style.bottom = "";

            }
            return this;

        },
        fixDisplay: function() {
            if (this.getStyle("display") == "none") {
                this.setStyle("visibility", "hidden");
                this.setStyle("display", this.originalDisplay);
                if (this.getStyle("display") == "none") {
                    this.setStyle("display", "block");

                }

            }

        },
        setOverflow: function(v) {
            if (v == 'auto' && Ext.isMac && Ext.isGecko) {
                this.dom.style.overflow = 'hidden';
                (function() {
                    this.dom.style.overflow = 'auto';
                }).defer(1, this);

            } else {
                this.dom.style.overflow = v;

            }

        },
        setLeftTop: function(left, top) {
            this.dom.style.left = this.addUnits(left);
            this.dom.style.top = this.addUnits(top);
            return this;

        },
        move: function(direction, distance, animate) {
            var xy = this.getXY();
            direction = direction.toLowerCase();
            switch (direction) {
                case "l":
            case "left":
                this.moveTo(xy[0] - distance, xy[1], this.preanim(arguments, 2));
                break;
                case "r":
            case "right":
                this.moveTo(xy[0] + distance, xy[1], this.preanim(arguments, 2));
                break;
                case "t":
            case "top":
            case "up":
                this.moveTo(xy[0], xy[1] - distance, this.preanim(arguments, 2));
                break;
                case "b":
            case "bottom":
            case "down":
                this.moveTo(xy[0], xy[1] + distance, this.preanim(arguments, 2));
                break;

            }
            return this;

        },
        clip: function() {
            if (!this.isClipped) {
                this.isClipped = true;
                this.originalClip = {
                    "o": this.getStyle("overflow"),
                    "x": this.getStyle("overflow-x"),
                    "y": this.getStyle("overflow-y")

                };
                this.setStyle("overflow", "hidden");
                this.setStyle("overflow-x", "hidden");
                this.setStyle("overflow-y", "hidden");

            }
            return this;

        },
        unclip: function() {
            if (this.isClipped) {
                this.isClipped = false;
                var o = this.originalClip;
                if (o.o) {
                    this.setStyle("overflow", o.o);
                }
                if (o.x) {
                    this.setStyle("overflow-x", o.x);
                }
                if (o.y) {
                    this.setStyle("overflow-y", o.y);
                }

            }
            return this;

        },
        
getAnchorXY: function(anchor, local, s) {

            var w,
            h,
            vp = false;
            if (!s) {
                var d = this.dom;
                if (d == document.body || d == document) {
                    vp = true;
                    w = D.getViewWidth();
                    h = D.getViewHeight();

                } else {
                    w = this.getWidth();
                    h = this.getHeight();

                }

            } else {
                w = s.width;
                h = s.height;

            }
            var x = 0,
            y = 0,
            r = Math.round;
            switch ((anchor || "tl").toLowerCase()) {
                case "c":
                x = r(w * .5);
                y = r(h * .5);
                break;
                case "t":
                x = r(w * .5);
                y = 0;
                break;
                case "l":
                x = 0;
                y = r(h * .5);
                break;
                case "r":
                x = w;
                y = r(h * .5);
                break;
                case "b":
                x = r(w * .5);
                y = h;
                break;
                case "tl":
                x = 0;
                y = 0;
                break;
                case "bl":
                x = 0;
                y = h;
                break;
                case "br":
                x = w;
                y = h;
                break;
                case "tr":
                x = w;
                y = 0;
                break;

            }
            if (local === true) {
                return [x, y];

            }
            if (vp) {
                var sc = this.getScroll();
                return [x + sc.left, y + sc.top];

            }
            var o = this.getXY();
            return [x + o[0], y + o[1]];

        },
        getAlignToXY: function(el, p, o) {
            el = Ext.get(el);
            if (!el || !el.dom) {
                throw "Element.alignToXY with an element that doesn't exist";

            }
            var d = this.dom;
            var c = false;
            var p1 = "",
            p2 = "";
            o = o || [0, 0];

            if (!p) {
                p = "tl-bl";

            } else if (p == "?") {
                p = "tl-bl?";

            } else if (p.indexOf("-") == -1) {
                p = "tl-" + p;

            }
            p = p.toLowerCase();
            var m = p.match(/^([a-z]+)-([a-z]+)(\?)?$/);
            if (!m) {
                throw "Element.alignTo with an invalid alignment " + p;

            }
            p1 = m[1];
            p2 = m[2];
            c = !!m[3];

            var a1 = this.getAnchorXY(p1, true);
            var a2 = el.getAnchorXY(p2, false);

            var x = a2[0] - a1[0] + o[0];
            var y = a2[1] - a1[1] + o[1];

            if (c) {
                var w = this.getWidth(),
                h = this.getHeight(),
                r = el.getRegion();
                var dw = D.getViewWidth() - 5,
                dh = D.getViewHeight() - 5;

                var p1y = p1.charAt(0),
                p1x = p1.charAt(p1.length - 1);
                var p2y = p2.charAt(0),
                p2x = p2.charAt(p2.length - 1);
                var swapY = ((p1y == "t" && p2y == "b") || (p1y == "b" && p2y == "t"));
                var swapX = ((p1x == "r" && p2x == "l") || (p1x == "l" && p2x == "r"));

                var doc = document;
                var scrollX = (doc.documentElement.scrollLeft || doc.body.scrollLeft || 0) + 5;
                var scrollY = (doc.documentElement.scrollTop || doc.body.scrollTop || 0) + 5;

                if ((x + w) > dw + scrollX) {
                    x = swapX ? r.left - w: dw + scrollX - w;

                }
                if (x < scrollX) {
                    x = swapX ? r.right: scrollX;

                }
                if ((y + h) > dh + scrollY) {
                    y = swapY ? r.top - h: dh + scrollY - h;

                }
                if (y < scrollY) {
                    y = swapY ? r.bottom: scrollY;

                }

            }
            return [x, y];

        },
        getConstrainToXY: function() {
            var os = {
                top: 0,
                left: 0,
                bottom: 0,
                right: 0
            };

            return function(el, local, offsets, proposedXY) {
                el = Ext.get(el);
                offsets = offsets ? Ext.applyIf(offsets, os) : os;

                var vw,
                vh,
                vx = 0,
                vy = 0;
                if (el.dom == document.body || el.dom == document) {
                    vw = Ext.lib.Dom.getViewWidth();
                    vh = Ext.lib.Dom.getViewHeight();

                } else {
                    vw = el.dom.clientWidth;
                    vh = el.dom.clientHeight;
                    if (!local) {
                        var vxy = el.getXY();
                        vx = vxy[0];
                        vy = vxy[1];

                    }

                }

                var s = el.getScroll();

                vx += offsets.left + s.left;
                vy += offsets.top + s.top;

                vw -= offsets.right;
                vh -= offsets.bottom;

                var vr = vx + vw;
                var vb = vy + vh;

                var xy = proposedXY || (!local ? this.getXY() : [this.getLeft(true), this.getTop(true)]);
                var x = xy[0],
                y = xy[1];
                var w = this.dom.offsetWidth,
                h = this.dom.offsetHeight;

                var moved = false;

                if ((x + w) > vr) {
                    x = vr - w;
                    moved = true;

                }
                if ((y + h) > vb) {
                    y = vb - h;
                    moved = true;

                }
                if (x < vx) {
                    x = vx;
                    moved = true;

                }
                if (y < vy) {
                    y = vy;
                    moved = true;

                }
                return moved ? [x, y] : false;

            };

        } (),
            adjustForConstraints: function(xy, parent, offsets) {
            return this.getConstrainToXY(parent || document, false, offsets, xy) || xy;

        },
        alignTo: function(element, position, offsets, animate) {
            var xy = this.getAlignToXY(element, position, offsets);
            this.setXY(xy, this.preanim(arguments, 3));
            return this;

        },
        anchorTo: function(el, alignment, offsets, animate, monitorScroll, callback) {
            var action = function() {
                this.alignTo(el, alignment, offsets, animate);
                Ext.callback(callback, this);

            };
            Ext.EventManager.onWindowResize(action, this);
            var tm = typeof monitorScroll;
            if (tm != 'undefined') {
                Ext.EventManager.on(window, 'scroll', action, this, 
                {
                    buffer: tm == 'number' ? monitorScroll: 50
                });

            }
            action.call(this);
            return this;

        },
        clearOpacity: function() {
            if (window.ActiveXObject) {
                if (typeof this.dom.style.filter == 'string' && (/alpha/i).test(this.dom.style.filter)) {
                    this.dom.style.filter = "";

                }

            } else {
                this.dom.style.opacity = "";
                this.dom.style["-moz-opacity"] = "";
                this.dom.style["-khtml-opacity"] = "";

            }
            return this;

        },
        hide: function(animate) {
            this.setVisible(false, this.preanim(arguments, 0));
            return this;

        },
        show: function(animate) {
            this.setVisible(true, this.preanim(arguments, 0));
            return this;

        },
        addUnits: function(size) {
            return Ext.Element.addUnits(size, this.defaultUnit);

        },
        update: function(html, loadScripts, callback) {
            if (typeof html == "undefined") {
                html = "";

            }
            if (loadScripts !== true) {
                this.dom.innerHTML = html;
                if (typeof callback == "function") {
                    callback();

                }
                return this;

            }
            var id = Ext.id();
            var dom = this.dom;

            html += '<span id="' + id + '"></span>';

            E.onAvailable(id, 
            function() {
                var hd = document.getElementsByTagName("head")[0];
                var re = /(?:<script([^>]*)?>)((\n|\r|.)*?)(?:<\/script>)/ig;
                var srcRe = /\ssrc=([\'\"])(.*?)\1/i;
                var typeRe = /\stype=([\'\"])(.*?)\1/i;

                var match;
                while (match = re.exec(html)) {
                    var attrs = match[1];
                    var srcMatch = attrs ? attrs.match(srcRe) : false;
                    if (srcMatch && srcMatch[2]) {
                        var s = document.createElement("script");
                        s.src = srcMatch[2];
                        var typeMatch = attrs.match(typeRe);
                        if (typeMatch && typeMatch[2]) {
                            s.type = typeMatch[2];

                        }
                        hd.appendChild(s);

                    } else if (match[2] && match[2].length > 0) {
                        if (window.execScript) {
                            window.execScript(match[2]);

                        } else {
                            window.eval(match[2]);

                        }

                    }

                }
                var el = document.getElementById(id);
                if (el) {
                    Ext.removeNode(el);
                }
                if (typeof callback == "function") {
                    callback();

                }

            });
            dom.innerHTML = html.replace(/(?:<script.*?>)((\n|\r|.)*?)(?:<\/script>)/ig, "");
            return this;

        },
        load: function() {
            var um = this.getUpdater();
            um.update.apply(um, arguments);
            return this;

        },
        getUpdater: function() {
            if (!this.updateManager) {
                this.updateManager = new Ext.Updater(this);

            }
            return this.updateManager;

        },
        unselectable: function() {
            this.dom.unselectable = "on";
            this.swallowEvent("selectstart", true);
            this.applyStyles("-moz-user-select:none;-khtml-user-select:none;");
            this.addClass("x-unselectable");
            return this;

        },
        getCenterXY: function() {
            return this.getAlignToXY(document, 'c-c');

        },
        center: function(centerIn) {
            this.alignTo(centerIn || document, 'c-c');
            return this;

        },
        isBorderBox: function() {
            return noBoxAdjust[this.dom.tagName.toLowerCase()] || Ext.isBorderBox;

        },
        getBox: function(contentBox, local) {
            var xy;
            if (!local) {
                xy = this.getXY();

            } else {
                var left = parseInt(this.getStyle("left"), 10) || 0;
                var top = parseInt(this.getStyle("top"), 10) || 0;
                xy = [left, top];

            }
            var el = this.dom,
            w = el.offsetWidth,
            h = el.offsetHeight,
            bx;
            if (!contentBox) {
                bx = {
                    x: xy[0],
                    y: xy[1],
                    0: xy[0],
                    1: xy[1],
                    width: w,
                    height: h
                };

            } else {
                var l = this.getBorderWidth("l") + this.getPadding("l");
                var r = this.getBorderWidth("r") + this.getPadding("r");
                var t = this.getBorderWidth("t") + this.getPadding("t");
                var b = this.getBorderWidth("b") + this.getPadding("b");
                bx = {
                    x: xy[0] + l,
                    y: xy[1] + t,
                    0: xy[0] + l,
                    1: xy[1] + t,
                    width: w - (l + r),
                    height: h - (t + b)
                };

            }
            bx.right = bx.x + bx.width;
            bx.bottom = bx.y + bx.height;
            return bx;

        },
        getFrameWidth: function(sides, onlyContentBox) {
            return onlyContentBox && Ext.isBorderBox ? 0: (this.getPadding(sides) + this.getBorderWidth(sides));

        },
        setBox: function(box, adjust, animate) {
            var w = box.width,
            h = box.height;
            if ((adjust && !this.autoBoxAdjust) && !this.isBorderBox()) {
                w -= (this.getBorderWidth("lr") + this.getPadding("lr"));
                h -= (this.getBorderWidth("tb") + this.getPadding("tb"));

            }
            this.setBounds(box.x, box.y, w, h, this.preanim(arguments, 2));
            return this;

        },
        repaint: function() {
            var dom = this.dom;
            this.addClass("x-repaint");
            setTimeout(function() {
                Ext.get(dom).removeClass("x-repaint");

            },
            1);
            return this;

        },
        getMargins: function(side) {
            if (!side) {
                return {
                    top: parseInt(this.getStyle("margin-top"), 10) || 0,
                    left: parseInt(this.getStyle("margin-left"), 10) || 0,
                    bottom: parseInt(this.getStyle("margin-bottom"), 10) || 0,
                    right: parseInt(this.getStyle("margin-right"), 10) || 0

                };

            } else {
                return this.addStyles(side, El.margins);

            }

        },
        addStyles: function(sides, styles) {
            var val = 0,
            v,
            w;
            for (var i = 0, len = sides.length; i < len; i++) {
                v = this.getStyle(styles[sides.charAt(i)]);
                if (v) {
                    w = parseInt(v, 10);
                    if (w) {
                        val += (w >= 0 ? w: -1 * w);
                    }

                }

            }
            return val;

        },
        createProxy: function(config, renderTo, matchBox) {
            config = typeof config == "object" ? 
            config: {
                tag: "div",
                cls: config
            };

            var proxy;
            if (renderTo) {
                proxy = Ext.DomHelper.append(renderTo, config, true);

            } else {
                proxy = Ext.DomHelper.insertBefore(this.dom, config, true);

            }
            if (matchBox) {
                proxy.setBox(this.getBox());

            }
            return proxy;

        },
        mask: function(msg, msgCls) {
            if (this.getStyle("position") == "static") {
                this.setStyle("position", "relative");

            }
            if (this._maskMsg) {
                this._maskMsg.remove();

            }
            if (this._mask) {
                this._mask.remove();

            }

            this._mask = Ext.DomHelper.append(this.dom, {
                cls: "ext-el-mask"
            },
            true);

            this.addClass("x-masked");
            this._mask.setDisplayed(true);
            if (typeof msg == 'string') {
                this._maskMsg = Ext.DomHelper.append(this.dom, {
                    cls: "ext-el-mask-msg",
                    cn: {
                        tag: 'div'
                    }
                },
                true);
                var mm = this._maskMsg;
                mm.dom.className = msgCls ? "ext-el-mask-msg " + msgCls: "ext-el-mask-msg";
                mm.dom.firstChild.innerHTML = msg;
                mm.setDisplayed(true);
                mm.center(this);

            }
            if (Ext.isIE && !(Ext.isIE7 && Ext.isStrict) && this.getStyle('height') == 'auto') {
                this._mask.setSize(this.dom.clientWidth, this.getHeight());

            }
            return this._mask;

        },
        unmask: function() {
            if (this._mask) {
                if (this._maskMsg) {
                    this._maskMsg.remove();
                    delete this._maskMsg;

                }
                this._mask.remove();
                delete this._mask;

            }
            this.removeClass("x-masked");

        },
        isMasked: function() {
            return this._mask && this._mask.isVisible();

        },
        createShim: function() {
            var el = document.createElement('iframe');
            el.frameBorder = 'no';
            el.className = 'ext-shim';
            if (Ext.isIE && Ext.isSecure) {
                el.src = Ext.SSL_SECURE_URL;

            }
            var shim = Ext.get(this.dom.parentNode.insertBefore(el, this.dom));
            shim.autoBoxAdjust = false;
            return shim;

        },
        remove: function() {
            Ext.removeNode(this.dom);
            delete El.cache[this.dom.id];

        },
        hover: function(overFn, outFn, scope) {
            var preOverFn = function(e) {
                if (!e.within(this, true)) {
                    overFn.apply(scope || this, arguments);

                }

            };
            var preOutFn = function(e) {
                if (!e.within(this, true)) {
                    outFn.apply(scope || this, arguments);

                }

            };
            this.on("mouseover", preOverFn, this.dom);
            this.on("mouseout", preOutFn, this.dom);
            return this;

        },
        addClassOnOver: function(className) {
            this.hover(
            function() {
                Ext.fly(this, '_internal').addClass(className);

            },
            function() {
                Ext.fly(this, '_internal').removeClass(className);

            }
            );
            return this;

        },
        addClassOnFocus: function(className) {
            this.on("focus", 
            function() {
                Ext.fly(this, '_internal').addClass(className);

            },
            this.dom);
            this.on("blur", 
            function() {
                Ext.fly(this, '_internal').removeClass(className);

            },
            this.dom);
            return this;

        },
        addClassOnClick: function(className) {
            var dom = this.dom;
            this.on("mousedown", 
            function() {
                Ext.fly(dom, '_internal').addClass(className);
                var d = Ext.getDoc();
                var fn = function() {
                    Ext.fly(dom, '_internal').removeClass(className);
                    d.removeListener("mouseup", fn);

                };
                d.on("mouseup", fn);

            });
            return this;

        },
        swallowEvent: function(eventName, preventDefault) {
            var fn = function(e) {
                e.stopPropagation();
                if (preventDefault) {
                    e.preventDefault();

                }

            };
            if (Ext.isArray(eventName)) {
                for (var i = 0, len = eventName.length; i < len; i++) {
                    this.on(eventName[i], fn);

                }
                return this;

            }
            this.on(eventName, fn);
            return this;

        },
        parent: function(selector, returnDom) {
            return this.matchNode('parentNode', 'parentNode', selector, returnDom);

        },
        next: function(selector, returnDom) {
            return this.matchNode('nextSibling', 'nextSibling', selector, returnDom);

        },
        prev: function(selector, returnDom) {
            return this.matchNode('previousSibling', 'previousSibling', selector, returnDom);

        },
        
first: function(selector, returnDom) {
            return this.matchNode('nextSibling', 'firstChild', selector, returnDom);

        },
        last: function(selector, returnDom) {
            return this.matchNode('previousSibling', 'lastChild', selector, returnDom);

        },
        matchNode: function(dir, start, selector, returnDom) {
            var n = this.dom[start];
            while (n) {
                if (n.nodeType == 1 && (!selector || Ext.DomQuery.is(n, selector))) {
                    return ! returnDom ? Ext.get(n) : n;

                }
                n = n[dir];

            }
            return null;

        },
        appendChild: function(el) {
            el = Ext.get(el);
            el.appendTo(this);
            return this;

        },
        createChild: function(config, insertBefore, returnDom) {
            config = config || {
                tag: 'div'
            };
            if (insertBefore) {
                return Ext.DomHelper.insertBefore(insertBefore, config, returnDom !== true);

            }
            return Ext.DomHelper[!this.dom.firstChild ? 'overwrite': 'append'](this.dom, config, returnDom !== true);

        },
        appendTo: function(el) {
            el = Ext.getDom(el);
            el.appendChild(this.dom);
            return this;

        },
        insertBefore: function(el) {
            el = Ext.getDom(el);
            el.parentNode.insertBefore(this.dom, el);
            return this;

        },
        insertAfter: function(el) {
            el = Ext.getDom(el);
            el.parentNode.insertBefore(this.dom, el.nextSibling);
            return this;

        },
        insertFirst: function(el, returnDom) {
            el = el || {};
            if (typeof el == 'object' && !el.nodeType && !el.dom) {
                return this.createChild(el, this.dom.firstChild, returnDom);

            } else {
                el = Ext.getDom(el);
                this.dom.insertBefore(el, this.dom.firstChild);
                return ! returnDom ? Ext.get(el) : el;

            }

        },
        insertSibling: function(el, where, returnDom) {
            var rt;
            if (Ext.isArray(el)) {
                for (var i = 0, len = el.length; i < len; i++) {
                    rt = this.insertSibling(el[i], where, returnDom);

                }
                return rt;

            }
            where = where ? where.toLowerCase() : 'before';
            el = el || {};
            var refNode = where == 'before' ? this.dom: this.dom.nextSibling;

            if (typeof el == 'object' && !el.nodeType && !el.dom) {
                if (where == 'after' && !this.dom.nextSibling) {
                    rt = Ext.DomHelper.append(this.dom.parentNode, el, !returnDom);

                } else {
                    rt = Ext.DomHelper[where == 'after' ? 'insertAfter': 'insertBefore'](this.dom, el, !returnDom);

                }


            } else {
                rt = this.dom.parentNode.insertBefore(Ext.getDom(el), refNode);
                if (!returnDom) {
                    rt = Ext.get(rt);

                }

            }
            return rt;

        },
        wrap: function(config, returnDom) {
            if (!config) {
                config = {
                    tag: "div"
                };

            }
            var newEl = Ext.DomHelper.insertBefore(this.dom, config, !returnDom);
            newEl.dom ? newEl.dom.appendChild(this.dom) : newEl.appendChild(this.dom);
            return newEl;

        },
        replace: function(el) {
            el = Ext.get(el);
            this.insertBefore(el);
            el.remove();
            return this;

        },
        replaceWith: function(el) {
            if (typeof el == 'object' && !el.nodeType && !el.dom) {
                el = this.insertSibling(el, 'before');

            } else {
                el = Ext.getDom(el);
                this.dom.parentNode.insertBefore(el, this.dom);

            }
            El.uncache(this.id);
            this.dom.parentNode.removeChild(this.dom);
            this.dom = el;
            this.id = Ext.id(el);
            El.cache[this.id] = this;
            return this;

        },
        insertHtml: function(where, html, returnEl) {
            var el = Ext.DomHelper.insertHtml(where, this.dom, html);
            return returnEl ? Ext.get(el) : el;

        },
        set: function(o, useSet) {
            var el = this.dom;
            useSet = typeof useSet == 'undefined' ? (el.setAttribute ? true: false) : useSet;
            for (var attr in o) {
                if (attr == "style" || typeof o[attr] == "function") continue;
                if (attr == "cls") {
                    el.className = o["cls"];

                } else if (o.hasOwnProperty(attr)) {
                    if (useSet) el.setAttribute(attr, o[attr]);
                    else el[attr] = o[attr];

                }

            }
            if (o.style) {
                Ext.DomHelper.applyStyles(el, o.style);

            }
            return this;

        },
        addKeyListener: function(key, fn, scope) {
            var config;
            if (typeof key != "object" || Ext.isArray(key)) {
                config = {
                    key: key,
                    fn: fn,
                    scope: scope

                };

            } else {
                config = {
                    key: key.key,
                    shift: key.shift,
                    ctrl: key.ctrl,
                    alt: key.alt,
                    fn: fn,
                    scope: scope

                };

            }
            return new Ext.KeyMap(this, config);

        },
        addKeyMap: function(config) {
            return new Ext.KeyMap(this, config);

        },
        isScrollable: function() {
            var dom = this.dom;
            return dom.scrollHeight > dom.clientHeight || dom.scrollWidth > dom.clientWidth;

        },
        scrollTo: function(side, value, animate) {
            var prop = side.toLowerCase() == "left" ? "scrollLeft": "scrollTop";
            if (!animate || !A) {
                this.dom[prop] = value;

            } else {
                var to = prop == "scrollLeft" ? [value, this.dom.scrollTop] : [this.dom.scrollLeft, value];
                this.anim({
                    scroll: {
                        "to": to
                    }
                },
                this.preanim(arguments, 2), 'scroll');

            }
            return this;

        },
        scroll: function(direction, distance, animate) {
            if (!this.isScrollable()) {
                return;

            }
            var el = this.dom;
            var l = el.scrollLeft,
            t = el.scrollTop;
            var w = el.scrollWidth,
            h = el.scrollHeight;
            var cw = el.clientWidth,
            ch = el.clientHeight;
            direction = direction.toLowerCase();
            var scrolled = false;
            var a = this.preanim(arguments, 2);
            switch (direction) {
                case "l":
            case "left":
                if (w - l > cw) {
                    var v = Math.min(l + distance, w - cw);
                    this.scrollTo("left", v, a);
                    scrolled = true;

                }
                break;
                case "r":
            case "right":
                if (l > 0) {
                    var v = Math.max(l - distance, 0);
                    this.scrollTo("left", v, a);
                    scrolled = true;

                }
                break;
                case "t":
            case "top":
            case "up":
                if (t > 0) {
                    var v = Math.max(t - distance, 0);
                    this.scrollTo("top", v, a);
                    scrolled = true;

                }
                break;
                case "b":
            case "bottom":
            case "down":
                if (h - t > ch) {
                    var v = Math.min(t + distance, h - ch);
                    this.scrollTo("top", v, a);
                    scrolled = true;

                }
                break;

            }
            return scrolled;

        },
        translatePoints: function(x, y) {
            if (typeof x == 'object' || Ext.isArray(x)) {
                y = x[1];
                x = x[0];

            }
            var p = this.getStyle('position');
            var o = this.getXY();

            var l = parseInt(this.getStyle('left'), 10);
            var t = parseInt(this.getStyle('top'), 10);

            if (isNaN(l)) {
                l = (p == "relative") ? 0: this.dom.offsetLeft;

            }
            if (isNaN(t)) {
                t = (p == "relative") ? 0: this.dom.offsetTop;

            }

            return {
                left: (x - o[0] + l),
                top: (y - o[1] + t)
            };

        },
        getScroll: function() {
            var d = this.dom,
            doc = document;
            if (d == doc || d == doc.body) {
                var l,
                t;
                if (Ext.isIE && Ext.isStrict) {
                    l = doc.documentElement.scrollLeft || (doc.body.scrollLeft || 0);
                    t = doc.documentElement.scrollTop || (doc.body.scrollTop || 0);

                } else {
                    l = window.pageXOffset || (doc.body.scrollLeft || 0);
                    t = window.pageYOffset || (doc.body.scrollTop || 0);

                }
                return {
                    left: l,
                    top: t
                };

            } else {
                return {
                    left: d.scrollLeft,
                    top: d.scrollTop
                };

            }

        },
        getColor: function(attr, defaultValue, prefix) {
            var v = this.getStyle(attr);
            if (!v || v == "transparent" || v == "inherit") {
                return defaultValue;

            }
            var color = typeof prefix == "undefined" ? "#": prefix;
            if (v.substr(0, 4) == "rgb(") {
                var rvs = v.slice(4, v.length - 1).split(",");
                for (var i = 0; i < 3; i++) {
                    var h = parseInt(rvs[i]);
                    var s = h.toString(16);
                    if (h < 16) {
                        s = "0" + s;

                    }
                    color += s;

                }

            } else {
                if (v.substr(0, 1) == "#") {
                    if (v.length == 4) {
                        for (var i = 1; i < 4; i++) {
                            var c = v.charAt(i);
                            color += c + c;

                        }

                    } else if (v.length == 7) {
                        color += v.substr(1);

                    }

                }

            }
            return (color.length > 5 ? color.toLowerCase() : defaultValue);

        },
        boxWrap: function(cls) {
            cls = cls || 'x-box';
            var el = Ext.get(this.insertHtml('beforeBegin', String.format('<div class="{0}">' + El.boxMarkup + '</div>', cls)));
            el.child('.' + cls + '-mc').dom.appendChild(this.dom);
            return el;

        },
        getAttributeNS: Ext.isIE ? 
        function(ns, name) {
            var d = this.dom;
            var type = typeof d[ns + ":" + name];
            if (type != 'undefined' && type != 'unknown') {
                return d[ns + ":" + name];

            }
            return d[name];

        }: function(ns, name) {
            var d = this.dom;
            return d.getAttributeNS(ns, name) || d.getAttribute(ns + ":" + name) || d.getAttribute(name) || d[name];

        },
        getTextWidth: function(text, min, max) {
            return (Ext.util.TextMetrics.measure(this.dom, Ext.value(text, this.dom.innerHTML, true)).width).constrain(min || 0, max || 1000000);

        }

    };

    var ep = El.prototype;


    ep.on = ep.addListener;
    ep.mon = ep.addListener;

    ep.getUpdateManager = ep.getUpdater;


    ep.un = ep.removeListener;


    ep.autoBoxAdjust = true;

    El.unitPattern = /\d+(px|em|%|en|ex|pt|in|cm|mm|pc)$/i;

    El.addUnits = function(v, defaultUnit) {
        if (v === "" || v == "auto") {
            return v;

        }
        if (v === undefined) {
            return '';

        }
        if (typeof v == "number" || !El.unitPattern.test(v)) {
            return v + (defaultUnit || 'px');

        }
        return v;

    };

    El.boxMarkup = '<div class="{0}-tl"><div class="{0}-tr"><div class="{0}-tc"></div></div></div><div class="{0}-ml"><div class="{0}-mr"><div class="{0}-mc"></div></div></div><div class="{0}-bl"><div class="{0}-br"><div class="{0}-bc"></div></div></div>';

    El.VISIBILITY = 1;

    El.DISPLAY = 2;

    El.borders = {
        l: "border-left-width",
        r: "border-right-width",
        t: "border-top-width",
        b: "border-bottom-width"
    };
    El.paddings = {
        l: "padding-left",
        r: "padding-right",
        t: "padding-top",
        b: "padding-bottom"
    };
    El.margins = {
        l: "margin-left",
        r: "margin-right",
        t: "margin-top",
        b: "margin-bottom"
    };




    El.cache = {};

    var docEl;


    El.get = function(el) {
        var ex,
        elm,
        id;
        if (!el) {
            return null;
        }
        if (typeof el == "string") {
            if (! (elm = document.getElementById(el))) {
                return null;

            }
            if (ex = El.cache[el]) {
                ex.dom = elm;

            } else {
                ex = El.cache[el] = new El(elm);

            }
            return ex;

        } else if (el.tagName) {
            if (! (id = el.id)) {
                id = Ext.id(el);

            }
            if (ex = El.cache[id]) {
                ex.dom = el;

            } else {
                ex = El.cache[id] = new El(el);

            }
            return ex;

        } else if (el instanceof El) {
            if (el != docEl) {
                el.dom = document.getElementById(el.id) || el.dom;
                El.cache[el.id] = el;
            }
            return el;

        } else if (el.isComposite) {
            return el;

        } else if (Ext.isArray(el)) {
            return El.select(el);

        } else if (el == document) {
            if (!docEl) {
                var f = function() {};
                f.prototype = El.prototype;
                docEl = new f();
                docEl.dom = document;

            }
            return docEl;

        }
        return null;

    };

    El.uncache = function(el) {
        for (var i = 0, a = arguments, len = a.length; i < len; i++) {
            if (a[i]) {
                delete El.cache[a[i].id || a[i]];

            }

        }

    };

    El.garbageCollect = function() {
        if (!Ext.enableGarbageCollector) {
            clearInterval(El.collectorThread);
            return;

        }
        for (var eid in El.cache) {
            var el = El.cache[eid],
            d = el.dom;
            if (!d || !d.parentNode || (!d.offsetParent && !document.getElementById(eid))) {
                delete El.cache[eid];
                if (d && Ext.enableListenerCollection) {
                    E.purgeElement(d);

                }

            }

        }

    }
    El.collectorThreadId = setInterval(El.garbageCollect, 30000);

    var flyFn = function() {};
    flyFn.prototype = El.prototype;
    var _cls = new flyFn();

    El.Flyweight = function(dom) {
        this.dom = dom;

    };

    El.Flyweight.prototype = _cls;
    El.Flyweight.prototype.isFlyweight = true;

    El._flyweights = {};

    El.fly = function(el, named) {
        named = named || '_global';
        el = Ext.getDom(el);
        if (!el) {
            return null;

        }
        if (!El._flyweights[named]) {
            El._flyweights[named] = new El.Flyweight();

        }
        El._flyweights[named].dom = el;
        return El._flyweights[named];

    };


    Ext.get = El.get;

    Ext.fly = El.fly;

    var noBoxAdjust = Ext.isStrict ? {
        select: 1

    }: {
        input: 1,
        select: 1,
        textarea: 1

    };
    if (Ext.isIE || Ext.isGecko) {
        noBoxAdjust['button'] = 1;

    }


    Ext.EventManager.on(window, 'unload', 
    function() {
        delete El.cache;
        delete El._flyweights;

    });

})();

Ext.enableFx = true;


Ext.Fx = {

    slideIn: function(anchor, o) {
        var el = this.getFxEl();
        o = o || {};

        el.queueFx(o, 
        function() {

            anchor = anchor || "t";

            this.fixDisplay();

            var r = this.getFxRestore();
            var b = this.getBox();
            this.setSize(b);

            var wrap = this.fxWrap(r.pos, o, "hidden");

            var st = this.dom.style;
            st.visibility = "visible";
            st.position = "absolute";

            var after = function() {
                el.fxUnwrap(wrap, r.pos, o);
                st.width = r.width;
                st.height = r.height;
                el.afterFx(o);

            };
            var a,
            pt = {
                to: [b.x, b.y]
            },
            bw = {
                to: b.width
            },
            bh = {
                to: b.height
            };

            switch (anchor.toLowerCase()) {
                case "t":
                wrap.setSize(b.width, 0);
                st.left = st.bottom = "0";
                a = {
                    height: bh
                };
                break;
                case "l":
                wrap.setSize(0, b.height);
                st.right = st.top = "0";
                a = {
                    width: bw
                };
                break;
                case "r":
                wrap.setSize(0, b.height);
                wrap.setX(b.right);
                st.left = st.top = "0";
                a = {
                    width: bw,
                    points: pt
                };
                break;
                case "b":
                wrap.setSize(b.width, 0);
                wrap.setY(b.bottom);
                st.left = st.top = "0";
                a = {
                    height: bh,
                    points: pt
                };
                break;
                case "tl":
                wrap.setSize(0, 0);
                st.right = st.bottom = "0";
                a = {
                    width: bw,
                    height: bh
                };
                break;
                case "bl":
                wrap.setSize(0, 0);
                wrap.setY(b.y + b.height);
                st.right = st.top = "0";
                a = {
                    width: bw,
                    height: bh,
                    points: pt
                };
                break;
                case "br":
                wrap.setSize(0, 0);
                wrap.setXY([b.right, b.bottom]);
                st.left = st.top = "0";
                a = {
                    width: bw,
                    height: bh,
                    points: pt
                };
                break;
                case "tr":
                wrap.setSize(0, 0);
                wrap.setX(b.x + b.width);
                st.left = st.bottom = "0";
                a = {
                    width: bw,
                    height: bh,
                    points: pt
                };
                break;

            }
            this.dom.style.visibility = "visible";
            wrap.show();

            arguments.callee.anim = wrap.fxanim(a, 
            o, 
            'motion', 
            .5, 
            'easeOut', after);

        });
        return this;

    },
    slideOut: function(anchor, o) {
        var el = this.getFxEl();
        o = o || {};

        el.queueFx(o, 
        function() {

            anchor = anchor || "t";

            var r = this.getFxRestore();

            var b = this.getBox();
            this.setSize(b);

            var wrap = this.fxWrap(r.pos, o, "visible");

            var st = this.dom.style;
            st.visibility = "visible";
            st.position = "absolute";

            wrap.setSize(b);

            var after = function() {
                if (o.useDisplay) {
                    el.setDisplayed(false);

                } else {
                    el.hide();

                }

                el.fxUnwrap(wrap, r.pos, o);

                st.width = r.width;
                st.height = r.height;

                el.afterFx(o);

            };

            var a,
            zero = {
                to: 0
            };
            switch (anchor.toLowerCase()) {
                case "t":
                st.left = st.bottom = "0";
                a = {
                    height: zero
                };
                break;
                case "l":
                st.right = st.top = "0";
                a = {
                    width: zero
                };
                break;
                case "r":
                st.left = st.top = "0";
                a = {
                    width: zero,
                    points: {
                        to: [b.right, b.y]
                    }
                };
                break;
                case "b":
                st.left = st.top = "0";
                a = {
                    height: zero,
                    points: {
                        to: [b.x, b.bottom]
                    }
                };
                break;
                case "tl":
                st.right = st.bottom = "0";
                a = {
                    width: zero,
                    height: zero
                };
                break;
                case "bl":
                st.right = st.top = "0";
                a = {
                    width: zero,
                    height: zero,
                    points: {
                        to: [b.x, b.bottom]
                    }
                };
                break;
                case "br":
                st.left = st.top = "0";
                a = {
                    width: zero,
                    height: zero,
                    points: {
                        to: [b.x + b.width, b.bottom]
                    }
                };
                break;
                case "tr":
                st.left = st.bottom = "0";
                a = {
                    width: zero,
                    height: zero,
                    points: {
                        to: [b.right, b.y]
                    }
                };
                break;

            }

            arguments.callee.anim = wrap.fxanim(a, 
            o, 
            'motion', 
            .5, 
            "easeOut", after);

        });
        return this;

    },
    puff: function(o) {
        var el = this.getFxEl();
        o = o || {};

        el.queueFx(o, 
        function() {
            this.clearOpacity();
            this.show();

            var r = this.getFxRestore();
            var st = this.dom.style;

            var after = function() {
                if (o.useDisplay) {
                    el.setDisplayed(false);

                } else {
                    el.hide();

                }

                el.clearOpacity();

                el.setPositioning(r.pos);
                st.width = r.width;
                st.height = r.height;
                st.fontSize = '';
                el.afterFx(o);

            };

            var width = this.getWidth();
            var height = this.getHeight();

            arguments.callee.anim = this.fxanim({
                width: {
                    to: this.adjustWidth(width * 2)
                },
                height: {
                    to: this.adjustHeight(height * 2)
                },
                points: {
                    by: [ - (width * .5), -(height * .5)]
                },
                opacity: {
                    to: 0
                },
                fontSize: {
                    to: 200,
                    unit: "%"
                }

            },
            o, 
            'motion', 
            .5, 
            "easeOut", after);

        });
        return this;

    },
    switchOff: function(o) {
        var el = this.getFxEl();
        o = o || {};

        el.queueFx(o, 
        function() {
            this.clearOpacity();
            this.clip();

            var r = this.getFxRestore();
            var st = this.dom.style;

            var after = function() {
                if (o.useDisplay) {
                    el.setDisplayed(false);

                } else {
                    el.hide();

                }

                el.clearOpacity();
                el.setPositioning(r.pos);
                st.width = r.width;
                st.height = r.height;

                el.afterFx(o);

            };

            this.fxanim({
                opacity: {
                    to: 0.3
                }
            },
            null, null, .1, null, 
            function() {
                this.clearOpacity();
                (function() {
                    this.fxanim({
                        height: {
                            to: 1
                        },
                        points: {
                            by: [0, this.getHeight() * .5]
                        }

                    },
                    o, 'motion', 0.3, 'easeIn', after);

                }).defer(100, this);

            });

        });
        return this;

    },
    highlight: function(color, o) {
        var el = this.getFxEl();
        o = o || {};

        el.queueFx(o, 
        function() {
            color = color || "ffff9c";
            var attr = o.attr || "backgroundColor";

            this.clearOpacity();
            this.show();

            var origColor = this.getColor(attr);
            var restoreColor = this.dom.style[attr];
            var endColor = (o.endColor || origColor) || "ffffff";

            var after = function() {
                el.dom.style[attr] = restoreColor;
                el.afterFx(o);

            };

            var a = {};
            a[attr] = {
                from: color,
                to: endColor
            };
            arguments.callee.anim = this.fxanim(a, 
            o, 
            'color', 
            1, 
            'easeIn', after);

        });
        return this;

    },
    frame: function(color, count, o) {
        var el = this.getFxEl();
        o = o || {};

        el.queueFx(o, 
        function() {
            color = color || "#C3DAF9";
            if (color.length == 6) {
                color = "#" + color;

            }
            count = count || 1;
            var duration = o.duration || 1;
            this.show();

            var b = this.getBox();
            var animFn = function() {
                var proxy = Ext.getBody().createChild({
                    style: {
                        visbility: "hidden",
                        position: "absolute",
                        "z-index": "35000",
                        border: "0px solid " + color

                    }

                });
                var scale = Ext.isBorderBox ? 2: 1;
                proxy.animate({
                    top: {
                        from: b.y,
                        to: b.y - 20
                    },
                    left: {
                        from: b.x,
                        to: b.x - 20
                    },
                    borderWidth: {
                        from: 0,
                        to: 10
                    },
                    opacity: {
                        from: 1,
                        to: 0
                    },
                    height: {
                        from: b.height,
                        to: (b.height + (20 * scale))
                    },
                    width: {
                        from: b.width,
                        to: (b.width + (20 * scale))
                    }

                },
                duration, 
                function() {
                    proxy.remove();
                    if (--count > 0) {
                        animFn();

                    } else {
                        el.afterFx(o);

                    }

                });

            };
            animFn.call(this);

        });
        return this;

    },
    pause: function(seconds) {
        var el = this.getFxEl();
        var o = {};

        el.queueFx(o, 
        function() {
            setTimeout(function() {
                el.afterFx(o);

            },
            seconds * 1000);

        });
        return this;

    },
    fadeIn: function(o) {
        var el = this.getFxEl();
        o = o || {};
        el.queueFx(o, 
        function() {
            this.setOpacity(0);
            this.fixDisplay();
            this.dom.style.visibility = 'visible';
            var to = o.endOpacity || 1;
            arguments.callee.anim = this.fxanim({
                opacity: {
                    to: to
                }
            },
            o, null, .5, "easeOut", 
            function() {
                if (to == 1) {
                    this.clearOpacity();

                }
                el.afterFx(o);

            });

        });
        return this;

    },
    fadeOut: function(o) {
        var el = this.getFxEl();
        o = o || {};
        el.queueFx(o, 
        function() {
            arguments.callee.anim = this.fxanim({
                opacity: {
                    to: o.endOpacity || 0
                }
            },
            o, null, .5, "easeOut", 
            function() {
                if (this.visibilityMode == Ext.Element.DISPLAY || o.useDisplay) {
                    this.dom.style.display = "none";

                } else {
                    this.dom.style.visibility = "hidden";

                }
                this.clearOpacity();
                el.afterFx(o);

            });

        });
        return this;

    },
    scale: function(w, h, o) {
        this.shift(Ext.apply({},
        o, {
            width: w,
            height: h

        }));
        return this;

    },
    shift: function(o) {
        var el = this.getFxEl();
        o = o || {};
        el.queueFx(o, 
        function() {
            var a = {},
            w = o.width,
            h = o.height,
            x = o.x,
            y = o.y,
            op = o.opacity;
            if (w !== undefined) {
                a.width = {
                    to: this.adjustWidth(w)
                };

            }
            if (h !== undefined) {
                a.height = {
                    to: this.adjustHeight(h)
                };

            }
            if (o.left !== undefined) {
                a.left = {
                    to: o.left
                };

            }
            if (o.top !== undefined) {
                a.top = {
                    to: o.top
                };

            }
            if (o.right !== undefined) {
                a.right = {
                    to: o.right
                };

            }
            if (o.bottom !== undefined) {
                a.bottom = {
                    to: o.bottom
                };

            }
            if (x !== undefined || y !== undefined) {
                a.points = {
                    to: [
                    x !== undefined ? x: this.getX(), 
                    y !== undefined ? y: this.getY()
                    ]
                };

            }
            if (op !== undefined) {
                a.opacity = {
                    to: op
                };

            }
            if (o.xy !== undefined) {
                a.points = {
                    to: o.xy
                };

            }
            arguments.callee.anim = this.fxanim(a, 
            o, 'motion', .35, "easeOut", 
            function() {
                el.afterFx(o);

            });

        });
        return this;

    },
    ghost: function(anchor, o) {
        var el = this.getFxEl();
        o = o || {};

        el.queueFx(o, 
        function() {
            anchor = anchor || "b";

            var r = this.getFxRestore();
            var w = this.getWidth(),
            h = this.getHeight();

            var st = this.dom.style;

            var after = function() {
                if (o.useDisplay) {
                    el.setDisplayed(false);

                } else {
                    el.hide();

                }

                el.clearOpacity();
                el.setPositioning(r.pos);
                st.width = r.width;
                st.height = r.height;

                el.afterFx(o);

            };

            var a = {
                opacity: {
                    to: 0
                },
                points: {}
            },
            pt = a.points;
            switch (anchor.toLowerCase()) {
                case "t":
                pt.by = [0, -h];
                break;
                case "l":
                pt.by = [ - w, 0];
                break;
                case "r":
                pt.by = [w, 0];
                break;
                case "b":
                pt.by = [0, h];
                break;
                case "tl":
                pt.by = [ - w, -h];
                break;
                case "bl":
                pt.by = [ - w, h];
                break;
                case "br":
                pt.by = [w, h];
                break;
                case "tr":
                pt.by = [w, -h];
                break;

            }

            arguments.callee.anim = this.fxanim(a, 
            o, 
            'motion', 
            .5, 
            "easeOut", after);

        });
        return this;

    },
    syncFx: function() {
        this.fxDefaults = Ext.apply(this.fxDefaults || {},
        {
            block: false,
            concurrent: true,
            stopFx: false

        });
        return this;

    },
    sequenceFx: function() {
        this.fxDefaults = Ext.apply(this.fxDefaults || {},
        {
            block: false,
            concurrent: false,
            stopFx: false

        });
        return this;

    },
    nextFx: function() {
        var ef = this.fxQueue[0];
        if (ef) {
            ef.call(this);

        }

    },
    hasActiveFx: function() {
        return this.fxQueue && this.fxQueue[0];

    },
    stopFx: function() {
        if (this.hasActiveFx()) {
            var cur = this.fxQueue[0];
            if (cur && cur.anim && cur.anim.isAnimated()) {
                this.fxQueue = [cur];
                cur.anim.stop(true);

            }

        }
        return this;

    },
    beforeFx: function(o) {
        if (this.hasActiveFx() && !o.concurrent) {
            if (o.stopFx) {
                this.stopFx();
                return true;

            }
            return false;

        }
        return true;

    },
    hasFxBlock: function() {
        var q = this.fxQueue;
        return q && q[0] && q[0].block;

    },
    queueFx: function(o, fn) {
        if (!this.fxQueue) {
            this.fxQueue = [];

        }
        if (!this.hasFxBlock()) {
            Ext.applyIf(o, this.fxDefaults);
            if (!o.concurrent) {
                var run = this.beforeFx(o);
                fn.block = o.block;
                this.fxQueue.push(fn);
                if (run) {
                    this.nextFx();

                }

            } else {
                fn.call(this);

            }

        }
        return this;

    },
    fxWrap: function(pos, o, vis) {
        var wrap;
        if (!o.wrap || !(wrap = Ext.get(o.wrap))) {
            var wrapXY;
            if (o.fixPosition) {
                wrapXY = this.getXY();

            }
            var div = document.createElement("div");
            div.style.visibility = vis;
            wrap = Ext.get(this.dom.parentNode.insertBefore(div, this.dom));
            wrap.setPositioning(pos);
            if (wrap.getStyle("position") == "static") {
                wrap.position("relative");

            }
            this.clearPositioning('auto');
            wrap.clip();
            wrap.dom.appendChild(this.dom);
            if (wrapXY) {
                wrap.setXY(wrapXY);

            }

        }
        return wrap;

    },
    fxUnwrap: function(wrap, pos, o) {
        this.clearPositioning();
        this.setPositioning(pos);
        if (!o.wrap) {
            wrap.dom.parentNode.insertBefore(this.dom, wrap.dom);
            wrap.remove();

        }

    },
    getFxRestore: function() {
        var st = this.dom.style;
        return {
            pos: this.getPositioning(),
            width: st.width,
            height: st.height
        };

    },
    afterFx: function(o) {
        if (o.afterStyle) {
            this.applyStyles(o.afterStyle);

        }
        if (o.afterCls) {
            this.addClass(o.afterCls);

        }
        if (o.remove === true) {
            this.remove();

        }
        Ext.callback(o.callback, o.scope, [this]);
        if (!o.concurrent) {
            this.fxQueue.shift();
            this.nextFx();

        }

    },
    getFxEl: function() {
        return Ext.get(this.dom);

    },
    fxanim: function(args, opt, animType, defaultDur, defaultEase, cb) {
        animType = animType || 'run';
        opt = opt || {};
        var anim = Ext.lib.Anim[animType](
        this.dom, args, 
        (opt.duration || defaultDur) || .35, 
        (opt.easing || defaultEase) || 'easeOut', 
        function() {
            Ext.callback(cb, this);

        },
        this
        );
        opt.anim = anim;
        return anim;

    }

};

Ext.Fx.resize = Ext.Fx.scale;

Ext.apply(Ext.Element.prototype, Ext.Fx);


Ext.CompositeElement = function(els) {
    this.elements = [];
    this.addElements(els);

};
Ext.CompositeElement.prototype = {
    isComposite: true,
    addElements: function(els) {
        if (!els) return this;
        if (typeof els == "string") {
            els = Ext.Element.selectorFunction(els);

        }
        var yels = this.elements;
        var index = yels.length - 1;
        for (var i = 0, len = els.length; i < len; i++) {
            yels[++index] = Ext.get(els[i]);

        }
        return this;

    },
    fill: function(els) {
        this.elements = [];
        this.add(els);
        return this;

    },
    filter: function(selector) {
        var els = [];
        this.each(function(el) {
            if (el.is(selector)) {
                els[els.length] = el.dom;

            }

        });
        this.fill(els);
        return this;

    },
    invoke: function(fn, args) {
        var els = this.elements;
        for (var i = 0, len = els.length; i < len; i++) {
            Ext.Element.prototype[fn].apply(els[i], args);

        }
        return this;

    },
    add: function(els) {
        if (typeof els == "string") {
            this.addElements(Ext.Element.selectorFunction(els));

        } else if (els.length !== undefined) {
            this.addElements(els);

        } else {
            this.addElements([els]);

        }
        return this;

    },
    each: function(fn, scope) {
        var els = this.elements;
        for (var i = 0, len = els.length; i < len; i++) {
            if (fn.call(scope || els[i], els[i], this, i) === false) {
                break;

            }

        }
        return this;

    },
    item: function(index) {
        return this.elements[index] || null;

    },
    first: function() {
        return this.item(0);

    },
    last: function() {
        return this.item(this.elements.length - 1);

    },
    getCount: function() {
        return this.elements.length;

    },
    contains: function(el) {
        return this.indexOf(el) !== -1;

    },
    indexOf: function(el) {
        return this.elements.indexOf(Ext.get(el));

    },
    
removeElement: function(el, removeDom) {
        if (Ext.isArray(el)) {
            for (var i = 0, len = el.length; i < len; i++) {
                this.removeElement(el[i]);

            }
            return this;

        }
        var index = typeof el == 'number' ? el: this.indexOf(el);
        if (index !== -1 && this.elements[index]) {
            if (removeDom) {
                var d = this.elements[index];
                if (d.dom) {
                    d.remove();

                } else {
                    Ext.removeNode(d);

                }

            }
            this.elements.splice(index, 1);

        }
        return this;

    },
    replaceElement: function(el, replacement, domReplace) {
        var index = typeof el == 'number' ? el: this.indexOf(el);
        if (index !== -1) {
            if (domReplace) {
                this.elements[index].replaceWith(replacement);

            } else {
                this.elements.splice(index, 1, Ext.get(replacement))

            }

        }
        return this;

    },
    clear: function() {
        this.elements = [];

    }

};
 (function() {
    Ext.CompositeElement.createCall = function(proto, fnName) {
        if (!proto[fnName]) {
            proto[fnName] = function() {
                return this.invoke(fnName, arguments);

            };

        }

    };
    for (var fnName in Ext.Element.prototype) {
        if (typeof Ext.Element.prototype[fnName] == "function") {
            Ext.CompositeElement.createCall(Ext.CompositeElement.prototype, fnName);

        }

    };

})();


Ext.CompositeElementLite = function(els) {
    Ext.CompositeElementLite.superclass.constructor.call(this, els);
    this.el = new Ext.Element.Flyweight();

};
Ext.extend(Ext.CompositeElementLite, Ext.CompositeElement, {
    addElements: function(els) {
        if (els) {
            if (Ext.isArray(els)) {
                this.elements = this.elements.concat(els);

            } else {
                var yels = this.elements;
                var index = yels.length - 1;
                for (var i = 0, len = els.length; i < len; i++) {
                    yels[++index] = els[i];

                }

            }

        }
        return this;

    },
    invoke: function(fn, args) {
        var els = this.elements;
        var el = this.el;
        for (var i = 0, len = els.length; i < len; i++) {
            el.dom = els[i];
            Ext.Element.prototype[fn].apply(el, args);

        }
        return this;

    },
    item: function(index) {
        if (!this.elements[index]) {
            return null;

        }
        this.el.dom = this.elements[index];
        return this.el;

    },
    addListener: function(eventName, handler, scope, opt) {
        var els = this.elements;
        for (var i = 0, len = els.length; i < len; i++) {
            Ext.EventManager.on(els[i], eventName, handler, scope || els[i], opt);

        }
        return this;

    },
    each: function(fn, scope) {
        var els = this.elements;
        var el = this.el;
        for (var i = 0, len = els.length; i < len; i++) {
            el.dom = els[i];
            if (fn.call(scope || el, el, this, i) === false) {
                break;

            }

        }
        return this;

    },
    indexOf: function(el) {
        return this.elements.indexOf(Ext.getDom(el));

    },
    replaceElement: function(el, replacement, domReplace) {
        var index = typeof el == 'number' ? el: this.indexOf(el);
        if (index !== -1) {
            replacement = Ext.getDom(replacement);
            if (domReplace) {
                var d = this.elements[index];
                d.parentNode.insertBefore(replacement, d);
                Ext.removeNode(d);

            }
            this.elements.splice(index, 1, replacement);

        }
        return this;

    }

});
Ext.CompositeElementLite.prototype.on = Ext.CompositeElementLite.prototype.addListener;
if (Ext.DomQuery) {
    Ext.Element.selectorFunction = Ext.DomQuery.select;

}

Ext.Element.select = function(selector, unique, root) {
    var els;
    if (typeof selector == "string") {
        els = Ext.Element.selectorFunction(selector, root);

    } else if (selector.length !== undefined) {
        els = selector;

    } else {
        throw "Invalid selector";

    }
    if (unique === true) {
        return new Ext.CompositeElement(els);

    } else {
        return new Ext.CompositeElementLite(els);

    }

};

Ext.select = Ext.Element.select;

Ext.data.Connection = function(config) {
    Ext.apply(this, config);
    this.addEvents(

    "beforerequest", 

    "requestcomplete", 

    "requestexception"
    );
    Ext.data.Connection.superclass.constructor.call(this);

};

Ext.extend(Ext.data.Connection, Ext.util.Observable, {





    timeout: 30000,
    autoAbort: false,
    
disableCaching: true,
    
request: function(o) {
        if (this.fireEvent("beforerequest", this, o) !== false) {
            var p = o.params;

            if (typeof p == "function") {
                p = p.call(o.scope || window, o);

            }
            if (typeof p == "object") {
                p = Ext.urlEncode(p);

            }
            if (this.extraParams) {
                var extras = Ext.urlEncode(this.extraParams);
                p = p ? (p + '&' + extras) : extras;

            }

            var url = o.url || this.url;
            if (typeof url == 'function') {
                url = url.call(o.scope || window, o);

            }

            if (o.form) {
                var form = Ext.getDom(o.form);
                url = url || form.action;

                var enctype = form.getAttribute("enctype");
                if (o.isUpload || (enctype && enctype.toLowerCase() == 'multipart/form-data')) {
                    return this.doFormUpload(o, p, url);

                }
                var f = Ext.lib.Ajax.serializeForm(form);
                p = p ? (p + '&' + f) : f;

            }

            var hs = o.headers;
            if (this.defaultHeaders) {
                hs = Ext.apply(hs || {},
                this.defaultHeaders);
                if (!o.headers) {
                    o.headers = hs;

                }

            }

            var cb = {
                success: this.handleResponse,
                failure: this.handleFailure,
                scope: this,
                argument: {
                    options: o
                },
                timeout: o.timeout || this.timeout

            };

            var method = o.method || this.method || (p ? "POST": "GET");

            if (method == 'GET' && (this.disableCaching && o.disableCaching !== false) || o.disableCaching === true) {
                url += (url.indexOf('?') != -1 ? '&': '?') + '_dc=' + (new Date().getTime());

            }

            if (typeof o.autoAbort == 'boolean') {
                if (o.autoAbort) {
                    this.abort();

                }

            } else if (this.autoAbort !== false) {
                this.abort();

            }
            if ((method == 'GET' || o.xmlData || o.jsonData) && p) {
                url += (url.indexOf('?') != -1 ? '&': '?') + p;
                p = '';

            }
            this.transId = Ext.lib.Ajax.request(method, url, cb, p, o);
            return this.transId;

        } else {
            Ext.callback(o.callback, o.scope, [o, null, null]);
            return null;

        }

    },
    isLoading: function(transId) {
        if (transId) {
            return Ext.lib.Ajax.isCallInProgress(transId);

        } else {
            return this.transId ? true: false;

        }

    },
    abort: function(transId) {
        if (transId || this.isLoading()) {
            Ext.lib.Ajax.abort(transId || this.transId);

        }

    },
    handleResponse: function(response) {
        this.transId = false;
        var options = response.argument.options;
        response.argument = options ? options.argument: null;
        this.fireEvent("requestcomplete", this, response, options);
        Ext.callback(options.success, options.scope, [response, options]);
        Ext.callback(options.callback, options.scope, [options, true, response]);

    },
    handleFailure: function(response, e) {
        this.transId = false;
        var options = response.argument.options;
        response.argument = options ? options.argument: null;
        this.fireEvent("requestexception", this, response, options, e);
        Ext.callback(options.failure, options.scope, [response, options]);
        Ext.callback(options.callback, options.scope, [options, false, response]);

    },
    doFormUpload: function(o, ps, url) {
        var id = Ext.id();
        var frame = document.createElement('iframe');
        frame.id = id;
        frame.name = id;
        frame.className = 'x-hidden';
        if (Ext.isIE) {
            frame.src = Ext.SSL_SECURE_URL;

        }
        document.body.appendChild(frame);

        if (Ext.isIE) {
            document.frames[id].name = id;

        }

        var form = Ext.getDom(o.form);
        form.target = id;
        form.method = 'POST';
        form.enctype = form.encoding = 'multipart/form-data';
        if (url) {
            form.action = url;

        }

        var hiddens,
        hd;
        if (ps) {
            hiddens = [];
            ps = Ext.urlDecode(ps, false);
            for (var k in ps) {
                if (ps.hasOwnProperty(k)) {
                    hd = document.createElement('input');
                    hd.type = 'hidden';
                    hd.name = k;
                    hd.value = ps[k];
                    form.appendChild(hd);
                    hiddens.push(hd);

                }

            }

        }

        function cb() {
            var r = {
                responseText: '',
                responseXML: null

            };

            r.argument = o ? o.argument: null;

            try {
                var doc;
                if (Ext.isIE) {
                    doc = frame.contentWindow.document;

                } else {
                    doc = (frame.contentDocument || window.frames[id].document);

                }
                if (doc && doc.body) {
                    r.responseText = doc.body.innerHTML;

                }
                if (doc && doc.XMLDocument) {
                    r.responseXML = doc.XMLDocument;

                } else {
                    r.responseXML = doc;

                }

            }
            catch(e) {
                }

            Ext.EventManager.removeListener(frame, 'load', cb, this);

            this.fireEvent("requestcomplete", this, r, o);

            Ext.callback(o.success, o.scope, [r, o]);
            Ext.callback(o.callback, o.scope, [o, true, r]);

            setTimeout(function() {
                Ext.removeNode(frame);
            },
            100);

        }

        Ext.EventManager.on(frame, 'load', cb, this);
        form.submit();

        if (hiddens) {
            for (var i = 0, len = hiddens.length; i < len; i++) {
                Ext.removeNode(hiddens[i]);

            }

        }

    }

});


Ext.Ajax = new Ext.data.Connection({

















    autoAbort: false,
                serializeForm: function(form) {
        return Ext.lib.Ajax.serializeForm(form);

    }

});

Ext.Updater = function(el, forceNew) {
    el = Ext.get(el);
    if (!forceNew && el.updateManager) {
        return el.updateManager;

    }

    this.el = el;

    this.defaultUrl = null;

    this.addEvents(

    "beforeupdate", 

    "update", 

    "failure"
    );
    var d = Ext.Updater.defaults;

    this.sslBlankUrl = d.sslBlankUrl;

    this.disableCaching = d.disableCaching;

    this.indicatorText = d.indicatorText;

    this.showLoadIndicator = d.showLoadIndicator;

    this.timeout = d.timeout;

    this.loadScripts = d.loadScripts;

    this.transaction = null;

    this.refreshDelegate = this.refresh.createDelegate(this);

    this.updateDelegate = this.update.createDelegate(this);

    this.formUpdateDelegate = this.formUpdate.createDelegate(this);

    if (!this.renderer) {

        this.renderer = new Ext.Updater.BasicRenderer();

    }
    Ext.Updater.superclass.constructor.call(this);

};

Ext.extend(Ext.Updater, Ext.util.Observable, {

    getEl: function() {
        return this.el;

    },
    update: function(url, params, callback, discardUrl) {
        if (this.fireEvent("beforeupdate", this.el, url, params) !== false) {
            var cfg,
            callerScope;
            if (typeof url == "object") {
                cfg = url;
                url = cfg.url;
                params = params || cfg.params;
                callback = callback || cfg.callback;
                discardUrl = discardUrl || cfg.discardUrl;
                callerScope = cfg.scope;
                if (typeof cfg.nocache != "undefined") {
                    this.disableCaching = cfg.nocache;
                };
                if (typeof cfg.text != "undefined") {
                    this.indicatorText = '<div class="loading-indicator">' + cfg.text + "</div>";
                };
                if (typeof cfg.scripts != "undefined") {
                    this.loadScripts = cfg.scripts;
                };
                if (typeof cfg.timeout != "undefined") {
                    this.timeout = cfg.timeout;
                };

            }
            this.showLoading();

            if (!discardUrl) {
                this.defaultUrl = url;

            }
            if (typeof url == "function") {
                url = url.call(this);

            }

            var o = Ext.apply(cfg || {},
            {
                url: url,
                params: (typeof params == "function" && callerScope) ? params.createDelegate(callerScope) : params,
                success: this.processSuccess,
                failure: this.processFailure,
                scope: this,
                callback: undefined,
                timeout: (this.timeout * 1000),
                disableCaching: this.disableCaching,
                argument: {
                    "options": cfg,
                    "url": url,
                    "form": null,
                    "callback": callback,
                    "scope": callerScope || window,
                    "params": params

                }

            });

            this.transaction = Ext.Ajax.request(o);

        }

    },
    formUpdate: function(form, url, reset, callback) {
        if (this.fireEvent("beforeupdate", this.el, form, url) !== false) {
            if (typeof url == "function") {
                url = url.call(this);

            }
            form = Ext.getDom(form)
            this.transaction = Ext.Ajax.request({
                form: form,
                url: url,
                success: this.processSuccess,
                failure: this.processFailure,
                scope: this,
                timeout: (this.timeout * 1000),
                argument: {
                    "url": url,
                    "form": form,
                    "callback": callback,
                    "reset": reset

                }

            });
            this.showLoading.defer(1, this);

        }

    },
    refresh: function(callback) {
        if (this.defaultUrl == null) {
            return;

        }
        this.update(this.defaultUrl, null, callback, true);

    },
    startAutoRefresh: function(interval, url, params, callback, refreshNow) {
        if (refreshNow) {
            this.update(url || this.defaultUrl, params, callback, true);

        }
        if (this.autoRefreshProcId) {
            clearInterval(this.autoRefreshProcId);

        }
        this.autoRefreshProcId = setInterval(this.update.createDelegate(this, [url || this.defaultUrl, params, callback, true]), interval * 1000);

    },
    stopAutoRefresh: function() {
        if (this.autoRefreshProcId) {
            clearInterval(this.autoRefreshProcId);
            delete this.autoRefreshProcId;

        }

    },
    isAutoRefreshing: function() {
        return this.autoRefreshProcId ? true: false;

    },
    showLoading: function() {
        if (this.showLoadIndicator) {
            this.el.update(this.indicatorText);

        }

    },
    processSuccess: function(response) {
        this.transaction = null;
        if (response.argument.form && response.argument.reset) {
            try {
                response.argument.form.reset();

            } catch(e) {}

        }
        if (this.loadScripts) {
            this.renderer.render(this.el, response, this, 
            this.updateComplete.createDelegate(this, [response]));

        } else {
            this.renderer.render(this.el, response, this);
            this.updateComplete(response);

        }

    },
    updateComplete: function(response) {
        this.fireEvent("update", this.el, response);
        if (typeof response.argument.callback == "function") {
            response.argument.callback.call(response.argument.scope, this.el, true, response, response.argument.options);

        }

    },
    processFailure: function(response) {
        this.transaction = null;
        this.fireEvent("failure", this.el, response);
        if (typeof response.argument.callback == "function") {
            response.argument.callback.call(response.argument.scope, this.el, false, response, response.argument.options);

        }

    },
    setRenderer: function(renderer) {
        this.renderer = renderer;

    },
    getRenderer: function() {
        return this.renderer;

    },
    setDefaultUrl: function(defaultUrl) {
        this.defaultUrl = defaultUrl;

    },
    abort: function() {
        if (this.transaction) {
            Ext.Ajax.abort(this.transaction);

        }

    },
    isUpdating: function() {
        if (this.transaction) {
            return Ext.Ajax.isLoading(this.transaction);

        }
        return false;

    }

});


Ext.Updater.defaults = {

    timeout: 30,
    loadScripts: false,
    sslBlankUrl: (Ext.SSL_SECURE_URL || "javascript:false"),
    disableCaching: false,
    showLoadIndicator: true,
    indicatorText: '<div class="loading-indicator">Loading...</div>'

};


Ext.Updater.updateElement = function(el, url, params, options) {
    var um = Ext.get(el).getUpdater();
    Ext.apply(um, options);
    um.update(url, params, options ? options.callback: null);

};

Ext.Updater.BasicRenderer = function() {};

Ext.Updater.BasicRenderer.prototype = {

    render: function(el, response, updateManager, callback) {
        el.update(response.responseText, updateManager.loadScripts, callback);

    }

};

Ext.UpdateManager = Ext.Updater;





Date.parseFunctions = {
    count: 0
};
Date.parseRegexes = [];
Date.formatFunctions = {
    count: 0
};

Date.prototype.dateFormat = function(format) {
    if (Date.formatFunctions[format] == null) {
        Date.createNewFormat(format);

    }
    var func = Date.formatFunctions[format];
    return this[func]();

};



Date.prototype.format = Date.prototype.dateFormat;

Date.createNewFormat = function(format) {
    var funcName = "format" + Date.formatFunctions.count++;
    Date.formatFunctions[format] = funcName;
    var code = "Date.prototype." + funcName + " = function(){return ";
    var special = false;
    var ch = '';
    for (var i = 0; i < format.length; ++i) {
        ch = format.charAt(i);
        if (!special && ch == "\\") {
            special = true;

        }
        else if (special) {
            special = false;
            code += "'" + String.escape(ch) + "' + ";

        }
        else {
            code += Date.getFormatCode(ch) + " + ";

        }

    }
    eval(code.substring(0, code.length - 3) + ";}");

};


Date.formatCodes = {
    d: "String.leftPad(this.getDate(), 2, '0')",
    D: "Date.getShortDayName(this.getDay())",
    j: "this.getDate()",
    l: "Date.dayNames[this.getDay()]",
    N: "(this.getDay() ? this.getDay() : 7)",
    S: "this.getSuffix()",
    w: "this.getDay()",
    z: "this.getDayOfYear()",
    W: "String.leftPad(this.getWeekOfYear(), 2, '0')",
    F: "Date.monthNames[this.getMonth()]",
    m: "String.leftPad(this.getMonth() + 1, 2, '0')",
    M: "Date.getShortMonthName(this.getMonth())",
    n: "(this.getMonth() + 1)",
    t: "this.getDaysInMonth()",
    L: "(this.isLeapYear() ? 1 : 0)",
    o: "(this.getFullYear() + (this.getWeekOfYear() == 1 && this.getMonth() > 0 ? +1 : (this.getWeekOfYear() >= 52 && this.getMonth() < 11 ? -1 : 0)))",
    Y: "this.getFullYear()",
    y: "('' + this.getFullYear()).substring(2, 4)",
    a: "(this.getHours() < 12 ? 'am' : 'pm')",
    A: "(this.getHours() < 12 ? 'AM' : 'PM')",
    g: "((this.getHours() % 12) ? this.getHours() % 12 : 12)",
    G: "this.getHours()",
    h: "String.leftPad((this.getHours() % 12) ? this.getHours() % 12 : 12, 2, '0')",
    H: "String.leftPad(this.getHours(), 2, '0')",
    i: "String.leftPad(this.getMinutes(), 2, '0')",
    s: "String.leftPad(this.getSeconds(), 2, '0')",
    u: "String.leftPad(this.getMilliseconds(), 3, '0')",
    O: "this.getGMTOffset()",
    P: "this.getGMTOffset(true)",
    T: "this.getTimezone()",
    Z: "(this.getTimezoneOffset() * -60)",
    c: function() {
        for (var c = "Y-m-dTH:i:sP", code = [], i = 0, l = c.length; i < l; ++i) {
            var e = c.charAt(i);
            code.push(e == "T" ? "'T'": Date.getFormatCode(e));
        }
        return code.join(" + ");

    },
    U: "Math.round(this.getTime() / 1000)"

}

Date.getFormatCode = function(character) {
    var f = Date.formatCodes[character];

    if (f) {
        f = Ext.type(f) == 'function' ? f() : f;
        Date.formatCodes[character] = f;
    }

    return f || ("'" + String.escape(character) + "'");

};


Date.parseDate = function(input, format) {
    if (Date.parseFunctions[format] == null) {
        Date.createParser(format);

    }
    var func = Date.parseFunctions[format];
    return Date[func](input);

};

Date.createParser = function(format) {
    var funcName = "parse" + Date.parseFunctions.count++;
    var regexNum = Date.parseRegexes.length;
    var currentGroup = 1;
    Date.parseFunctions[format] = funcName;

    var code = "Date." + funcName + " = function(input){\n"
    + "var y = -1, m = -1, d = -1, h = -1, i = -1, s = -1, ms = -1, o, z, u, v;\n"
    + "input = String(input);var d = new Date();\n"
    + "y = d.getFullYear();\n"
    + "m = d.getMonth();\n"
    + "d = d.getDate();\n"
    + "var results = input.match(Date.parseRegexes[" + regexNum + "]);\n"
    + "if (results && results.length > 0) {";
    var regex = "";

    var special = false;
    var ch = '';
    for (var i = 0; i < format.length; ++i) {
        ch = format.charAt(i);
        if (!special && ch == "\\") {
            special = true;

        }
        else if (special) {
            special = false;
            regex += String.escape(ch);

        }
        else {
            var obj = Date.formatCodeToRegex(ch, currentGroup);
            currentGroup += obj.g;
            regex += obj.s;
            if (obj.g && obj.c) {
                code += obj.c;

            }

        }

    }

    code += "if (u){\n"
    + "v = new Date(u * 1000);\n" + "}else if (y >= 0 && m >= 0 && d > 0 && h >= 0 && i >= 0 && s >= 0 && ms >= 0){\n"
    + "v = new Date(y, m, d, h, i, s, ms);\n"
    + "}else if (y >= 0 && m >= 0 && d > 0 && h >= 0 && i >= 0 && s >= 0){\n"
    + "v = new Date(y, m, d, h, i, s);\n"
    + "}else if (y >= 0 && m >= 0 && d > 0 && h >= 0 && i >= 0){\n"
    + "v = new Date(y, m, d, h, i);\n"
    + "}else if (y >= 0 && m >= 0 && d > 0 && h >= 0){\n"
    + "v = new Date(y, m, d, h);\n"
    + "}else if (y >= 0 && m >= 0 && d > 0){\n"
    + "v = new Date(y, m, d);\n"
    + "}else if (y >= 0 && m >= 0){\n"
    + "v = new Date(y, m);\n"
    + "}else if (y >= 0){\n"
    + "v = new Date(y);\n"
    + "}\n}\nreturn (v && Ext.type(z || o) == 'number')?" + " (Ext.type(z) == 'number' ? v.add(Date.SECOND, (v.getTimezoneOffset() * 60) + z) :" + " v.add(Date.HOUR, (v.getGMTOffset() / 100) + (o / -100))) : v;\n" + "}";

    Date.parseRegexes[regexNum] = new RegExp("^" + regex + "$", "i");
    eval(code);

};

Date.parseCodes = {

    d: {
        g: 1,
        c: "d = parseInt(results[{0}], 10);\n",
        s: "(\\d{2})"
    },
    j: function() {
        return Ext.applyIf({
            s: "(\\d{1,2})"
        },
        Date.parseCodes["d"]);

    },
    D: function() {
        for (var a = [], i = 0; i < 7; a.push(Date.getShortDayName(i)), ++i);
        return {
            g: 0,
            c: null,
            s: "(?:" + a.join("|") + ")"

        }

    },
    l: function() {
        return {
            g: 0,
            c: null,
            s: "(?:" + Date.dayNames.join("|") + ")"

        }

    },
    N: {
        g: 0,
        c: null,
        s: "[1-7]"
    },
    S: {
        g: 0,
        c: null,
        s: "(?:st|nd|rd|th)"

    },
    w: {
        g: 0,
        c: null,
        s: "[0-6]"
    },
    z: {
        g: 0,
        c: null,
        s: "(?:\\d{1,3}"
    },
    W: {
        g: 0,
        c: null,
        s: "(?:\\d{2})"
    },
    F: function() {
        return {
            g: 1,
            c: "m = parseInt(Date.getMonthNumber(results[{0}]), 10);\n",
            s: "(" + Date.monthNames.join("|") + ")"

        }

    },
    M: function() {
        for (var a = [], i = 0; i < 12; a.push(Date.getShortMonthName(i)), ++i);
        return Ext.applyIf({
            s: "(" + a.join("|") + ")"

        },
        Date.parseCodes["F"]);

    },
    m: {
        g: 1,
        c: "m = parseInt(results[{0}], 10) - 1;\n",
        s: "(\\d{2})"
    },
    n: function() {
        return Ext.applyIf({
            s: "(\\d{1,2})"
        },
        Date.parseCodes["m"]);

    },
    t: {
        g: 0,
        c: null,
        s: "(?:\\d{2})"
    },
    L: {
        g: 0,
        c: null,
        s: "(?:1|0)"

    },
    o: function() {
        return Date.parseCodes["Y"];

    },
    Y: {
        g: 1,
        c: "y = parseInt(results[{0}], 10);\n",
        s: "(\\d{4})"
    },
    y: {
        g: 1,
        c: "var ty = parseInt(results[{0}], 10);\n"
        + "y = ty > Date.y2kYear ? 1900 + ty : 2000 + ty;\n",
        s: "(\\d{1,2})"

    },
    a: {
        g: 1,
        c: "if (results[{0}] == 'am') {\n"
        + "if (h == 12) { h = 0; }\n"
        + "} else { if (h < 12) { h += 12; }}",
        s: "(am|pm)"

    },
    A: {
        g: 1,
        c: "if (results[{0}] == 'AM') {\n"
        + "if (h == 12) { h = 0; }\n"
        + "} else { if (h < 12) { h += 12; }}",
        s: "(AM|PM)"

    },
    g: function() {
        return Date.parseCodes["G"];

    },
    G: {
        g: 1,
        c: "h = parseInt(results[{0}], 10);\n",
        s: "(\\d{1,2})"
    },
    h: function() {
        return Date.parseCodes["H"];

    },
    H: {
        g: 1,
        c: "h = parseInt(results[{0}], 10);\n",
        s: "(\\d{2})"
    },
    i: {
        g: 1,
        c: "i = parseInt(results[{0}], 10);\n",
        s: "(\\d{2})"
    },
    s: {
        g: 1,
        c: "s = parseInt(results[{0}], 10);\n",
        s: "(\\d{2})"
    },
    u: {
        g: 1,
        c: "ms = parseInt(results[{0}], 10);\n",
        s: "(\\d{3})"
    },
    O: {
        g: 1,
        c: [
        "o = results[{0}];", 
        "var sn = o.substring(0,1);", "var hr = o.substring(1,3)*1 + Math.floor(o.substring(3,5) / 60);", "var mn = o.substring(3,5) % 60;", "o = ((-12 <= (hr*60 + mn)/60) && ((hr*60 + mn)/60 <= 14))? (sn + String.leftPad(hr, 2, '0') + String.leftPad(mn, 2, '0')) : null;\n"].join("\n"),
        s: "([+\-]\\d{4})"
    },
    P: function() {
        return Ext.applyIf({
            s: "([+\-]\\d{2}:\\d{2})"
        },
        Date.parseCodes["O"]);

    },
    T: {
        g: 0,
        c: null,
        s: "[A-Z]{1,4}"
    },
    Z: {
        g: 1,
        c: "z = results[{0}] * 1;\n" + "z = (-43200 <= z && z <= 50400)? z : null;\n",
        s: "([+\-]?\\d{1,5})"
    },
    c: function() {
        var df = Date.formatCodeToRegex,
        calc = [];
        var arr = [
        df("Y", 1), 
        df("m", 2), 
        df("d", 3), 
        df("h", 4), 
        df("i", 5), 
        df("s", 6), 
        {
            c: "if(results[7] == 'Z'){\no = 0;\n}else{\n" + df("P", 7).c + "\n}"
        }];
        for (var i = 0, l = arr.length; i < l; ++i) {
            calc.push(arr[i].c);

        }

        return {
            g: 1,
            c: calc.join(""),
            s: arr[0].s + "-" + arr[1].s + "-" + arr[2].s + "T" + arr[3].s + ":" + arr[4].s + ":" + arr[5].s + "(" + df("P", 7).s + "|Z)"

        }

    },
    U: {
        g: 1,
        c: "u = parseInt(results[{0}], 10);\n",
        s: "(-?\\d+)"
    }

}

Date.formatCodeToRegex = function(character, currentGroup) {
    var p = Date.parseCodes[character];

    if (p) {
        p = Ext.type(p) == 'function' ? p() : p;
        Date.parseCodes[character] = p;
        if (p.c) {
            p.c = String.format(p.c, currentGroup);

        }

    }

    return p || {
        g: 0,
        c: null,
        s: Ext.escapeRe(character)
    }

};


Date.prototype.getTimezone = function() {
    return this.toString().replace(/^.* (?:\((.*)\)|([A-Z]{1,4})(?:[\-+][0-9]{4})?(?: -?\d+)?)$/, "$1$2").replace(/[^A-Z]/g, "");

};


Date.prototype.getGMTOffset = function(colon) {
    return (this.getTimezoneOffset() > 0 ? "-": "+")
    + String.leftPad(Math.abs(Math.floor(this.getTimezoneOffset() / 60)), 2, "0")
    + (colon ? ":": "")
    + String.leftPad(this.getTimezoneOffset() % 60, 2, "0");

};


Date.prototype.getDayOfYear = function() {
    var num = 0;
    Date.daysInMonth[1] = this.isLeapYear() ? 29: 28;
    for (var i = 0; i < this.getMonth(); ++i) {
        num += Date.daysInMonth[i];

    }
    return num + this.getDate() - 1;

};


Date.prototype.getWeekOfYear = function() {
    var ms1d = 864e5;
    var ms7d = 7 * ms1d;
    var DC3 = Date.UTC(this.getFullYear(), this.getMonth(), this.getDate() + 3) / ms1d;
    var AWN = Math.floor(DC3 / 7);
    var Wyr = new Date(AWN * ms7d).getUTCFullYear();
    return AWN - Math.floor(Date.UTC(Wyr, 0, 7) / ms7d) + 1;

};


Date.prototype.isLeapYear = function() {
    var year = this.getFullYear();
    return !! ((year & 3) == 0 && (year % 100 || (year % 400 == 0 && year)));

};


Date.prototype.getFirstDayOfMonth = function() {
    var day = (this.getDay() - (this.getDate() - 1)) % 7;
    return (day < 0) ? (day + 7) : day;

};


Date.prototype.getLastDayOfMonth = function() {
    var day = (this.getDay() + (Date.daysInMonth[this.getMonth()] - this.getDate())) % 7;
    return (day < 0) ? (day + 7) : day;

};



Date.prototype.getFirstDateOfMonth = function() {
    return new Date(this.getFullYear(), this.getMonth(), 1);

};


Date.prototype.getLastDateOfMonth = function() {
    return new Date(this.getFullYear(), this.getMonth(), this.getDaysInMonth());

};

Date.prototype.getDaysInMonth = function() {
    Date.daysInMonth[1] = this.isLeapYear() ? 29: 28;
    return Date.daysInMonth[this.getMonth()];

};


Date.prototype.getSuffix = function() {
    switch (this.getDate()) {
        case 1:
    case 21:
    case 31:
        return "st";
        case 2:
    case 22:
        return "nd";
        case 3:
    case 23:
        return "rd";
        default:
        return "th";

    }

};

Date.daysInMonth = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];


Date.monthNames = [
"January", 
"February", 
"March", 
"April", 
"May", 
"June", 
"July", 
"August", 
"September", 
"October", 
"November", 
"December"
];


Date.getShortMonthName = function(month) {
    return Date.monthNames[month].substring(0, 3);

}


Date.dayNames = [
"Sunday", 
"Monday", 
"Tuesday", 
"Wednesday", 
"Thursday", 
"Friday", 
"Saturday"
];


Date.getShortDayName = function(day) {
    return Date.dayNames[day].substring(0, 3);

}

Date.y2kYear = 50;


Date.monthNumbers = {
    Jan: 0,
    Feb: 1,
    Mar: 2,
    Apr: 3,
    May: 4,
    Jun: 5,
    Jul: 6,
    Aug: 7,
    Sep: 8,
    Oct: 9,
    Nov: 10,
    Dec: 11

};


Date.getMonthNumber = function(name) {
    return Date.monthNumbers[name.substring(0, 1).toUpperCase() + name.substring(1, 3).toLowerCase()];

}


Date.prototype.clone = function() {
    return new Date(this.getTime());

};


Date.prototype.clearTime = function(clone) {
    if (clone) {
        return this.clone().clearTime();

    }
    this.setHours(0);
    this.setMinutes(0);
    this.setSeconds(0);
    this.setMilliseconds(0);
    return this;

};

if (Ext.isSafari) {
    Date.brokenSetMonth = Date.prototype.setMonth;
    Date.prototype.setMonth = function(num) {
        if (num <= -1) {
            var n = Math.ceil( - num);
            var back_year = Math.ceil(n / 12);
            var month = (n % 12) ? 12 - n % 12: 0;
            this.setFullYear(this.getFullYear() - back_year);
            return Date.brokenSetMonth.call(this, month);

        } else {
            return Date.brokenSetMonth.apply(this, arguments);

        }

    };

}


Date.MILLI = "ms";

Date.SECOND = "s";

Date.MINUTE = "mi";

Date.HOUR = "h";

Date.DAY = "d";

Date.MONTH = "mo";

Date.YEAR = "y";


Date.prototype.add = function(interval, value) {
    var d = this.clone();
    if (!interval || value === 0) return d;
    switch (interval.toLowerCase()) {
        case Date.MILLI:
        d.setMilliseconds(this.getMilliseconds() + value);
        break;
        case Date.SECOND:
        d.setSeconds(this.getSeconds() + value);
        break;
        case Date.MINUTE:
        d.setMinutes(this.getMinutes() + value);
        break;
        case Date.HOUR:
        d.setHours(this.getHours() + value);
        break;
        case Date.DAY:
        d.setDate(this.getDate() + value);
        break;
        case Date.MONTH:
        var day = this.getDate();
        if (day > 28) {
            day = Math.min(day, this.getFirstDateOfMonth().add('mo', value).getLastDateOfMonth().getDate());

        }
        d.setDate(day);
        d.setMonth(this.getMonth() + value);
        break;
        case Date.YEAR:
        d.setFullYear(this.getFullYear() + value);
        break;

    }
    return d;

};


Date.prototype.between = function(start, end) {
    var t = this.getTime();
    return start.getTime() <= t && t <= end.getTime();

}

Ext.util.DelayedTask = function(fn, scope, args) {
    var id = null,
    d,
    t;

    var call = function() {
        var now = new Date().getTime();
        if (now - t >= d) {
            clearInterval(id);
            id = null;
            fn.apply(scope, args || []);

        }

    };

    this.delay = function(delay, newFn, newScope, newArgs) {
        if (id && delay != d) {
            this.cancel();

        }
        d = delay;
        t = new Date().getTime();
        fn = newFn || fn;
        scope = newScope || scope;
        args = newArgs || args;
        if (!id) {
            id = setInterval(call, d);

        }

    };


    this.cancel = function() {
        if (id) {
            clearInterval(id);
            id = null;

        }

    };

};

Ext.util.TaskRunner = function(interval) {
    interval = interval || 10;
    var tasks = [],
    removeQueue = [];
    var id = 0;
    var running = false;

    var stopThread = function() {
        running = false;
        clearInterval(id);
        id = 0;

    };

    var startThread = function() {
        if (!running) {
            running = true;
            id = setInterval(runTasks, interval);

        }

    };

    var removeTask = function(t) {
        removeQueue.push(t);
        if (t.onStop) {
            t.onStop.apply(t.scope || t);

        }

    };

    var runTasks = function() {
        if (removeQueue.length > 0) {
            for (var i = 0, len = removeQueue.length; i < len; i++) {
                tasks.remove(removeQueue[i]);

            }
            removeQueue = [];
            if (tasks.length < 1) {
                stopThread();
                return;

            }

        }
        var now = new Date().getTime();
        for (var i = 0, len = tasks.length; i < len; ++i) {
            var t = tasks[i];
            var itime = now - t.taskRunTime;
            if (t.interval <= itime) {
                var rt = t.run.apply(t.scope || t, t.args || [++t.taskRunCount]);
                t.taskRunTime = now;
                if (rt === false || t.taskRunCount === t.repeat) {
                    removeTask(t);
                    return;

                }

            }
            if (t.duration && t.duration <= (now - t.taskStartTime)) {
                removeTask(t);

            }

        }

    };


    this.start = function(task) {
        tasks.push(task);
        task.taskStartTime = new Date().getTime();
        task.taskRunTime = 0;
        task.taskRunCount = 0;
        startThread();
        return task;

    };


    this.stop = function(task) {
        removeTask(task);
        return task;

    };


    this.stopAll = function() {
        stopThread();
        for (var i = 0, len = tasks.length; i < len; i++) {
            if (tasks[i].onStop) {
                tasks[i].onStop();

            }

        }
        tasks = [];
        removeQueue = [];

    };

};


Ext.TaskMgr = new Ext.util.TaskRunner();

Ext.util.MixedCollection = function(allowFunctions, keyFn) {
    this.items = [];
    this.map = {};
    this.keys = [];
    this.length = 0;
    this.addEvents(

    "clear", 

    "add", 

    "replace", 

    "remove", 
    "sort"
    );
    this.allowFunctions = allowFunctions === true;
    if (keyFn) {
        this.getKey = keyFn;

    }
    Ext.util.MixedCollection.superclass.constructor.call(this);

};

Ext.extend(Ext.util.MixedCollection, Ext.util.Observable, {
    allowFunctions: false,
    add: function(key, o) {
        if (arguments.length == 1) {
            o = arguments[0];
            key = this.getKey(o);

        }
        if (typeof key == "undefined" || key === null) {
            this.length++;
            this.items.push(o);
            this.keys.push(null);

        } else {
            var old = this.map[key];
            if (old) {
                return this.replace(key, o);

            }
            this.length++;
            this.items.push(o);
            this.map[key] = o;
            this.keys.push(key);

        }
        this.fireEvent("add", this.length - 1, o, key);
        return o;

    },
    getKey: function(o) {
        return o.id;

    },
    replace: function(key, o) {
        if (arguments.length == 1) {
            o = arguments[0];
            key = this.getKey(o);

        }
        var old = this.item(key);
        if (typeof key == "undefined" || key === null || typeof old == "undefined") {
            return this.add(key, o);

        }
        var index = this.indexOfKey(key);
        this.items[index] = o;
        this.map[key] = o;
        this.fireEvent("replace", key, old, o);
        return o;

    },
    addAll: function(objs) {
        if (arguments.length > 1 || Ext.isArray(objs)) {
            var args = arguments.length > 1 ? arguments: objs;
            for (var i = 0, len = args.length; i < len; i++) {
                this.add(args[i]);

            }

        } else {
            for (var key in objs) {
                if (this.allowFunctions || typeof objs[key] != "function") {
                    this.add(key, objs[key]);

                }

            }

        }

    },
    each: function(fn, scope) {
        var items = [].concat(this.items);
        for (var i = 0, len = items.length; i < len; i++) {
            if (fn.call(scope || items[i], items[i], i, len) === false) {
                break;

            }

        }

    },
    eachKey: function(fn, scope) {
        for (var i = 0, len = this.keys.length; i < len; i++) {
            fn.call(scope || window, this.keys[i], this.items[i], i, len);

        }

    },
    find: function(fn, scope) {
        for (var i = 0, len = this.items.length; i < len; i++) {
            if (fn.call(scope || window, this.items[i], this.keys[i])) {
                return this.items[i];

            }

        }
        return null;

    },
    insert: function(index, key, o) {
        if (arguments.length == 2) {
            o = arguments[1];
            key = this.getKey(o);

        }
        if (index >= this.length) {
            return this.add(key, o);

        }
        this.length++;
        this.items.splice(index, 0, o);
        if (typeof key != "undefined" && key != null) {
            this.map[key] = o;

        }
        this.keys.splice(index, 0, key);
        this.fireEvent("add", index, o, key);
        return o;

    },
    remove: function(o) {
        return this.removeAt(this.indexOf(o));

    },
    removeAt: function(index) {
        if (index < this.length && index >= 0) {
            this.length--;
            var o = this.items[index];
            this.items.splice(index, 1);
            var key = this.keys[index];
            if (typeof key != "undefined") {
                delete this.map[key];

            }
            this.keys.splice(index, 1);
            this.fireEvent("remove", o, key);
            return o;

        }
        return false;

    },
    removeKey: function(key) {
        return this.removeAt(this.indexOfKey(key));

    },
    getCount: function() {
        return this.length;

    },
    indexOf: function(o) {
        return this.items.indexOf(o);

    },
    indexOfKey: function(key) {
        return this.keys.indexOf(key);

    },
    item: function(key) {
        var item = typeof this.map[key] != "undefined" ? this.map[key] : this.items[key];
        return typeof item != 'function' || this.allowFunctions ? item: null;

    },
    itemAt: function(index) {
        return this.items[index];

    },
    key: function(key) {
        return this.map[key];

    },
    contains: function(o) {
        return this.indexOf(o) != -1;

    },
    containsKey: function(key) {
        return typeof this.map[key] != "undefined";

    },
    clear: function() {
        this.length = 0;
        this.items = [];
        this.keys = [];
        this.map = {};
        this.fireEvent("clear");

    },
    first: function() {
        return this.items[0];

    },
    last: function() {
        return this.items[this.length - 1];

    },
    _sort: function(property, dir, fn) {
        var dsc = String(dir).toUpperCase() == "DESC" ? -1: 1;
        fn = fn || 
        function(a, b) {
            return a - b;

        };
        var c = [],
        k = this.keys,
        items = this.items;
        for (var i = 0, len = items.length; i < len; i++) {
            c[c.length] = {
                key: k[i],
                value: items[i],
                index: i
            };

        }
        c.sort(function(a, b) {
            var v = fn(a[property], b[property]) * dsc;
            if (v == 0) {
                v = (a.index < b.index ? -1: 1);

            }
            return v;

        });
        for (var i = 0, len = c.length; i < len; i++) {
            items[i] = c[i].value;
            k[i] = c[i].key;

        }
        this.fireEvent("sort", this);

    },
    sort: function(dir, fn) {
        this._sort("value", dir, fn);

    },
    keySort: function(dir, fn) {
        this._sort("key", dir, fn || 
        function(a, b) {
            return String(a).toUpperCase() - String(b).toUpperCase();

        });

    },
    getRange: function(start, end) {
        var items = this.items;
        if (items.length < 1) {
            return [];

        }
        start = start || 0;
        end = Math.min(typeof end == "undefined" ? this.length - 1: end, this.length - 1);
        var r = [];
        if (start <= end) {
            for (var i = start; i <= end; i++) {
                r[r.length] = items[i];

            }

        } else {
            for (var i = start; i >= end; i--) {
                r[r.length] = items[i];

            }

        }
        return r;

    },
    filter: function(property, value, anyMatch, caseSensitive) {
        if (Ext.isEmpty(value, false)) {
            return this.clone();

        }
        value = this.createValueMatcher(value, anyMatch, caseSensitive);
        return this.filterBy(function(o) {
            return o && value.test(o[property]);

        });

    },
    filterBy: function(fn, scope) {
        var r = new Ext.util.MixedCollection();
        r.getKey = this.getKey;
        var k = this.keys,
        it = this.items;
        for (var i = 0, len = it.length; i < len; i++) {
            if (fn.call(scope || this, it[i], k[i])) {
                r.add(k[i], it[i]);

            }

        }
        return r;

    },
    findIndex: function(property, value, start, anyMatch, caseSensitive) {
        if (Ext.isEmpty(value, false)) {
            return - 1;

        }
        value = this.createValueMatcher(value, anyMatch, caseSensitive);
        return this.findIndexBy(function(o) {
            return o && value.test(o[property]);

        },
        null, start);

    },
    findIndexBy: function(fn, scope, start) {
        var k = this.keys,
        it = this.items;
        for (var i = (start || 0), len = it.length; i < len; i++) {
            if (fn.call(scope || this, it[i], k[i])) {
                return i;

            }

        }
        if (typeof start == 'number' && start > 0) {
            for (var i = 0; i < start; i++) {
                if (fn.call(scope || this, it[i], k[i])) {
                    return i;

                }

            }

        }
        return - 1;

    },
    createValueMatcher: function(value, anyMatch, caseSensitive) {
        if (!value.exec) {
            value = String(value);
            value = new RegExp((anyMatch === true ? '': '^') + Ext.escapeRe(value), caseSensitive ? '': 'i');

        }
        return value;

    },
    clone: function() {
        var r = new Ext.util.MixedCollection();
        var k = this.keys,
        it = this.items;
        for (var i = 0, len = it.length; i < len; i++) {
            r.add(k[i], it[i]);

        }
        r.getKey = this.getKey;
        return r;

    }

});

Ext.util.MixedCollection.prototype.get = Ext.util.MixedCollection.prototype.item;

Ext.util.JSON = new(function() {
    var useHasOwn = !!{}.hasOwnProperty;


    var pad = function(n) {
        return n < 10 ? "0" + n: n;

    };

    var m = {
        "\b": '\\b',
        "\t": '\\t',
        "\n": '\\n',
        "\f": '\\f',
        "\r": '\\r',
        '"': '\\"',
        "\\": '\\\\'

    };

    var encodeString = function(s) {
        if (/["\\\x00-\x1f]/.test(s)) {
            return '"' + s.replace(/([\x00-\x1f\\"])/g, 
            function(a, b) {
                var c = m[b];
                if (c) {
                    return c;

                }
                c = b.charCodeAt();
                return "\\u00" + 
                Math.floor(c / 16).toString(16) + 
                (c % 16).toString(16);

            }) + '"';

        }
        return '"' + s + '"';

    };

    var encodeArray = function(o) {
        var a = ["["],
        b,
        i,
        l = o.length,
        v;
        for (i = 0; i < l; i += 1) {
            v = o[i];
            switch (typeof v) {
                case "undefined":
            case "function":
            case "unknown":
                break;
                default:
                if (b) {
                    a.push(',');

                }
                a.push(v === null ? "null": Ext.util.JSON.encode(v));
                b = true;

            }

        }
        a.push("]");
        return a.join("");

    };

    this.encodeDate = function(o) {
        return '"' + o.getFullYear() + "-" + 
        pad(o.getMonth() + 1) + "-" + 
        pad(o.getDate()) + "T" + 
        pad(o.getHours()) + ":" + 
        pad(o.getMinutes()) + ":" + 
        pad(o.getSeconds()) + '"';

    };


    this.encode = function(o) {
        if (typeof o == "undefined" || o === null) {
            return "null";

        } else if (Ext.isArray(o)) {
            return encodeArray(o);

        } else if (Ext.isDate(o)) {
            return Ext.util.JSON.encodeDate(o);

        } else if (typeof o == "string") {
            return encodeString(o);

        } else if (typeof o == "number") {
            return isFinite(o) ? String(o) : "null";

        } else if (typeof o == "boolean") {
            return String(o);

        } else {
            var a = ["{"],
            b,
            i,
            v;
            for (i in o) {
                if (!useHasOwn || o.hasOwnProperty(i)) {
                    v = o[i];
                    switch (typeof v) {
                        case "undefined":
                    case "function":
                    case "unknown":
                        break;
                        default:
                        if (b) {
                            a.push(',');

                        }
                        a.push(this.encode(i), ":", 
                        v === null ? "null": this.encode(v));
                        b = true;

                    }

                }

            }
            a.push("}");
            return a.join("");

        }

    };


    this.decode = function(json) {
        return eval("(" + json + ')');

    };

})();

Ext.encode = Ext.util.JSON.encode;

Ext.decode = Ext.util.JSON.decode;


Ext.util.Format = function() {
    var trimRe = /^\s+|\s+$/g;
    return {

        ellipsis: function(value, len) {
            if (value && value.length > len) {
                return value.substr(0, len - 3) + "...";

            }
            return value;

        },
        undef: function(value) {
            return value !== undefined ? value: "";

        },
        defaultValue: function(value, defaultValue) {
            return value !== undefined && value !== '' ? value: defaultValue;

        },
        htmlEncode: function(value) {
            return ! value ? value: String(value).replace(/&/g, "&amp;").replace(/>/g, "&gt;").replace(/</g, "&lt;").replace(/"/g, "&quot;");

        },
        htmlDecode: function(value) {
            return ! value ? value: String(value).replace(/&amp;/g, "&").replace(/&gt;/g, ">").replace(/&lt;/g, "<").replace(/&quot;/g, '"');

        },
        trim: function(value) {
            return String(value).replace(trimRe, "");

        },
        substr: function(value, start, length) {
            return String(value).substr(start, length);

        },
        lowercase: function(value) {
            return String(value).toLowerCase();

        },
        uppercase: function(value) {
            return String(value).toUpperCase();

        },
        capitalize: function(value) {
            return ! value ? value: value.charAt(0).toUpperCase() + value.substr(1).toLowerCase();

        },
        call: function(value, fn) {
            if (arguments.length > 2) {
                var args = Array.prototype.slice.call(arguments, 2);
                args.unshift(value);
                return eval(fn).apply(window, args);

            } else {
                return eval(fn).call(window, value);

            }

        },
        usMoney: function(v) {
            v = (Math.round((v - 0) * 100)) / 100;
            v = (v == Math.floor(v)) ? v + ".00": ((v * 10 == Math.floor(v * 10)) ? v + "0": v);
            v = String(v);
            var ps = v.split('.');
            var whole = ps[0];
            var sub = ps[1] ? '.' + ps[1] : '.00';
            var r = /(\d+)(\d{3})/;
            while (r.test(whole)) {
                whole = whole.replace(r, '$1' + ',' + '$2');

            }
            v = whole + sub;
            if (v.charAt(0) == '-') {
                return '-$' + v.substr(1);

            }
            return "$" + v;

        },
        date: function(v, format) {
            if (!v) {
                return "";

            }
            if (!Ext.isDate(v)) {
                v = new Date(Date.parse(v));

            }
            return v.dateFormat(format || "m/d/Y");

        },
        dateRenderer: function(format) {
            return function(v) {
                return Ext.util.Format.date(v, format);

            };

        },
        stripTagsRE: /<\/?[^>]+>/gi,
        stripTags: function(v) {
            return ! v ? v: String(v).replace(this.stripTagsRE, "");

        },
        stripScriptsRe: /(?:<script.*?>)((\n|\r|.)*?)(?:<\/script>)/ig,
        stripScripts: function(v) {
            return ! v ? v: String(v).replace(this.stripScriptsRe, "");

        },
        fileSize: function(size) {
            if (size < 1024) {
                return size + " bytes";

            } else if (size < 1048576) {
                return (Math.round(((size * 10) / 1024)) / 10) + " KB";

            } else {
                return (Math.round(((size * 10) / 1048576)) / 10) + " MB";

            }

        },
        math: function() {
            var fns = {};
            return function(v, a) {
                if (!fns[a]) {
                    fns[a] = new Function('v', 'return v ' + a + ';');

                }
                return fns[a](v);

            }

        } ()

    };

} ();

Ext.XTemplate = function() {
    Ext.XTemplate.superclass.constructor.apply(this, arguments);
    var s = this.html;

    s = ['<tpl>', s, '</tpl>'].join('');

    var re = /<tpl\b[^>]*>((?:(?=([^<]+))\2|<(?!tpl\b[^>]*>))*?)<\/tpl>/;

    var nameRe = /^<tpl\b[^>]*?for="(.*?)"/;
    var ifRe = /^<tpl\b[^>]*?if="(.*?)"/;
    var execRe = /^<tpl\b[^>]*?exec="(.*?)"/;
    var m,
    id = 0;
    var tpls = [];

    while (m = s.match(re)) {
        var m2 = m[0].match(nameRe);
        var m3 = m[0].match(ifRe);
        var m4 = m[0].match(execRe);
        var exp = null,
        fn = null,
        exec = null;
        var name = m2 && m2[1] ? m2[1] : '';
        if (m3) {
            exp = m3 && m3[1] ? m3[1] : null;
            if (exp) {
                fn = new Function('values', 'parent', 'xindex', 'xcount', 'with(values){ return ' + (Ext.util.Format.htmlDecode(exp)) + '; }');

            }

        }
        if (m4) {
            exp = m4 && m4[1] ? m4[1] : null;
            if (exp) {
                exec = new Function('values', 'parent', 'xindex', 'xcount', 'with(values){ ' + (Ext.util.Format.htmlDecode(exp)) + '; }');

            }

        }
        if (name) {
            switch (name) {
                case '.':
                name = new Function('values', 'parent', 'with(values){ return values; }');
                break;
                case '..':
                name = new Function('values', 'parent', 'with(values){ return parent; }');
                break;
                default:
                name = new Function('values', 'parent', 'with(values){ return ' + name + '; }');

            }

        }
        tpls.push({
            id: id,
            target: name,
            exec: exec,
            test: fn,
            body: m[1] || ''

        });
        s = s.replace(m[0], '{xtpl' + id + '}');
        ++id;

    }
    for (var i = tpls.length - 1; i >= 0; --i) {
        this.compileTpl(tpls[i]);

    }
    this.master = tpls[tpls.length - 1];
    this.tpls = tpls;

};
Ext.extend(Ext.XTemplate, Ext.Template, {
    re: /\{([\w-\.\#]+)(?:\:([\w\.]*)(?:\((.*?)?\))?)?(\s?[\+\-\*\\]\s?[\d\.\+\-\*\\\(\)]+)?\}/g,
    codeRe: /\{\[((?:\\\]|.|\n)*?)\]\}/g,
    applySubTemplate: function(id, values, parent, xindex, xcount) {
        var t = this.tpls[id];
        if (t.test && !t.test.call(this, values, parent, xindex, xcount)) {
            return '';

        }
        if (t.exec && t.exec.call(this, values, parent, xindex, xcount)) {
            return '';

        }
        var vs = t.target ? t.target.call(this, values, parent) : values;
        parent = t.target ? values: parent;
        if (t.target && Ext.isArray(vs)) {
            var buf = [];
            for (var i = 0, len = vs.length; i < len; i++) {
                buf[buf.length] = t.compiled.call(this, vs[i], parent, i + 1, len);

            }
            return buf.join('');

        }
        return t.compiled.call(this, vs, parent, xindex, xcount);

    },
    compileTpl: function(tpl) {
        var fm = Ext.util.Format;
        var useF = this.disableFormats !== true;
        var sep = Ext.isGecko ? "+": ",";
        var fn = function(m, name, format, args, math) {
            if (name.substr(0, 4) == 'xtpl') {
                return "'" + sep + 'this.applySubTemplate(' + name.substr(4) + ', values, parent, xindex, xcount)' + sep + "'";

            }
            var v;
            if (name === '.') {
                v = 'values';

            } else if (name === '#') {
                v = 'xindex';

            } else if (name.indexOf('.') != -1) {
                v = name;

            } else {
                v = "values['" + name + "']";

            }
            if (math) {
                v = '(' + v + math + ')';

            }
            if (format && useF) {
                args = args ? ',' + args: "";
                if (format.substr(0, 5) != "this.") {
                    format = "fm." + format + '(';

                } else {
                    format = 'this.call("' + format.substr(5) + '", ';
                    args = ", values";

                }

            } else {
                args = '';
                format = "(" + v + " === undefined ? '' : ";

            }
            return "'" + sep + format + v + args + ")" + sep + "'";

        };
        var codeFn = function(m, code) {
            return "'" + sep + '(' + code + ')' + sep + "'";

        };

        var body;
        if (Ext.isGecko) {
            body = "tpl.compiled = function(values, parent, xindex, xcount){ return '" + 
            tpl.body.replace(/(\r\n|\n)/g, '\\n').replace(/'/g, "\\'").replace(this.re, fn).replace(this.codeRe, codeFn) + 
            "';};";

        } else {
            body = ["tpl.compiled = function(values, parent, xindex, xcount){ return ['"];
            body.push(tpl.body.replace(/(\r\n|\n)/g, '\\n').replace(/'/g, "\\'").replace(this.re, fn).replace(this.codeRe, codeFn));
            body.push("'].join('');};");
            body = body.join('');

        }
        eval(body);
        return this;

    },
    applyTemplate: function(values) {
        return this.master.compiled.call(this, values, {},
        1, 1);

    },
    compile: function() {
        return this;
    }






});

Ext.XTemplate.prototype.apply = Ext.XTemplate.prototype.applyTemplate;


Ext.XTemplate.from = function(el) {
    el = Ext.getDom(el);
    return new Ext.XTemplate(el.value || el.innerHTML);

};

Ext.util.CSS = function() {
    var rules = null;
    var doc = document;

    var camelRe = /(-[a-z])/gi;
    var camelFn = function(m, a) {
        return a.charAt(1).toUpperCase();
    };

    return {

        createStyleSheet: function(cssText, id) {
            var ss;
            var head = doc.getElementsByTagName("head")[0];
            var rules = doc.createElement("style");
            rules.setAttribute("type", "text/css");
            if (id) {
                rules.setAttribute("id", id);

            }
            if (Ext.isIE) {
                head.appendChild(rules);
                ss = rules.styleSheet;
                ss.cssText = cssText;

            } else {
                try {
                    rules.appendChild(doc.createTextNode(cssText));

                } catch(e) {
                    rules.cssText = cssText;

                }
                head.appendChild(rules);
                ss = rules.styleSheet ? rules.styleSheet: (rules.sheet || doc.styleSheets[doc.styleSheets.length - 1]);

            }
            this.cacheStyleSheet(ss);
            return ss;

        },
        removeStyleSheet: function(id) {
            var existing = doc.getElementById(id);
            if (existing) {
                existing.parentNode.removeChild(existing);

            }

        },
        swapStyleSheet: function(id, url) {
            this.removeStyleSheet(id);
            var ss = doc.createElement("link");
            ss.setAttribute("rel", "stylesheet");
            ss.setAttribute("type", "text/css");
            ss.setAttribute("id", id);
            ss.setAttribute("href", url);
            doc.getElementsByTagName("head")[0].appendChild(ss);

        },
        refreshCache: function() {
            return this.getRules(true);

        },
        cacheStyleSheet: function(ss) {
            if (!rules) {
                rules = {};

            }
            try {
                var ssRules = ss.cssRules || ss.rules;
                for (var j = ssRules.length - 1; j >= 0; --j) {
                    rules[ssRules[j].selectorText] = ssRules[j];

                }

            } catch(e) {}

        },
        getRules: function(refreshCache) {
            if (rules == null || refreshCache) {
                rules = {};
                var ds = doc.styleSheets;
                for (var i = 0, len = ds.length; i < len; i++) {
                    try {
                        this.cacheStyleSheet(ds[i]);

                    } catch(e) {}

                }

            }
            return rules;

        },
        getRule: function(selector, refreshCache) {
            var rs = this.getRules(refreshCache);
            if (!Ext.isArray(selector)) {
                return rs[selector];

            }
            for (var i = 0; i < selector.length; i++) {
                if (rs[selector[i]]) {
                    return rs[selector[i]];

                }

            }
            return null;

        },
        
updateRule: function(selector, property, value) {
            if (!Ext.isArray(selector)) {
                var rule = this.getRule(selector);
                if (rule) {
                    rule.style[property.replace(camelRe, camelFn)] = value;
                    return true;

                }

            } else {
                for (var i = 0; i < selector.length; i++) {
                    if (this.updateRule(selector[i], property, value)) {
                        return true;

                    }

                }

            }
            return false;

        }

    };

} ();

Ext.util.ClickRepeater = function(el, config)
 {
    this.el = Ext.get(el);
    this.el.unselectable();

    Ext.apply(this, config);

    this.addEvents(

    "mousedown", 

    "click", 

    "mouseup"
    );

    this.el.on("mousedown", this.handleMouseDown, this);
    if (this.preventDefault || this.stopDefault) {
        this.el.on("click", 
        function(e) {
            if (this.preventDefault) {
                e.preventDefault();

            }
            if (this.stopDefault) {
                e.stopEvent();

            }

        },
        this);

    }

    if (this.handler) {
        this.on("click", this.handler, this.scope || this);

    }

    Ext.util.ClickRepeater.superclass.constructor.call(this);

};

Ext.extend(Ext.util.ClickRepeater, Ext.util.Observable, {
    interval: 20,
    delay: 250,
    preventDefault: true,
    stopDefault: false,
    timer: 0,
    handleMouseDown: function() {
        clearTimeout(this.timer);
        this.el.blur();
        if (this.pressClass) {
            this.el.addClass(this.pressClass);

        }
        this.mousedownTime = new Date();

        Ext.getDoc().on("mouseup", this.handleMouseUp, this);
        this.el.on("mouseout", this.handleMouseOut, this);

        this.fireEvent("mousedown", this);
        this.fireEvent("click", this);

        if (this.accelerate) {
            this.delay = 400;

        }
        this.timer = this.click.defer(this.delay || this.interval, this);

    },
    click: function() {
        this.fireEvent("click", this);
        this.timer = this.click.defer(this.accelerate ? 
        this.easeOutExpo(this.mousedownTime.getElapsed(), 
        400, 
        -390, 
        12000) : 
        this.interval, this);

    },
    easeOutExpo: function(t, b, c, d) {
        return (t == d) ? b + c: c * ( - Math.pow(2, -10 * t / d) + 1) + b;

    },
    handleMouseOut: function() {
        clearTimeout(this.timer);
        if (this.pressClass) {
            this.el.removeClass(this.pressClass);

        }
        this.el.on("mouseover", this.handleMouseReturn, this);

    },
    handleMouseReturn: function() {
        this.el.un("mouseover", this.handleMouseReturn);
        if (this.pressClass) {
            this.el.addClass(this.pressClass);

        }
        this.click();

    },
    handleMouseUp: function() {
        clearTimeout(this.timer);
        this.el.un("mouseover", this.handleMouseReturn);
        this.el.un("mouseout", this.handleMouseOut);
        Ext.getDoc().un("mouseup", this.handleMouseUp);
        this.el.removeClass(this.pressClass);
        this.fireEvent("mouseup", this);

    }

});

Ext.KeyNav = function(el, config) {
    this.el = Ext.get(el);
    Ext.apply(this, config);
    if (!this.disabled) {
        this.disabled = true;
        this.enable();

    }

};

Ext.KeyNav.prototype = {

    disabled: false,
    defaultEventAction: "stopEvent",
    forceKeyDown: false,
    prepareEvent: function(e) {
        var k = e.getKey();
        var h = this.keyToHandler[k];
        if (Ext.isSafari2 && h && k >= 37 && k <= 40) {
            e.stopEvent();

        }

    },
    relay: function(e) {
        var k = e.getKey();
        var h = this.keyToHandler[k];
        if (h && this[h]) {
            if (this.doRelay(e, this[h], h) !== true) {
                e[this.defaultEventAction]();

            }

        }

    },
    doRelay: function(e, h, hname) {
        return h.call(this.scope || this, e);

    },
    enter: false,
    left: false,
    right: false,
    up: false,
    down: false,
    tab: false,
    esc: false,
    pageUp: false,
    pageDown: false,
    del: false,
    home: false,
    end: false,
    keyToHandler: {
        37: "left",
        39: "right",
        38: "up",
        40: "down",
        33: "pageUp",
        34: "pageDown",
        46: "del",
        36: "home",
        35: "end",
        13: "enter",
        27: "esc",
        9: "tab"

    },
    enable: function() {
        if (this.disabled) {
            if (this.forceKeyDown || Ext.isIE || Ext.isSafari3 || Ext.isAir) {
                this.el.on("keydown", this.relay, this);

            } else {
                this.el.on("keydown", this.prepareEvent, this);
                this.el.on("keypress", this.relay, this);

            }
            this.disabled = false;

        }

    },
    disable: function() {
        if (!this.disabled) {
            if (this.forceKeyDown || Ext.isIE || Ext.isSafari3 || Ext.isAir) {
                this.el.un("keydown", this.relay);

            } else {
                this.el.un("keydown", this.prepareEvent);
                this.el.un("keypress", this.relay);

            }
            this.disabled = true;

        }

    }

};

Ext.KeyMap = function(el, config, eventName) {
    this.el = Ext.get(el);
    this.eventName = eventName || "keydown";
    this.bindings = [];
    if (config) {
        this.addBinding(config);

    }
    this.enable();

};

Ext.KeyMap.prototype = {

    stopEvent: false,
    addBinding: function(config) {
        if (Ext.isArray(config)) {
            for (var i = 0, len = config.length; i < len; i++) {
                this.addBinding(config[i]);

            }
            return;

        }
        var keyCode = config.key,
        shift = config.shift,
        ctrl = config.ctrl,
        alt = config.alt,
        fn = config.fn || config.handler,
        scope = config.scope;

        if (typeof keyCode == "string") {
            var ks = [];
            var keyString = keyCode.toUpperCase();
            for (var j = 0, len = keyString.length; j < len; j++) {
                ks.push(keyString.charCodeAt(j));

            }
            keyCode = ks;

        }
        var keyArray = Ext.isArray(keyCode);

        var handler = function(e) {
            if ((!shift || e.shiftKey) && (!ctrl || e.ctrlKey) && (!alt || e.altKey)) {
                var k = e.getKey();
                if (keyArray) {
                    for (var i = 0, len = keyCode.length; i < len; i++) {
                        if (keyCode[i] == k) {
                            if (this.stopEvent) {
                                e.stopEvent();

                            }
                            fn.call(scope || window, k, e);
                            return;

                        }

                    }

                } else {
                    if (k == keyCode) {
                        if (this.stopEvent) {
                            e.stopEvent();

                        }
                        fn.call(scope || window, k, e);

                    }

                }

            }

        };
        this.bindings.push(handler);

    },
    on: function(key, fn, scope) {
        var keyCode,
        shift,
        ctrl,
        alt;
        if (typeof key == "object" && !Ext.isArray(key)) {
            keyCode = key.key;
            shift = key.shift;
            ctrl = key.ctrl;
            alt = key.alt;

        } else {
            keyCode = key;

        }
        this.addBinding({
            key: keyCode,
            shift: shift,
            ctrl: ctrl,
            alt: alt,
            fn: fn,
            scope: scope

        })

    },
    handleKeyDown: function(e) {
        if (this.enabled) {
            var b = this.bindings;
            for (var i = 0, len = b.length; i < len; i++) {
                b[i].call(this, e);

            }

        }

    },
    isEnabled: function() {
        return this.enabled;

    },
    enable: function() {
        if (!this.enabled) {
            this.el.on(this.eventName, this.handleKeyDown, this);
            this.enabled = true;

        }

    },
    disable: function() {
        if (this.enabled) {
            this.el.removeListener(this.eventName, this.handleKeyDown, this);
            this.enabled = false;

        }

    }

};

Ext.util.TextMetrics = function() {
    var shared;
    return {

        measure: function(el, text, fixedWidth) {
            if (!shared) {
                shared = Ext.util.TextMetrics.Instance(el, fixedWidth);

            }
            shared.bind(el);
            shared.setFixedWidth(fixedWidth || 'auto');
            return shared.getSize(text);

        },
        createInstance: function(el, fixedWidth) {
            return Ext.util.TextMetrics.Instance(el, fixedWidth);

        }

    };

} ();

Ext.util.TextMetrics.Instance = function(bindTo, fixedWidth) {
    var ml = new Ext.Element(document.createElement('div'));
    document.body.appendChild(ml.dom);
    ml.position('absolute');
    ml.setLeftTop( - 1000, -1000);
    ml.hide();

    if (fixedWidth) {
        ml.setWidth(fixedWidth);

    }

    var instance = {

        getSize: function(text) {
            ml.update(text);
            var s = ml.getSize();
            ml.update('');
            return s;

        },
        bind: function(el) {
            ml.setStyle(
            Ext.fly(el).getStyles('font-size', 'font-style', 'font-weight', 'font-family', 'line-height', 'text-transform', 'letter-spacing')
            );

        },
        setFixedWidth: function(width) {
            ml.setWidth(width);

        },
        getWidth: function(text) {
            ml.dom.style.width = 'auto';
            return this.getSize(text).width;

        },
        getHeight: function(text) {
            return this.getSize(text).height;

        }

    };

    instance.bind(bindTo);

    return instance;

};

Ext.Element.measureText = Ext.util.TextMetrics.measure;


 (function() {

    var Event = Ext.EventManager;
    var Dom = Ext.lib.Dom;


    Ext.dd.DragDrop = function(id, sGroup, config) {
        if (id) {
            this.init(id, sGroup, config);

        }

    };

    Ext.dd.DragDrop.prototype = {


        id: null,
        config: null,
        dragElId: null,
        handleElId: null,
        invalidHandleTypes: null,
        invalidHandleIds: null,
        invalidHandleClasses: null,
        startPageX: 0,
        startPageY: 0,
        groups: null,
        locked: false,
        lock: function() {
            this.locked = true;
        },
        unlock: function() {
            this.locked = false;
        },
        isTarget: true,
        padding: null,
        _domRef: null,
        __ygDragDrop: true,
        constrainX: false,
        constrainY: false,
        minX: 0,
        maxX: 0,
        minY: 0,
        maxY: 0,
        maintainOffset: false,
        xTicks: null,
        yTicks: null,
        primaryButtonOnly: true,
        available: false,
        hasOuterHandles: false,
        b4StartDrag: function(x, y) {},
startDrag: function(x, y) {},
b4Drag: function(e) {},
onDrag: function(e) {},
onDragEnter: function(e, id) {},
b4DragOver: function(e) {},
onDragOver: function(e, id) {},
b4DragOut: function(e) {},
onDragOut: function(e, id) {},
b4DragDrop: function(e) {},
onDragDrop: function(e, id) {},
onInvalidDrop: function(e) {},
b4EndDrag: function(e) {},
endDrag: function(e) {},
b4MouseDown: function(e) {},
onMouseDown: function(e) {},
onMouseUp: function(e) {},
onAvailable: function() {
            },
            defaultPadding: {
            left: 0,
            right: 0,
            top: 0,
            bottom: 0
        },
        constrainTo: function(constrainTo, pad, inContent) {
            if (typeof pad == "number") {
                pad = {
                    left: pad,
                    right: pad,
                    top: pad,
                    bottom: pad
                };

            }
            pad = pad || this.defaultPadding;
            var b = Ext.get(this.getEl()).getBox();
            var ce = Ext.get(constrainTo);
            var s = ce.getScroll();
            var c,
            cd = ce.dom;
            if (cd == document.body) {
                c = {
                    x: s.left,
                    y: s.top,
                    width: Ext.lib.Dom.getViewWidth(),
                    height: Ext.lib.Dom.getViewHeight()
                };

            } else {
                var xy = ce.getXY();
                c = {
                    x: xy[0] + s.left,
                    y: xy[1] + s.top,
                    width: cd.clientWidth,
                    height: cd.clientHeight
                };

            }


            var topSpace = b.y - c.y;
            var leftSpace = b.x - c.x;

            this.resetConstraints();
            this.setXConstraint(leftSpace - (pad.left || 0), 
            c.width - leftSpace - b.width - (pad.right || 0), 
            this.xTickSize
            );
            this.setYConstraint(topSpace - (pad.top || 0), 
            c.height - topSpace - b.height - (pad.bottom || 0), 
            this.yTickSize
            );

        },
        getEl: function() {
            if (!this._domRef) {
                this._domRef = Ext.getDom(this.id);

            }

            return this._domRef;

        },
        getDragEl: function() {
            return Ext.getDom(this.dragElId);

        },
        init: function(id, sGroup, config) {
            this.initTarget(id, sGroup, config);
            Event.on(this.id, "mousedown", this.handleMouseDown, this);


        },
        initTarget: function(id, sGroup, config) {


            this.config = config || {};


            this.DDM = Ext.dd.DDM;

            this.groups = {};



            if (typeof id !== "string") {
                id = Ext.id(id);

            }


            this.id = id;


            this.addToGroup((sGroup) ? sGroup: "default");



            this.handleElId = id;


            this.setDragElId(id);


            this.invalidHandleTypes = {
                A: "A"
            };
            this.invalidHandleIds = {};
            this.invalidHandleClasses = [];

            this.applyConfig();

            this.handleOnAvailable();

        },
        applyConfig: function() {



            this.padding = this.config.padding || [0, 0, 0, 0];
            this.isTarget = (this.config.isTarget !== false);
            this.maintainOffset = (this.config.maintainOffset);
            this.primaryButtonOnly = (this.config.primaryButtonOnly !== false);


        },
        handleOnAvailable: function() {
            this.available = true;
            this.resetConstraints();
            this.onAvailable();

        },
        setPadding: function(iTop, iRight, iBot, iLeft) {

            if (!iRight && 0 !== iRight) {
                this.padding = [iTop, iTop, iTop, iTop];

            } else if (!iBot && 0 !== iBot) {
                this.padding = [iTop, iRight, iTop, iRight];

            } else {
                this.padding = [iTop, iRight, iBot, iLeft];

            }

        },
        setInitPosition: function(diffX, diffY) {
            var el = this.getEl();

            if (!this.DDM.verifyEl(el)) {
                return;

            }

            var dx = diffX || 0;
            var dy = diffY || 0;

            var p = Dom.getXY(el);

            this.initPageX = p[0] - dx;
            this.initPageY = p[1] - dy;

            this.lastPageX = p[0];
            this.lastPageY = p[1];


            this.setStartPosition(p);

        },
        setStartPosition: function(pos) {
            var p = pos || Dom.getXY(this.getEl());
            this.deltaSetXY = null;

            this.startPageX = p[0];
            this.startPageY = p[1];

        },
        addToGroup: function(sGroup) {
            this.groups[sGroup] = true;
            this.DDM.regDragDrop(this, sGroup);

        },
        removeFromGroup: function(sGroup) {
            if (this.groups[sGroup]) {
                delete this.groups[sGroup];

            }

            this.DDM.removeDDFromGroup(this, sGroup);

        },
        setDragElId: function(id) {
            this.dragElId = id;

        },
        setHandleElId: function(id) {
            if (typeof id !== "string") {
                id = Ext.id(id);

            }
            this.handleElId = id;
            this.DDM.regHandle(this.id, id);

        },
        setOuterHandleElId: function(id) {
            if (typeof id !== "string") {
                id = Ext.id(id);

            }
            Event.on(id, "mousedown", 
            this.handleMouseDown, this);
            this.setHandleElId(id);

            this.hasOuterHandles = true;

        },
        unreg: function() {
            Event.un(this.id, "mousedown", 
            this.handleMouseDown);
            this._domRef = null;
            this.DDM._remove(this);

        },
        destroy: function() {
            this.unreg();

        },
        isLocked: function() {
            return (this.DDM.isLocked() || this.locked);

        },
        handleMouseDown: function(e, oDD) {
            if (this.primaryButtonOnly && e.button != 0) {
                return;

            }

            if (this.isLocked()) {
                return;

            }

            this.DDM.refreshCache(this.groups);

            var pt = new Ext.lib.Point(Ext.lib.Event.getPageX(e), Ext.lib.Event.getPageY(e));
            if (!this.hasOuterHandles && !this.DDM.isOverTarget(pt, this)) {
                } else {
                if (this.clickValidator(e)) {


                    this.setStartPosition();


                    this.b4MouseDown(e);
                    this.onMouseDown(e);

                    this.DDM.handleMouseDown(e, this);

                    this.DDM.stopEvent(e);

                } else {


                    }

            }

        },
        clickValidator: function(e) {
            var target = e.getTarget();
            return (this.isValidHandleChild(target) && 
            (this.id == this.handleElId || 
            this.DDM.handleWasClicked(target, this.id)));

        },
        addInvalidHandleType: function(tagName) {
            var type = tagName.toUpperCase();
            this.invalidHandleTypes[type] = type;

        },
        addInvalidHandleId: function(id) {
            if (typeof id !== "string") {
                id = Ext.id(id);

            }
            this.invalidHandleIds[id] = id;

        },
        addInvalidHandleClass: function(cssClass) {
            this.invalidHandleClasses.push(cssClass);

        },
        removeInvalidHandleType: function(tagName) {
            var type = tagName.toUpperCase();

            delete this.invalidHandleTypes[type];

        },
        removeInvalidHandleId: function(id) {
            if (typeof id !== "string") {
                id = Ext.id(id);

            }
            delete this.invalidHandleIds[id];

        },
        removeInvalidHandleClass: function(cssClass) {
            for (var i = 0, len = this.invalidHandleClasses.length; i < len; ++i) {
                if (this.invalidHandleClasses[i] == cssClass) {
                    delete this.invalidHandleClasses[i];

                }

            }

        },
        isValidHandleChild: function(node) {

            var valid = true;

            var nodeName;
            try {
                nodeName = node.nodeName.toUpperCase();

            } catch(e) {
                nodeName = node.nodeName;

            }
            valid = valid && !this.invalidHandleTypes[nodeName];
            valid = valid && !this.invalidHandleIds[node.id];

            for (var i = 0, len = this.invalidHandleClasses.length; valid && i < len; ++i) {
                valid = !Dom.hasClass(node, this.invalidHandleClasses[i]);

            }


            return valid;


        },
        setXTicks: function(iStartX, iTickSize) {
            this.xTicks = [];
            this.xTickSize = iTickSize;

            var tickMap = {};

            for (var i = this.initPageX; i >= this.minX; i = i - iTickSize) {
                if (!tickMap[i]) {
                    this.xTicks[this.xTicks.length] = i;
                    tickMap[i] = true;

                }

            }

            for (i = this.initPageX; i <= this.maxX; i = i + iTickSize) {
                if (!tickMap[i]) {
                    this.xTicks[this.xTicks.length] = i;
                    tickMap[i] = true;

                }

            }

            this.xTicks.sort(this.DDM.numericSort);

        },
        setYTicks: function(iStartY, iTickSize) {
            this.yTicks = [];
            this.yTickSize = iTickSize;

            var tickMap = {};

            for (var i = this.initPageY; i >= this.minY; i = i - iTickSize) {
                if (!tickMap[i]) {
                    this.yTicks[this.yTicks.length] = i;
                    tickMap[i] = true;

                }

            }

            for (i = this.initPageY; i <= this.maxY; i = i + iTickSize) {
                if (!tickMap[i]) {
                    this.yTicks[this.yTicks.length] = i;
                    tickMap[i] = true;

                }

            }

            this.yTicks.sort(this.DDM.numericSort);

        },
        setXConstraint: function(iLeft, iRight, iTickSize) {
            this.leftConstraint = iLeft;
            this.rightConstraint = iRight;

            this.minX = this.initPageX - iLeft;
            this.maxX = this.initPageX + iRight;
            if (iTickSize) {
                this.setXTicks(this.initPageX, iTickSize);
            }

            this.constrainX = true;

        },
        clearConstraints: function() {
            this.constrainX = false;
            this.constrainY = false;
            this.clearTicks();

        },
        clearTicks: function() {
            this.xTicks = null;
            this.yTicks = null;
            this.xTickSize = 0;
            this.yTickSize = 0;

        },
        setYConstraint: function(iUp, iDown, iTickSize) {
            this.topConstraint = iUp;
            this.bottomConstraint = iDown;

            this.minY = this.initPageY - iUp;
            this.maxY = this.initPageY + iDown;
            if (iTickSize) {
                this.setYTicks(this.initPageY, iTickSize);
            }

            this.constrainY = true;


        },
        resetConstraints: function() {



            if (this.initPageX || this.initPageX === 0) {

                var dx = (this.maintainOffset) ? this.lastPageX - this.initPageX: 0;
                var dy = (this.maintainOffset) ? this.lastPageY - this.initPageY: 0;

                this.setInitPosition(dx, dy);



            } else {
                this.setInitPosition();

            }

            if (this.constrainX) {
                this.setXConstraint(this.leftConstraint, 
                this.rightConstraint, 
                this.xTickSize);

            }

            if (this.constrainY) {
                this.setYConstraint(this.topConstraint, 
                this.bottomConstraint, 
                this.yTickSize);

            }

        },
        getTick: function(val, tickArray) {

            if (!tickArray) {


                return val;

            } else if (tickArray[0] >= val) {


                return tickArray[0];

            } else {
                for (var i = 0, len = tickArray.length; i < len; ++i) {
                    var next = i + 1;
                    if (tickArray[next] && tickArray[next] >= val) {
                        var diff1 = val - tickArray[i];
                        var diff2 = tickArray[next] - val;
                        return (diff2 > diff1) ? tickArray[i] : tickArray[next];

                    }

                }



                return tickArray[tickArray.length - 1];

            }

        },
        toString: function() {
            return ("DragDrop " + this.id);

        }


    };


})();




if (!Ext.dd.DragDropMgr) {


    Ext.dd.DragDropMgr = function() {

        var Event = Ext.EventManager;

        return {


            ids: {},
            handleIds: {},
            dragCurrent: null,


dragOvers: {},
deltaX: 0,


deltaY: 0,


preventDefault: true,


stopPropagation: true,


initialized: false,


locked: false,


init: function() {
                this.initialized = true;

            },
            POINT: 0,
            INTERSECT: 1,
            mode: 0,
            _execOnAll: function(sMethod, args) {
                for (var i in this.ids) {
                    for (var j in this.ids[i]) {
                        var oDD = this.ids[i][j];
                        if (!this.isTypeOfDD(oDD)) {
                            continue;

                        }
                        oDD[sMethod].apply(oDD, args);

                    }

                }

            },
            _onLoad: function() {

                this.init();


                Event.on(document, "mouseup", this.handleMouseUp, this, true);
                Event.on(document, "mousemove", this.handleMouseMove, this, true);
                Event.on(window, "unload", this._onUnload, this, true);
                Event.on(window, "resize", this._onResize, this, true);



            },
            _onResize: function(e) {
                this._execOnAll("resetConstraints", []);

            },
            lock: function() {
                this.locked = true;
            },
            unlock: function() {
                this.locked = false;
            },
            isLocked: function() {
                return this.locked;
            },
            locationCache: {},
            useCache: true,


			clickPixelThresh: 3,


			clickTimeThresh: 350,


			dragThreshMet: false,


			clickTimeout: null,


			startX: 0,


			startY: 0,


		regDragDrop: function(oDD, sGroup) {
                if (!this.initialized) {
                    this.init();
                }

                if (!this.ids[sGroup]) {
                    this.ids[sGroup] = {};

                }
                this.ids[sGroup][oDD.id] = oDD;

            },
            removeDDFromGroup: function(oDD, sGroup) {
                if (!this.ids[sGroup]) {
                    this.ids[sGroup] = {};

                }

                var obj = this.ids[sGroup];
                if (obj && obj[oDD.id]) {
                    delete obj[oDD.id];

                }

            },
            _remove: function(oDD) {
                for (var g in oDD.groups) {
                    if (g && this.ids[g][oDD.id]) {
                        delete this.ids[g][oDD.id];

                    }

                }
                delete this.handleIds[oDD.id];

            },
            regHandle: function(sDDId, sHandleId) {
                if (!this.handleIds[sDDId]) {
                    this.handleIds[sDDId] = {};

                }
                this.handleIds[sDDId][sHandleId] = sHandleId;

            },
            isDragDrop: function(id) {
                return (this.getDDById(id)) ? true: false;

            },
            getRelated: function(p_oDD, bTargetsOnly) {
                var oDDs = [];
                for (var i in p_oDD.groups) {
                    for (j in this.ids[i]) {
                        var dd = this.ids[i][j];
                        if (!this.isTypeOfDD(dd)) {
                            continue;

                        }
                        if (!bTargetsOnly || dd.isTarget) {
                            oDDs[oDDs.length] = dd;

                        }

                    }

                }

                return oDDs;

            },
            isLegalTarget: function(oDD, oTargetDD) {
                var targets = this.getRelated(oDD, true);
                for (var i = 0, len = targets.length; i < len; ++i) {
                    if (targets[i].id == oTargetDD.id) {
                        return true;

                    }

                }

                return false;

            },
            isTypeOfDD: function(oDD) {
                return (oDD && oDD.__ygDragDrop);

            },
            isHandle: function(sDDId, sHandleId) {
                return (this.handleIds[sDDId] && 
                this.handleIds[sDDId][sHandleId]);

            },
            getDDById: function(id) {
                for (var i in this.ids) {
                    if (this.ids[i][id]) {
                        return this.ids[i][id];

                    }

                }
                return null;

            },
            handleMouseDown: function(e, oDD) {
                if (Ext.QuickTips) {
                    Ext.QuickTips.disable();

                }
                this.currentTarget = e.getTarget();

                this.dragCurrent = oDD;

                var el = oDD.getEl();


                this.startX = e.getPageX();
                this.startY = e.getPageY();

                this.deltaX = this.startX - el.offsetLeft;
                this.deltaY = this.startY - el.offsetTop;

                this.dragThreshMet = false;

                this.clickTimeout = setTimeout(
                function() {
                    var DDM = Ext.dd.DDM;
                    DDM.startDrag(DDM.startX, DDM.startY);

                },
                this.clickTimeThresh);

            },
            startDrag: function(x, y) {
                clearTimeout(this.clickTimeout);
                if (this.dragCurrent) {
                    this.dragCurrent.b4StartDrag(x, y);
                    this.dragCurrent.startDrag(x, y);

                }
                this.dragThreshMet = true;

            },
            handleMouseUp: function(e) {

                if (Ext.QuickTips) {
                    Ext.QuickTips.enable();

                }
                if (!this.dragCurrent) {
                    return;

                }

                clearTimeout(this.clickTimeout);

                if (this.dragThreshMet) {
                    this.fireEvents(e, true);

                } else {
                    }

                this.stopDrag(e);

                this.stopEvent(e);

            },
            stopEvent: function(e) {
                if (this.stopPropagation) {
                    e.stopPropagation();

                }

                if (this.preventDefault) {
                    e.preventDefault();

                }

            },
            stopDrag: function(e) {

                if (this.dragCurrent) {
                    if (this.dragThreshMet) {
                        this.dragCurrent.b4EndDrag(e);
                        this.dragCurrent.endDrag(e);

                    }

                    this.dragCurrent.onMouseUp(e);

                }

                this.dragCurrent = null;
                this.dragOvers = {};

            },
            handleMouseMove: function(e) {
                if (!this.dragCurrent) {
                    return true;

                }




                if (Ext.isIE && (e.button !== 0 && e.button !== 1 && e.button !== 2)) {
                    this.stopEvent(e);
                    return this.handleMouseUp(e);

                }

                if (!this.dragThreshMet) {
                    var diffX = Math.abs(this.startX - e.getPageX());
                    var diffY = Math.abs(this.startY - e.getPageY());
                    if (diffX > this.clickPixelThresh || 
                    diffY > this.clickPixelThresh) {
                        this.startDrag(this.startX, this.startY);

                    }

                }

                if (this.dragThreshMet) {
                    this.dragCurrent.b4Drag(e);
                    this.dragCurrent.onDrag(e);
                    if (!this.dragCurrent.moveOnly) {
                        this.fireEvents(e, false);

                    }

                }

                this.stopEvent(e);

                return true;

            },
            fireEvents: function(e, isDrop) {
                var dc = this.dragCurrent;



                if (!dc || dc.isLocked()) {
                    return;

                }

                var pt = e.getPoint();


                var oldOvers = [];

                var outEvts = [];
                var overEvts = [];
                var dropEvts = [];
                var enterEvts = [];



                for (var i in this.dragOvers) {

                    var ddo = this.dragOvers[i];

                    if (!this.isTypeOfDD(ddo)) {
                        continue;

                    }

                    if (!this.isOverTarget(pt, ddo, this.mode)) {
                        outEvts.push(ddo);

                    }

                    oldOvers[i] = true;
                    delete this.dragOvers[i];

                }

                for (var sGroup in dc.groups) {

                    if ("string" != typeof sGroup) {
                        continue;

                    }

                    for (i in this.ids[sGroup]) {
                        var oDD = this.ids[sGroup][i];
                        if (!this.isTypeOfDD(oDD)) {
                            continue;

                        }

                        if (oDD.isTarget && !oDD.isLocked() && oDD != dc) {
                            if (this.isOverTarget(pt, oDD, this.mode)) {

                                if (isDrop) {
                                    dropEvts.push(oDD);


                                } else {


                                    if (!oldOvers[oDD.id]) {
                                        enterEvts.push(oDD);


                                    } else {
                                        overEvts.push(oDD);

                                    }

                                    this.dragOvers[oDD.id] = oDD;

                                }

                            }

                        }

                    }

                }

                if (this.mode) {
                    if (outEvts.length) {
                        dc.b4DragOut(e, outEvts);
                        dc.onDragOut(e, outEvts);

                    }

                    if (enterEvts.length) {
                        dc.onDragEnter(e, enterEvts);

                    }

                    if (overEvts.length) {
                        dc.b4DragOver(e, overEvts);
                        dc.onDragOver(e, overEvts);

                    }

                    if (dropEvts.length) {
                        dc.b4DragDrop(e, dropEvts);
                        dc.onDragDrop(e, dropEvts);

                    }


                } else {

                    var len = 0;
                    for (i = 0, len = outEvts.length; i < len; ++i) {
                        dc.b4DragOut(e, outEvts[i].id);
                        dc.onDragOut(e, outEvts[i].id);

                    }


                    for (i = 0, len = enterEvts.length; i < len; ++i) {

                        dc.onDragEnter(e, enterEvts[i].id);

                    }


                    for (i = 0, len = overEvts.length; i < len; ++i) {
                        dc.b4DragOver(e, overEvts[i].id);
                        dc.onDragOver(e, overEvts[i].id);

                    }


                    for (i = 0, len = dropEvts.length; i < len; ++i) {
                        dc.b4DragDrop(e, dropEvts[i].id);
                        dc.onDragDrop(e, dropEvts[i].id);

                    }


                }


                if (isDrop && !dropEvts.length) {
                    dc.onInvalidDrop(e);

                }


            },
            getBestMatch: function(dds) {
                var winner = null;






                var len = dds.length;

                if (len == 1) {
                    winner = dds[0];

                } else {

                    for (var i = 0; i < len; ++i) {
                        var dd = dds[i];



                        if (dd.cursorIsOver) {
                            winner = dd;
                            break;


                        } else {
                            if (!winner || 
                            winner.overlap.getArea() < dd.overlap.getArea()) {
                                winner = dd;

                            }

                        }

                    }

                }

                return winner;

            },
            refreshCache: function(groups) {
                for (var sGroup in groups) {
                    if ("string" != typeof sGroup) {
                        continue;

                    }
                    for (var i in this.ids[sGroup]) {
                        var oDD = this.ids[sGroup][i];

                        if (this.isTypeOfDD(oDD)) {

                            var loc = this.getLocation(oDD);
                            if (loc) {
                                this.locationCache[oDD.id] = loc;

                            } else {
                                delete this.locationCache[oDD.id];




                            }

                        }

                    }

                }

            },
            verifyEl: function(el) {
                if (el) {
                    var parent;
                    if (Ext.isIE) {
                        try {
                            parent = el.offsetParent;

                        } catch(e) {}

                    } else {
                        parent = el.offsetParent;

                    }
                    if (parent) {
                        return true;

                    }

                }

                return false;

            },
            getLocation: function(oDD) {
                if (!this.isTypeOfDD(oDD)) {
                    return null;

                }

                var el = oDD.getEl(),
                pos,
                x1,
                x2,
                y1,
                y2,
                t,
                r,
                b,
                l;

                try {
                    pos = Ext.lib.Dom.getXY(el);

                } catch(e) {}

                if (!pos) {
                    return null;

                }

                x1 = pos[0];
                x2 = x1 + el.offsetWidth;
                y1 = pos[1];
                y2 = y1 + el.offsetHeight;

                t = y1 - oDD.padding[0];
                r = x2 + oDD.padding[1];
                b = y2 + oDD.padding[2];
                l = x1 - oDD.padding[3];

                return new Ext.lib.Region(t, r, b, l);

            },
            isOverTarget: function(pt, oTarget, intersect) {

                var loc = this.locationCache[oTarget.id];
                if (!loc || !this.useCache) {
                    loc = this.getLocation(oTarget);
                    this.locationCache[oTarget.id] = loc;


                }

                if (!loc) {
                    return false;

                }

                oTarget.cursorIsOver = loc.contains(pt);






                var dc = this.dragCurrent;
                if (!dc || !dc.getTargetCoord || 
                (!intersect && !dc.constrainX && !dc.constrainY)) {
                    return oTarget.cursorIsOver;

                }

                oTarget.overlap = null;





                var pos = dc.getTargetCoord(pt.x, pt.y);

                var el = dc.getDragEl();
                var curRegion = new Ext.lib.Region(pos.y, 
                pos.x + el.offsetWidth, 
                pos.y + el.offsetHeight, 
                pos.x);

                var overlap = curRegion.intersect(loc);

                if (overlap) {
                    oTarget.overlap = overlap;
                    return (intersect) ? true: oTarget.cursorIsOver;

                } else {
                    return false;

                }

            },
            _onUnload: function(e, me) {
                Ext.dd.DragDropMgr.unregAll();

            },
            unregAll: function() {

                if (this.dragCurrent) {
                    this.stopDrag();
                    this.dragCurrent = null;

                }

                this._execOnAll("unreg", []);

                for (var i in this.elementCache) {
                    delete this.elementCache[i];

                }

                this.elementCache = {};
                this.ids = {};

            },
            elementCache: {},
            getElWrapper: function(id) {
                var oWrapper = this.elementCache[id];
                if (!oWrapper || !oWrapper.el) {
                    oWrapper = this.elementCache[id] = 
                    new this.ElementWrapper(Ext.getDom(id));

                }
                return oWrapper;

            },
            getElement: function(id) {
                return Ext.getDom(id);

            },
            getCss: function(id) {
                var el = Ext.getDom(id);
                return (el) ? el.style: null;

            },
            ElementWrapper: function(el) {

                this.el = el || null;

                this.id = this.el && el.id;

                this.css = this.el && el.style;

            },
            getPosX: function(el) {
                return Ext.lib.Dom.getX(el);

            },
            getPosY: function(el) {
                return Ext.lib.Dom.getY(el);

            },
            swapNode: function(n1, n2) {
                if (n1.swapNode) {
                    n1.swapNode(n2);

                } else {
                    var p = n2.parentNode;
                    var s = n2.nextSibling;

                    if (s == n1) {
                        p.insertBefore(n1, n2);

                    } else if (n2 == n1.nextSibling) {
                        p.insertBefore(n2, n1);

                    } else {
                        n1.parentNode.replaceChild(n2, n1);
                        p.insertBefore(n1, s);

                    }

                }

            },
            getScroll: function() {
                var t,
                l,
                dde = document.documentElement,
                db = document.body;
                if (dde && (dde.scrollTop || dde.scrollLeft)) {
                    t = dde.scrollTop;
                    l = dde.scrollLeft;

                } else if (db) {
                    t = db.scrollTop;
                    l = db.scrollLeft;

                } else {

                    }
                return {
                    top: t,
                    left: l
                };

            },
            getStyle: function(el, styleProp) {
                return Ext.fly(el).getStyle(styleProp);

            },
            getScrollTop: function() {
                return this.getScroll().top;
            },
            getScrollLeft: function() {
                return this.getScroll().left;
            },
            moveToEl: function(moveEl, targetEl) {
                var aCoord = Ext.lib.Dom.getXY(targetEl);
                Ext.lib.Dom.setXY(moveEl, aCoord);

            },
            numericSort: function(a, b) {
                return (a - b);
            },
            _timeoutCount: 0,
            _addListeners: function() {
                var DDM = Ext.dd.DDM;
                if (Ext.lib.Event && document) {
                    DDM._onLoad();

                } else {
                    if (DDM._timeoutCount > 2000) {
                        } else {
                        setTimeout(DDM._addListeners, 10);
                        if (document && document.body) {
                            DDM._timeoutCount += 1;

                        }

                    }

                }

            },
            handleWasClicked: function(node, id) {
                if (this.isHandle(id, node.id)) {
                    return true;

                } else {

                    var p = node.parentNode;

                    while (p) {
                        if (this.isHandle(id, p.id)) {
                            return true;

                        } else {
                            p = p.parentNode;

                        }

                    }

                }

                return false;

            }


        };


    } ();


    Ext.dd.DDM = Ext.dd.DragDropMgr;
    Ext.dd.DDM._addListeners();


}


Ext.dd.DD = function(id, sGroup, config) {
    if (id) {
        this.init(id, sGroup, config);

    }

};

Ext.extend(Ext.dd.DD, Ext.dd.DragDrop, {


    scroll: true,
    autoOffset: function(iPageX, iPageY) {
        var x = iPageX - this.startPageX;
        var y = iPageY - this.startPageY;
        this.setDelta(x, y);

    },
    setDelta: function(iDeltaX, iDeltaY) {
        this.deltaX = iDeltaX;
        this.deltaY = iDeltaY;

    },
    setDragElPos: function(iPageX, iPageY) {



        var el = this.getDragEl();
        this.alignElWithMouse(el, iPageX, iPageY);

    },
    alignElWithMouse: function(el, iPageX, iPageY) {
        var oCoord = this.getTargetCoord(iPageX, iPageY);
        var fly = el.dom ? el: Ext.fly(el, '_dd');
        if (!this.deltaSetXY) {
            var aCoord = [oCoord.x, oCoord.y];
            fly.setXY(aCoord);
            var newLeft = fly.getLeft(true);
            var newTop = fly.getTop(true);
            this.deltaSetXY = [newLeft - oCoord.x, newTop - oCoord.y];

        } else {
            fly.setLeftTop(oCoord.x + this.deltaSetXY[0], oCoord.y + this.deltaSetXY[1]);

        }

        this.cachePosition(oCoord.x, oCoord.y);
        this.autoScroll(oCoord.x, oCoord.y, el.offsetHeight, el.offsetWidth);
        return oCoord;

    },
    cachePosition: function(iPageX, iPageY) {
        if (iPageX) {
            this.lastPageX = iPageX;
            this.lastPageY = iPageY;

        } else {
            var aCoord = Ext.lib.Dom.getXY(this.getEl());
            this.lastPageX = aCoord[0];
            this.lastPageY = aCoord[1];

        }

    },
    autoScroll: function(x, y, h, w) {

        if (this.scroll) {

            var clientH = Ext.lib.Dom.getViewHeight();


            var clientW = Ext.lib.Dom.getViewWidth();


            var st = this.DDM.getScrollTop();


            var sl = this.DDM.getScrollLeft();


            var bot = h + y;


            var right = w + x;




            var toBot = (clientH + st - y - this.deltaY);


            var toRight = (clientW + sl - x - this.deltaX);




            var thresh = 40;




            var scrAmt = (document.all) ? 80: 30;



            if (bot > clientH && toBot < thresh) {
                window.scrollTo(sl, st + scrAmt);

            }



            if (y < st && st > 0 && y - st < thresh) {
                window.scrollTo(sl, st - scrAmt);

            }



            if (right > clientW && toRight < thresh) {
                window.scrollTo(sl + scrAmt, st);

            }



            if (x < sl && sl > 0 && x - sl < thresh) {
                window.scrollTo(sl - scrAmt, st);

            }

        }

    },
    getTargetCoord: function(iPageX, iPageY) {


        var x = iPageX - this.deltaX;
        var y = iPageY - this.deltaY;

        if (this.constrainX) {
            if (x < this.minX) {
                x = this.minX;
            }
            if (x > this.maxX) {
                x = this.maxX;
            }

        }

        if (this.constrainY) {
            if (y < this.minY) {
                y = this.minY;
            }
            if (y > this.maxY) {
                y = this.maxY;
            }

        }

        x = this.getTick(x, this.xTicks);
        y = this.getTick(y, this.yTicks);


        return {
            x: x,
            y: y
        };

    },
    applyConfig: function() {
        Ext.dd.DD.superclass.applyConfig.call(this);
        this.scroll = (this.config.scroll !== false);

    },
    b4MouseDown: function(e) {

        this.autoOffset(e.getPageX(), 
        e.getPageY());

    },
    b4Drag: function(e) {
        this.setDragElPos(e.getPageX(), 
        e.getPageY());

    },
    toString: function() {
        return ("DD " + this.id);

    }







});

Ext.dd.DDProxy = function(id, sGroup, config) {
    if (id) {
        this.init(id, sGroup, config);
        this.initFrame();

    }

};


Ext.dd.DDProxy.dragElId = "ygddfdiv";

Ext.extend(Ext.dd.DDProxy, Ext.dd.DD, {


    resizeFrame: true,
    centerFrame: false,
    createFrame: function() {
        var self = this;
        var body = document.body;

        if (!body || !body.firstChild) {
            setTimeout(function() {
                self.createFrame();
            },
            50);
            return;

        }

        var div = this.getDragEl();

        if (!div) {
            div = document.createElement("div");
            div.id = this.dragElId;
            var s = div.style;

            s.position = "absolute";
            s.visibility = "hidden";
            s.cursor = "move";
            s.border = "2px solid #aaa";
            s.zIndex = 999;




            body.insertBefore(div, body.firstChild);

        }

    },
    initFrame: function() {
        this.createFrame();

    },
    applyConfig: function() {
        Ext.dd.DDProxy.superclass.applyConfig.call(this);

        this.resizeFrame = (this.config.resizeFrame !== false);
        this.centerFrame = (this.config.centerFrame);
        this.setDragElId(this.config.dragElId || Ext.dd.DDProxy.dragElId);

    },
    showFrame: function(iPageX, iPageY) {
        var el = this.getEl();
        var dragEl = this.getDragEl();
        var s = dragEl.style;

        this._resizeProxy();

        if (this.centerFrame) {
            this.setDelta(Math.round(parseInt(s.width, 10) / 2), 
            Math.round(parseInt(s.height, 10) / 2));

        }

        this.setDragElPos(iPageX, iPageY);

        Ext.fly(dragEl).show();

    },
    _resizeProxy: function() {
        if (this.resizeFrame) {
            var el = this.getEl();
            Ext.fly(this.getDragEl()).setSize(el.offsetWidth, el.offsetHeight);

        }

    },
    b4MouseDown: function(e) {
        var x = e.getPageX();
        var y = e.getPageY();
        this.autoOffset(x, y);
        this.setDragElPos(x, y);

    },
    b4StartDrag: function(x, y) {

        this.showFrame(x, y);

    },
    b4EndDrag: function(e) {
        Ext.fly(this.getDragEl()).hide();

    },
    

endDrag: function(e) {

        var lel = this.getEl();
        var del = this.getDragEl();


        del.style.visibility = "";

        this.beforeMove();


        lel.style.visibility = "hidden";
        Ext.dd.DDM.moveToEl(lel, del);
        del.style.visibility = "hidden";
        lel.style.visibility = "";

        this.afterDrag();

    },
    beforeMove: function() {

        },
        afterDrag: function() {

        },
        toString: function() {
        return ("DDProxy " + this.id);

    }


});

Ext.dd.DDTarget = function(id, sGroup, config) {
    if (id) {
        this.initTarget(id, sGroup, config);

    }

};


Ext.extend(Ext.dd.DDTarget, Ext.dd.DragDrop, {
    toString: function() {
        return ("DDTarget " + this.id);

    }

});

Ext.dd.DragTracker = function(config) {
    Ext.apply(this, config);
    this.addEvents(
    'mousedown', 
    'mouseup', 
    'mousemove', 
    'dragstart', 
    'dragend', 
    'drag'
    );

    this.dragRegion = new Ext.lib.Region(0, 0, 0, 0);

    if (this.el) {
        this.initEl(this.el);

    }

}

Ext.extend(Ext.dd.DragTracker, Ext.util.Observable, {
    active: false,
    tolerance: 5,
    autoStart: false,
    initEl: function(el) {
        this.el = Ext.get(el);
        el.on('mousedown', this.onMouseDown, this, 
        this.delegate ? {
            delegate: this.delegate
        }: undefined);

    },
    destroy: function() {
        this.el.un('mousedown', this.onMouseDown, this);

    },
    onMouseDown: function(e, target) {
        if (this.fireEvent('mousedown', this, e) !== false && this.onBeforeStart(e) !== false) {
            this.startXY = this.lastXY = e.getXY();
            this.dragTarget = this.delegate ? target: this.el.dom;
            e.preventDefault();
            var doc = Ext.getDoc();
            doc.on('mouseup', this.onMouseUp, this);
            doc.on('mousemove', this.onMouseMove, this);
            doc.on('selectstart', this.stopSelect, this);
            if (this.autoStart) {
                this.timer = this.triggerStart.defer(this.autoStart === true ? 1000: this.autoStart, this);

            }

        }

    },
    onMouseMove: function(e, target) {
        e.preventDefault();
        var xy = e.getXY(),
        s = this.startXY;
        this.lastXY = xy;
        if (!this.active) {
            if (Math.abs(s[0] - xy[0]) > this.tolerance || Math.abs(s[1] - xy[1]) > this.tolerance) {
                this.triggerStart();

            } else {
                return;

            }

        }
        this.fireEvent('mousemove', this, e);
        this.onDrag(e);
        this.fireEvent('drag', this, e);

    },
    onMouseUp: function(e) {
        var doc = Ext.getDoc();
        doc.un('mousemove', this.onMouseMove, this);
        doc.un('mouseup', this.onMouseUp, this);
        doc.un('selectstart', this.stopSelect, this);
        e.preventDefault();
        this.clearStart();
        this.active = false;
        delete this.elRegion;
        this.fireEvent('mouseup', this, e);
        this.onEnd(e);
        this.fireEvent('dragend', this, e);

    },
    triggerStart: function(isTimer) {
        this.clearStart();
        this.active = true;
        this.onStart(this.startXY);
        this.fireEvent('dragstart', this, this.startXY);

    },
    clearStart: function() {
        if (this.timer) {
            clearTimeout(this.timer);
            delete this.timer;

        }

    },
    stopSelect: function(e) {
        e.stopEvent();
        return false;

    },
    onBeforeStart: function(e) {

        },
        onStart: function(xy) {

        },
        onDrag: function(e) {

        },
        onEnd: function(e) {

        },
        getDragTarget: function() {
        return this.dragTarget;

    },
    getDragCt: function() {
        return this.el;

    },
    getXY: function(constrain) {
        return constrain ? 
        this.constrainModes[constrain].call(this, this.lastXY) : this.lastXY;

    },
    getOffset: function(constrain) {
        var xy = this.getXY(constrain);
        var s = this.startXY;
        return [s[0] - xy[0], s[1] - xy[1]];

    },
    constrainModes: {
        'point': function(xy) {

            if (!this.elRegion) {
                this.elRegion = this.getDragCt().getRegion();

            }

            var dr = this.dragRegion;

            dr.left = xy[0];
            dr.top = xy[1];
            dr.right = xy[0];
            dr.bottom = xy[1];

            dr.constrainTo(this.elRegion);

            return [dr.left, dr.top];

        }

    }

});

Ext.dd.ScrollManager = function() {
    var ddm = Ext.dd.DragDropMgr;
    var els = {};
    var dragEl = null;
    var proc = {};

    var onStop = function(e) {
        dragEl = null;
        clearProc();

    };

    var triggerRefresh = function() {
        if (ddm.dragCurrent) {
            ddm.refreshCache(ddm.dragCurrent.groups);

        }

    };

    var doScroll = function() {
        if (ddm.dragCurrent) {
            var dds = Ext.dd.ScrollManager;
            var inc = proc.el.ddScrollConfig ? 
            proc.el.ddScrollConfig.increment: dds.increment;
            if (!dds.animate) {
                if (proc.el.scroll(proc.dir, inc)) {
                    triggerRefresh();

                }

            } else {
                proc.el.scroll(proc.dir, inc, true, dds.animDuration, triggerRefresh);

            }

        }

    };

    var clearProc = function() {
        if (proc.id) {
            clearInterval(proc.id);

        }
        proc.id = 0;
        proc.el = null;
        proc.dir = "";

    };

    var startProc = function(el, dir) {
        clearProc();
        proc.el = el;
        proc.dir = dir;
        proc.id = setInterval(doScroll, Ext.dd.ScrollManager.frequency);

    };

    var onFire = function(e, isDrop) {
        if (isDrop || !ddm.dragCurrent) {
            return;
        }
        var dds = Ext.dd.ScrollManager;
        if (!dragEl || dragEl != ddm.dragCurrent) {
            dragEl = ddm.dragCurrent;

            dds.refreshCache();

        }

        var xy = Ext.lib.Event.getXY(e);
        var pt = new Ext.lib.Point(xy[0], xy[1]);
        for (var id in els) {
            var el = els[id],
            r = el._region;
            var c = el.ddScrollConfig ? el.ddScrollConfig: dds;
            if (r && r.contains(pt) && el.isScrollable()) {
                if (r.bottom - pt.y <= c.vthresh) {
                    if (proc.el != el) {
                        startProc(el, "down");

                    }
                    return;

                } else if (r.right - pt.x <= c.hthresh) {
                    if (proc.el != el) {
                        startProc(el, "left");

                    }
                    return;

                } else if (pt.y - r.top <= c.vthresh) {
                    if (proc.el != el) {
                        startProc(el, "up");

                    }
                    return;

                } else if (pt.x - r.left <= c.hthresh) {
                    if (proc.el != el) {
                        startProc(el, "right");

                    }
                    return;

                }

            }

        }
        clearProc();

    };

    ddm.fireEvents = ddm.fireEvents.createSequence(onFire, ddm);
    ddm.stopDrag = ddm.stopDrag.createSequence(onStop, ddm);

    return {

        register: function(el) {
            if (Ext.isArray(el)) {
                for (var i = 0, len = el.length; i < len; i++) {
                    this.register(el[i]);

                }

            } else {
                el = Ext.get(el);
                els[el.id] = el;

            }

        },
        unregister: function(el) {
            if (Ext.isArray(el)) {
                for (var i = 0, len = el.length; i < len; i++) {
                    this.unregister(el[i]);

                }

            } else {
                el = Ext.get(el);
                delete els[el.id];

            }

        },
        vthresh: 25,
        hthresh: 25,
        
increment: 100,
        
frequency: 500,
        
animate: true,
        
animDuration: .4,
        
refreshCache: function() {
            for (var id in els) {
                if (typeof els[id] == 'object') {
                    els[id]._region = els[id].getRegion();

                }

            }

        }

    };

} ();

Ext.dd.Registry = function() {
    var elements = {};
    var handles = {};
    var autoIdSeed = 0;

    var getId = function(el, autogen) {
        if (typeof el == "string") {
            return el;

        }
        var id = el.id;
        if (!id && autogen !== false) {
            id = "extdd-" + (++autoIdSeed);
            el.id = id;

        }
        return id;

    };

    return {

        register: function(el, data) {
            data = data || {};
            if (typeof el == "string") {
                el = document.getElementById(el);

            }
            data.ddel = el;
            elements[getId(el)] = data;
            if (data.isHandle !== false) {
                handles[data.ddel.id] = data;

            }
            if (data.handles) {
                var hs = data.handles;
                for (var i = 0, len = hs.length; i < len; i++) {
                    handles[getId(hs[i])] = data;

                }

            }

        },
        unregister: function(el) {
            var id = getId(el, false);
            var data = elements[id];
            if (data) {
                delete elements[id];
                if (data.handles) {
                    var hs = data.handles;
                    for (var i = 0, len = hs.length; i < len; i++) {
                        delete handles[getId(hs[i], false)];

                    }

                }

            }

        },
        getHandle: function(id) {
            if (typeof id != "string") {
                id = id.id;

            }
            return handles[id];

        },
        getHandleFromEvent: function(e) {
            var t = Ext.lib.Event.getTarget(e);
            return t ? handles[t.id] : null;

        },
        getTarget: function(id) {
            if (typeof id != "string") {
                id = id.id;

            }
            return elements[id];

        },
        getTargetFromEvent: function(e) {
            var t = Ext.lib.Event.getTarget(e);
            return t ? elements[t.id] || handles[t.id] : null;

        }

    };

} ();

Ext.dd.StatusProxy = function(config) {
    Ext.apply(this, config);
    this.id = this.id || Ext.id();
    this.el = new Ext.Layer({
        dh: {
            id: this.id,
            tag: "div",
            cls: "x-dd-drag-proxy " + this.dropNotAllowed,
            children: [
            {
                tag: "div",
                cls: "x-dd-drop-icon"
            },
            {
                tag: "div",
                cls: "x-dd-drag-ghost"
            }
            ]

        },
        shadow: !config || config.shadow !== false

    });
    this.ghost = Ext.get(this.el.dom.childNodes[1]);
    this.dropStatus = this.dropNotAllowed;

};

Ext.dd.StatusProxy.prototype = {

    dropAllowed: "x-dd-drop-ok",
        dropNotAllowed: "x-dd-drop-nodrop",
        
setStatus: function(cssClass) {
        cssClass = cssClass || this.dropNotAllowed;
        if (this.dropStatus != cssClass) {
            this.el.replaceClass(this.dropStatus, cssClass);
            this.dropStatus = cssClass;

        }

    },
    reset: function(clearGhost) {
        this.el.dom.className = "x-dd-drag-proxy " + this.dropNotAllowed;
        this.dropStatus = this.dropNotAllowed;
        if (clearGhost) {
            this.ghost.update("");

        }

    },
    update: function(html) {
        if (typeof html == "string") {
            this.ghost.update(html);

        } else {
            this.ghost.update("");
            html.style.margin = "0";
            this.ghost.dom.appendChild(html);

        }

    },
    getEl: function() {
        return this.el;

    },
    getGhost: function() {
        return this.ghost;

    },
    hide: function(clear) {
        this.el.hide();
        if (clear) {
            this.reset(true);

        }

    },
    stop: function() {
        if (this.anim && this.anim.isAnimated && this.anim.isAnimated()) {
            this.anim.stop();

        }

    },
    show: function() {
        this.el.show();

    },
    sync: function() {
        this.el.sync();

    },
    repair: function(xy, callback, scope) {
        this.callback = callback;
        this.scope = scope;
        if (xy && this.animRepair !== false) {
            this.el.addClass("x-dd-drag-repair");
            this.el.hideUnders(true);
            this.anim = this.el.shift({
                duration: this.repairDuration || .5,
                easing: 'easeOut',
                xy: xy,
                stopFx: true,
                callback: this.afterRepair,
                scope: this

            });

        } else {
            this.afterRepair();

        }

    },
    afterRepair: function() {
        this.hide(true);
        if (typeof this.callback == "function") {
            this.callback.call(this.scope || this);

        }
        this.callback = null;
        this.scope = null;

    }

};

Ext.dd.DragSource = function(el, config) {
    this.el = Ext.get(el);
    if (!this.dragData) {
        this.dragData = {};

    }

    Ext.apply(this, config);

    if (!this.proxy) {
        this.proxy = new Ext.dd.StatusProxy();

    }
    Ext.dd.DragSource.superclass.constructor.call(this, this.el.dom, this.ddGroup || this.group, 
    {
        dragElId: this.proxy.id,
        resizeFrame: false,
        isTarget: false,
        scroll: this.scroll === true
    });

    this.dragging = false;

};

Ext.extend(Ext.dd.DragSource, Ext.dd.DDProxy, {


    dropAllowed: "x-dd-drop-ok",
    dropNotAllowed: "x-dd-drop-nodrop",
    
getDragData: function(e) {
        return this.dragData;

    },
    onDragEnter: function(e, id) {
        var target = Ext.dd.DragDropMgr.getDDById(id);
        this.cachedTarget = target;
        if (this.beforeDragEnter(target, e, id) !== false) {
            if (target.isNotifyTarget) {
                var status = target.notifyEnter(this, e, this.dragData);
                this.proxy.setStatus(status);

            } else {
                this.proxy.setStatus(this.dropAllowed);

            }

            if (this.afterDragEnter) {

                this.afterDragEnter(target, e, id);

            }

        }

    },
    beforeDragEnter: function(target, e, id) {
        return true;

    },
    alignElWithMouse: function() {
        Ext.dd.DragSource.superclass.alignElWithMouse.apply(this, arguments);
        this.proxy.sync();

    },
    onDragOver: function(e, id) {
        var target = this.cachedTarget || Ext.dd.DragDropMgr.getDDById(id);
        if (this.beforeDragOver(target, e, id) !== false) {
            if (target.isNotifyTarget) {
                var status = target.notifyOver(this, e, this.dragData);
                this.proxy.setStatus(status);

            }

            if (this.afterDragOver) {

                this.afterDragOver(target, e, id);

            }

        }

    },
    beforeDragOver: function(target, e, id) {
        return true;

    },
    onDragOut: function(e, id) {
        var target = this.cachedTarget || Ext.dd.DragDropMgr.getDDById(id);
        if (this.beforeDragOut(target, e, id) !== false) {
            if (target.isNotifyTarget) {
                target.notifyOut(this, e, this.dragData);

            }
            this.proxy.reset();
            if (this.afterDragOut) {

                this.afterDragOut(target, e, id);

            }

        }
        this.cachedTarget = null;

    },
    beforeDragOut: function(target, e, id) {
        return true;

    },
    onDragDrop: function(e, id) {
        var target = this.cachedTarget || Ext.dd.DragDropMgr.getDDById(id);
        if (this.beforeDragDrop(target, e, id) !== false) {
            if (target.isNotifyTarget) {
                if (target.notifyDrop(this, e, this.dragData)) {
                    this.onValidDrop(target, e, id);

                } else {
                    this.onInvalidDrop(target, e, id);

                }

            } else {
                this.onValidDrop(target, e, id);

            }

            if (this.afterDragDrop) {

                this.afterDragDrop(target, e, id);

            }

        }
        delete this.cachedTarget;

    },
    beforeDragDrop: function(target, e, id) {
        return true;

    },
    onValidDrop: function(target, e, id) {
        this.hideProxy();
        if (this.afterValidDrop) {

            this.afterValidDrop(target, e, id);

        }

    },
    getRepairXY: function(e, data) {
        return this.el.getXY();

    },
    onInvalidDrop: function(target, e, id) {
        this.beforeInvalidDrop(target, e, id);
        if (this.cachedTarget) {
            if (this.cachedTarget.isNotifyTarget) {
                this.cachedTarget.notifyOut(this, e, this.dragData);

            }
            this.cacheTarget = null;

        }
        this.proxy.repair(this.getRepairXY(e, this.dragData), this.afterRepair, this);

        if (this.afterInvalidDrop) {

            this.afterInvalidDrop(e, id);

        }

    },
    afterRepair: function() {
        if (Ext.enableFx) {
            this.el.highlight(this.hlColor || "c3daf9");

        }
        this.dragging = false;

    },
    beforeInvalidDrop: function(target, e, id) {
        return true;

    },
    handleMouseDown: function(e) {
        if (this.dragging) {
            return;

        }
        var data = this.getDragData(e);
        if (data && this.onBeforeDrag(data, e) !== false) {
            this.dragData = data;
            this.proxy.stop();
            Ext.dd.DragSource.superclass.handleMouseDown.apply(this, arguments);

        }

    },
    onBeforeDrag: function(data, e) {
        return true;

    },
    onStartDrag: Ext.emptyFn,
    startDrag: function(x, y) {
        this.proxy.reset();
        this.dragging = true;
        this.proxy.update("");
        this.onInitDrag(x, y);
        this.proxy.show();

    },
    onInitDrag: function(x, y) {
        var clone = this.el.dom.cloneNode(true);
        clone.id = Ext.id();
        this.proxy.update(clone);
        this.onStartDrag(x, y);
        return true;

    },
    getProxy: function() {
        return this.proxy;

    },
    hideProxy: function() {
        this.proxy.hide();
        this.proxy.reset(true);
        this.dragging = false;

    },
    triggerCacheRefresh: function() {
        Ext.dd.DDM.refreshCache(this.groups);

    },
    b4EndDrag: function(e) {
        },
        endDrag: function(e) {
        this.onEndDrag(this.dragData, e);

    },
    onEndDrag: function(data, e) {
        },
        autoOffset: function(x, y) {
        this.setDelta( - 12, -20);

    }

});

Ext.dd.DropTarget = function(el, config) {
    this.el = Ext.get(el);

    Ext.apply(this, config);

    if (this.containerScroll) {
        Ext.dd.ScrollManager.register(this.el);

    }

    Ext.dd.DropTarget.superclass.constructor.call(this, this.el.dom, this.ddGroup || this.group, 
    {
        isTarget: true
    });


};

Ext.extend(Ext.dd.DropTarget, Ext.dd.DDTarget, {



    dropAllowed: "x-dd-drop-ok",
    dropNotAllowed: "x-dd-drop-nodrop",
    
isTarget: true,
    
isNotifyTarget: true,
    
notifyEnter: function(dd, e, data) {
        if (this.overClass) {
            this.el.addClass(this.overClass);

        }
        return this.dropAllowed;

    },
    notifyOver: function(dd, e, data) {
        return this.dropAllowed;

    },
    notifyOut: function(dd, e, data) {
        if (this.overClass) {
            this.el.removeClass(this.overClass);

        }

    },
    notifyDrop: function(dd, e, data) {
        return false;

    }

});

Ext.dd.DragZone = function(el, config) {
    Ext.dd.DragZone.superclass.constructor.call(this, el, config);
    if (this.containerScroll) {
        Ext.dd.ScrollManager.register(this.el);

    }

};

Ext.extend(Ext.dd.DragZone, Ext.dd.DragSource, {




    getDragData: function(e) {
        return Ext.dd.Registry.getHandleFromEvent(e);

    },
    onInitDrag: function(x, y) {
        this.proxy.update(this.dragData.ddel.cloneNode(true));
        this.onStartDrag(x, y);
        return true;

    },
    afterRepair: function() {
        if (Ext.enableFx) {
            Ext.Element.fly(this.dragData.ddel).highlight(this.hlColor || "c3daf9");

        }
        this.dragging = false;

    },
    getRepairXY: function(e) {
        return Ext.Element.fly(this.dragData.ddel).getXY();

    }

});

Ext.dd.DropZone = function(el, config) {
    Ext.dd.DropZone.superclass.constructor.call(this, el, config);

};

Ext.extend(Ext.dd.DropZone, Ext.dd.DropTarget, {

    getTargetFromEvent: function(e) {
        return Ext.dd.Registry.getTargetFromEvent(e);

    },
    onNodeEnter: function(n, dd, e, data) {

        },
        onNodeOver: function(n, dd, e, data) {
        return this.dropAllowed;

    },
    onNodeOut: function(n, dd, e, data) {

        },
        onNodeDrop: function(n, dd, e, data) {
        return false;

    },
    onContainerOver: function(dd, e, data) {
        return this.dropNotAllowed;

    },
    onContainerDrop: function(dd, e, data) {
        return false;

    },
    notifyEnter: function(dd, e, data) {
        return this.dropNotAllowed;

    },
    notifyOver: function(dd, e, data) {
        var n = this.getTargetFromEvent(e);
        if (!n) {
            if (this.lastOverNode) {
                this.onNodeOut(this.lastOverNode, dd, e, data);
                this.lastOverNode = null;

            }
            return this.onContainerOver(dd, e, data);

        }
        if (this.lastOverNode != n) {
            if (this.lastOverNode) {
                this.onNodeOut(this.lastOverNode, dd, e, data);

            }
            this.onNodeEnter(n, dd, e, data);
            this.lastOverNode = n;

        }
        return this.onNodeOver(n, dd, e, data);

    },
    notifyOut: function(dd, e, data) {
        if (this.lastOverNode) {
            this.onNodeOut(this.lastOverNode, dd, e, data);
            this.lastOverNode = null;

        }

    },
    notifyDrop: function(dd, e, data) {
        if (this.lastOverNode) {
            this.onNodeOut(this.lastOverNode, dd, e, data);
            this.lastOverNode = null;

        }
        var n = this.getTargetFromEvent(e);
        return n ? 
        this.onNodeDrop(n, dd, e, data) : 
        this.onContainerDrop(dd, e, data);

    },
    triggerCacheRefresh: function() {
        Ext.dd.DDM.refreshCache(this.groups);

    }

});


Ext.data.SortTypes = {

    none: function(s) {
        return s;

    },
    stripTagsRE: /<\/?[^>]+>/gi,
    asText: function(s) {
        return String(s).replace(this.stripTagsRE, "");

    },
    asUCText: function(s) {
        return String(s).toUpperCase().replace(this.stripTagsRE, "");

    },
    asUCString: function(s) {
        return String(s).toUpperCase();

    },
    asDate: function(s) {
        if (!s) {
            return 0;

        }
        if (Ext.isDate(s)) {
            return s.getTime();

        }
        return Date.parse(String(s));

    },
    asFloat: function(s) {
        var val = parseFloat(String(s).replace(/,/g, ""));
        if (isNaN(val)) val = 0;
        return val;

    },
    asInt: function(s) {
        var val = parseInt(String(s).replace(/,/g, ""));
        if (isNaN(val)) val = 0;
        return val;

    }

};

Ext.data.Record = function(data, id) {
    this.id = (id || id === 0) ? id: ++Ext.data.Record.AUTO_ID;
    this.data = data;

};


Ext.data.Record.create = function(o) {
    var f = Ext.extend(Ext.data.Record, {});
    var p = f.prototype;
    p.fields = new Ext.util.MixedCollection(false, 
    function(field) {
        return field.name;

    });
    for (var i = 0, len = o.length; i < len; i++) {
        p.fields.add(new Ext.data.Field(o[i]));

    }
    f.getField = function(name) {
        return p.fields.get(name);

    };
    return f;

};

Ext.data.Record.AUTO_ID = 1000;
Ext.data.Record.EDIT = 'edit';
Ext.data.Record.REJECT = 'reject';
Ext.data.Record.COMMIT = 'commit';

Ext.data.Record.prototype = {



    dirty: false,
    editing: false,
    error: null,
    modified: null,
    join: function(store) {
        this.store = store;

    },
    set: function(name, value) {
        if (String(this.data[name]) == String(value)) {
            return;

        }
        this.dirty = true;
        if (!this.modified) {
            this.modified = {};

        }
        if (typeof this.modified[name] == 'undefined') {
            this.modified[name] = this.data[name];

        }
        this.data[name] = value;
        if (!this.editing && this.store) {
            this.store.afterEdit(this);

        }

    },
    get: function(name) {
        return this.data[name];

    },
    beginEdit: function() {
        this.editing = true;
        this.modified = {};

    },
    cancelEdit: function() {
        this.editing = false;
        delete this.modified;

    },
    endEdit: function() {
        this.editing = false;
        if (this.dirty && this.store) {
            this.store.afterEdit(this);

        }

    },
    reject: function(silent) {
        var m = this.modified;
        for (var n in m) {
            if (typeof m[n] != "function") {
                this.data[n] = m[n];

            }

        }
        this.dirty = false;
        delete this.modified;
        this.editing = false;
        if (this.store && silent !== true) {
            this.store.afterReject(this);

        }

    },
    commit: function(silent) {
        this.dirty = false;
        delete this.modified;
        this.editing = false;
        if (this.store && silent !== true) {
            this.store.afterCommit(this);

        }

    },
    getChanges: function() {
        var m = this.modified,
        cs = {};
        for (var n in m) {
            if (m.hasOwnProperty(n)) {
                cs[n] = this.data[n];

            }

        }
        return cs;

    },
    hasError: function() {
        return this.error != null;

    },
    clearError: function() {
        this.error = null;

    },
    copy: function(newId) {
        return new this.constructor(Ext.apply({},
        this.data), newId || this.id);

    },
    isModified: function(fieldName) {
        return this.modified && this.modified.hasOwnProperty(fieldName);

    }

};

Ext.StoreMgr = Ext.apply(new Ext.util.MixedCollection(), {



    register: function() {
        for (var i = 0, s; s = arguments[i]; i++) {
            this.add(s);

        }

    },
    unregister: function() {
        for (var i = 0, s; s = arguments[i]; i++) {
            this.remove(this.lookup(s));

        }

    },
    lookup: function(id) {
        return typeof id == "object" ? id: this.get(id);

    },
    getKey: function(o) {
        return o.storeId || o.id;

    }

});

Ext.data.Store = function(config) {
    this.data = new Ext.util.MixedCollection(false);
    this.data.getKey = function(o) {
        return o.id;

    };

    this.baseParams = {};
    this.paramNames = {
        "start": "start",
        "limit": "limit",
        "sort": "sort",
        "dir": "dir"

    };

    if (config && config.data) {
        this.inlineData = config.data;
        delete config.data;

    }

    Ext.apply(this, config);

    if (this.url && !this.proxy) {
        this.proxy = new Ext.data.HttpProxy({
            url: this.url
        });

    }

    if (this.reader) {
        if (!this.recordType) {
            this.recordType = this.reader.recordType;

        }
        if (this.reader.onMetaChange) {
            this.reader.onMetaChange = this.onMetaChange.createDelegate(this);

        }

    }

    if (this.recordType) {
        this.fields = this.recordType.prototype.fields;

    }
    this.modified = [];

    this.addEvents(

    'datachanged', 

    'metachange', 

    'add', 

    'remove', 

    'update', 

    'clear', 

    'beforeload', 

    'load', 

    'loadexception'
    );

    if (this.proxy) {
        this.relayEvents(this.proxy, ["loadexception"]);

    }

    this.sortToggle = {};
    if (this.sortInfo) {
        this.setDefaultSort(this.sortInfo.field, this.sortInfo.direction);

    }

    Ext.data.Store.superclass.constructor.call(this);

    if (this.storeId || this.id) {
        Ext.StoreMgr.register(this);

    }
    if (this.inlineData) {
        this.loadData(this.inlineData);
        delete this.inlineData;

    } else if (this.autoLoad) {
        this.load.defer(10, this, [
        typeof this.autoLoad == 'object' ? 
        this.autoLoad: undefined]);

    }

};
Ext.extend(Ext.data.Store, Ext.util.Observable, {

    remoteSort: false,
    pruneModifiedRecords: false,
    lastOptions: null,
    destroy: function() {
        if (this.id) {
            Ext.StoreMgr.unregister(this);

        }
        this.data = null;
        this.purgeListeners();

    },
    add: function(records) {
        records = [].concat(records);
        if (records.length < 1) {
            return;

        }
        for (var i = 0, len = records.length; i < len; i++) {
            records[i].join(this);

        }
        var index = this.data.length;
        this.data.addAll(records);
        if (this.snapshot) {
            this.snapshot.addAll(records);

        }
        this.fireEvent("add", this, records, index);

    },
    addSorted: function(record) {
        var index = this.findInsertIndex(record);
        this.insert(index, record);

    },
    remove: function(record) {
        var index = this.data.indexOf(record);
        this.data.removeAt(index);
        if (this.pruneModifiedRecords) {
            this.modified.remove(record);

        }
        if (this.snapshot) {
            this.snapshot.remove(record);

        }
        this.fireEvent("remove", this, record, index);

    },
    removeAll: function() {
        this.data.clear();
        if (this.snapshot) {
            this.snapshot.clear();

        }
        if (this.pruneModifiedRecords) {
            this.modified = [];

        }
        this.fireEvent("clear", this);

    },
    insert: function(index, records) {
        records = [].concat(records);
        for (var i = 0, len = records.length; i < len; i++) {
            this.data.insert(index, records[i]);
            records[i].join(this);
        }
        this.fireEvent("add", this, records, index);

    },
    indexOf: function(record) {
        return this.data.indexOf(record);

    },
    indexOfId: function(id) {
        return this.data.indexOfKey(id);

    },
    getById: function(id) {
        return this.data.key(id);

    },
    getAt: function(index) {
        return this.data.itemAt(index);

    },
    getRange: function(start, end) {
        return this.data.getRange(start, end);

    },
    storeOptions: function(o) {
        o = Ext.apply({}, o);
        delete o.callback;
        delete o.scope;
        this.lastOptions = o;

    },
    load: function(options) {
        options = options || {};
        if (this.fireEvent("beforeload", this, options) !== false) {
            this.storeOptions(options);
            var p = Ext.apply(options.params || {}, this.baseParams);
            if (this.sortInfo && this.remoteSort) {
                var pn = this.paramNames;
                p[pn["sort"]] = this.sortInfo.field;
                p[pn["dir"]] = this.sortInfo.direction;

            }
            this.proxy.load(p, this.reader, this.loadRecords, this, options);
            return true;

        } else {
            return false;

        }

    },
    reload: function(options) {
        this.load(Ext.applyIf(options || {}, this.lastOptions));

    },
    loadRecords: function(o, options, success) {
        if (!o || success === false) {
            if (success !== false) {
                this.fireEvent("load", this, [], options);

            }
            if (options.callback) {
                options.callback.call(options.scope || this, [], options, false);

            }
            return;

        }
        var r = o.records,
        t = o.totalRecords || r.length;
        if (!options || options.add !== true) {
            if (this.pruneModifiedRecords) {
                this.modified = [];

            }
            for (var i = 0, len = r.length; i < len; i++) {
                r[i].join(this);

            }

            if (this.snapshot) {
                this.data = this.snapshot;
                delete this.snapshot;

            }
            this.data.clear();
            this.data.addAll(r);
            this.totalLength = t;
            this.applySort();
            this.fireEvent("datachanged", this);

        } else {
            this.totalLength = Math.max(t, this.data.length + r.length);
            this.add(r);

        }
        this.fireEvent("load", this, r, options);
        if (options.callback) {
            options.callback.call(options.scope || this, r, options, true);

        }

    },
    loadData: function(o, append) {
        var r = this.reader.readRecords(o);
        this.loadRecords(r, {
            add: append
        },
        true);

    },
    getCount: function() {
        return this.data.length || 0;

    },
    getTotalCount: function() {
        return this.totalLength || 0;

    },
    getSortState: function() {
        return this.sortInfo;

    },
    applySort: function() {
        if (this.sortInfo && !this.remoteSort) {
            var s = this.sortInfo,
            f = s.field;
            this.sortData(f, s.direction);

        }

    },
    sortData: function(f, direction) {
        direction = direction || 'ASC';
        var st = this.fields.get(f).sortType;
        var fn = function(r1, r2) {
            var v1 = st(r1.data[f]),
            v2 = st(r2.data[f]);
            return v1 > v2 ? 1: (v1 < v2 ? -1: 0);

        };
        this.data.sort(direction, fn);
        
        if (this.snapshot && this.snapshot != this.data) {
            this.snapshot.sort(direction, fn);

        }

    },
    setDefaultSort: function(field, dir) {
        dir = dir ? dir.toUpperCase() : "ASC";
        this.sortInfo = {
            field: field,
            direction: dir
        };
        this.sortToggle[field] = dir;

    },
    sort: function(fieldName, dir) {
        var f = this.fields.get(fieldName);
        if (!f) {
            return false;

        }
        if (!dir) {
            if (this.sortInfo && this.sortInfo.field == f.name) {
                dir = (this.sortToggle[f.name] || "ASC").toggle("ASC", "DESC");

            } else {
                dir = f.sortDir;

            }

        }
        var st = (this.sortToggle) ? this.sortToggle[f.name] : null;
        var si = (this.sortInfo) ? this.sortInfo: null;

        this.sortToggle[f.name] = dir;
        this.sortInfo = {
            field: f.name,
            direction: dir
        };
        if (!this.remoteSort) {
            this.applySort();
            this.fireEvent("datachanged", this);

        } else {
            if (!this.load(this.lastOptions)) {
                if (st) {
                    this.sortToggle[f.name] = st;

                }
                if (si) {
                    this.sortInfo = si;

                }

            }

        }

    },
    each: function(fn, scope) {
        this.data.each(fn, scope);

    },
    getModifiedRecords: function() {
        return this.modified;

    },
    createFilterFn: function(property, value, anyMatch, caseSensitive) {
        if (Ext.isEmpty(value, false)) {
            return false;

        }
        value = this.data.createValueMatcher(value, anyMatch, caseSensitive);
        return function(r) {
            return value.test(r.data[property]);

        };

    },
    sum: function(property, start, end) {
        var rs = this.data.items,
        v = 0;
        start = start || 0;
        end = (end || end === 0) ? end: rs.length - 1;

        for (var i = start; i <= end; i++) {
            v += (rs[i].data[property] || 0);

        }
        return v;

    },
    filter: function(property, value, anyMatch, caseSensitive) {
        var fn = this.createFilterFn(property, value, anyMatch, caseSensitive);
        return fn ? this.filterBy(fn) : this.clearFilter();

    },
    filterBy: function(fn, scope) {
        this.snapshot = this.snapshot || this.data;
        this.data = this.queryBy(fn, scope || this);
        this.fireEvent("datachanged", this);

    },
    query: function(property, value, anyMatch, caseSensitive) {
        var fn = this.createFilterFn(property, value, anyMatch, caseSensitive);
        return fn ? this.queryBy(fn) : this.data.clone();

    },
    queryBy: function(fn, scope) {
        var data = this.snapshot || this.data;
        return data.filterBy(fn, scope || this);

    },
    find: function(property, value, start, anyMatch, caseSensitive) {
        var fn = this.createFilterFn(property, value, anyMatch, caseSensitive);
        return fn ? this.data.findIndexBy(fn, null, start) : -1;

    },
    findBy: function(fn, scope, start) {
        return this.data.findIndexBy(fn, scope, start);

    },
    collect: function(dataIndex, allowNull, bypassFilter) {
        var d = (bypassFilter === true && this.snapshot) ? 
        this.snapshot.items: this.data.items;
        var v,
        sv,
        r = [],
        l = {};
        for (var i = 0, len = d.length; i < len; i++) {
            v = d[i].data[dataIndex];
            sv = String(v);
            if ((allowNull || !Ext.isEmpty(v)) && !l[sv]) {
                l[sv] = true;
                r[r.length] = v;

            }

        }
        return r;

    },
    clearFilter: function(suppressEvent) {
        if (this.isFiltered()) {
            this.data = this.snapshot;
            delete this.snapshot;
            if (suppressEvent !== true) {
                this.fireEvent("datachanged", this);

            }

        }

    },
    isFiltered: function() {
        return this.snapshot && this.snapshot != this.data;

    },
    afterEdit: function(record) {
        if (this.modified.indexOf(record) == -1) {
            this.modified.push(record);

        }
        this.fireEvent("update", this, record, Ext.data.Record.EDIT);

    },
    afterReject: function(record) {
        this.modified.remove(record);
        this.fireEvent("update", this, record, Ext.data.Record.REJECT);

    },
    afterCommit: function(record) {
        this.modified.remove(record);
        this.fireEvent("update", this, record, Ext.data.Record.COMMIT);

    },
    commitChanges: function() {
        var m = this.modified.slice(0);
        this.modified = [];
        for (var i = 0, len = m.length; i < len; i++) {
            m[i].commit();

        }

    },
    rejectChanges: function() {
        var m = this.modified.slice(0);
        this.modified = [];
        for (var i = 0, len = m.length; i < len; i++) {
            m[i].reject();

        }

    },
    onMetaChange: function(meta, rtype, o) {
        this.recordType = rtype;
        this.fields = rtype.prototype.fields;
        delete this.snapshot;
        this.sortInfo = meta.sortInfo;
        this.modified = [];
        this.fireEvent('metachange', this, this.reader.meta);

    },
    findInsertIndex: function(record) {
        this.suspendEvents();
        var data = this.data.clone();
        this.data.add(record);
        this.applySort();
        var index = this.data.indexOf(record);
        this.data = data;
        this.resumeEvents();
        return index;

    }

});

Ext.data.SimpleStore = function(config) {
    Ext.data.SimpleStore.superclass.constructor.call(this, Ext.apply(config, {
        reader: new Ext.data.ArrayReader({
            id: config.id

        },
        Ext.data.Record.create(config.fields)
        )

    }));

};
Ext.extend(Ext.data.SimpleStore, Ext.data.Store, {
    loadData: function(data, append) {
        if (this.expandData === true) {
            var r = [];
            for (var i = 0, len = data.length; i < len; i++) {
                r[r.length] = [data[i]];

            }
            data = r;

        }
        Ext.data.SimpleStore.superclass.loadData.call(this, data, append);

    }

});

Ext.data.JsonStore = function(c) {
    Ext.data.JsonStore.superclass.constructor.call(this, Ext.apply(c, {
        proxy: !c.data ? new Ext.data.HttpProxy({
            url: c.url
        }) : undefined,
        reader: new Ext.data.JsonReader(c, c.fields)

    }));

};
Ext.extend(Ext.data.JsonStore, Ext.data.Store);



Ext.data.Field = function(config) {
    if (typeof config == "string") {
        config = {
            name: config
        };

    }
    Ext.apply(this, config);

    if (!this.type) {
        this.type = "auto";

    }

    var st = Ext.data.SortTypes;

    if (typeof this.sortType == "string") {
        this.sortType = st[this.sortType];

    }


    if (!this.sortType) {
        switch (this.type) {
            case "string":
            this.sortType = st.asUCString;
            break;
            case "date":
            this.sortType = st.asDate;
            break;
            default:
            this.sortType = st.none;

        }

    }


    var stripRe = /[\$,%]/g;



    if (!this.convert) {
        var cv,
        dateFormat = this.dateFormat;
        switch (this.type) {
            case "":
        case "auto":
        case undefined:
            cv = function(v) {
                return v;
            };
            break;
            case "string":
            cv = function(v) {
                return (v === undefined || v === null) ? '': String(v);
            };
            break;
            case "int":
            cv = function(v) {
                return v !== undefined && v !== null && v !== '' ? 
                parseInt(String(v).replace(stripRe, ""), 10) : '';

            };
            break;
            case "float":
            cv = function(v) {
                return v !== undefined && v !== null && v !== '' ? 
                parseFloat(String(v).replace(stripRe, ""), 10) : '';

            };
            break;
            case "bool":
        case "boolean":
            cv = function(v) {
                return v === true || v === "true" || v == 1;
            };
            break;
            case "date":
            cv = function(v) {
                if (!v) {
                    return '';

                }
                if (Ext.isDate(v)) {
                    return v;

                }
                if (dateFormat) {
                    if (dateFormat == "timestamp") {
                        return new Date(v * 1000);

                    }
                    if (dateFormat == "time") {
                        return new Date(parseInt(v, 10));

                    }
                    return Date.parseDate(v, dateFormat);

                }
                var parsed = Date.parse(v);
                return parsed ? new Date(parsed) : null;

            };
            break;


        }
        this.convert = cv;

    }

};

Ext.data.Field.prototype = {
    dateFormat: null,
    defaultValue: "",
    mapping: null,
    sortType: null,
    sortDir: "ASC"

};

Ext.data.DataReader = function(meta, recordType) {

    this.meta = meta;
    this.recordType = Ext.isArray(recordType) ? 
    Ext.data.Record.create(recordType) : recordType;

};

Ext.data.DataReader.prototype = {

    };

Ext.data.DataProxy = function() {
    this.addEvents(

    'beforeload', 

    'load'
    );
    Ext.data.DataProxy.superclass.constructor.call(this);

};

Ext.extend(Ext.data.DataProxy, Ext.util.Observable);

Ext.data.MemoryProxy = function(data) {
    Ext.data.MemoryProxy.superclass.constructor.call(this);
    this.data = data;

};

Ext.extend(Ext.data.MemoryProxy, Ext.data.DataProxy, {



    load: function(params, reader, callback, scope, arg) {
        params = params || {};
        var result;
        try {
            result = reader.readRecords(this.data);

        } catch(e) {
            this.fireEvent("loadexception", this, arg, null, e);
            callback.call(scope, null, arg, false);
            return;

        }
        callback.call(scope, result, arg, true);

    },
    update: function(params, records) {

	}

});

Ext.data.HttpProxy = function(conn) {
    Ext.data.HttpProxy.superclass.constructor.call(this);

    this.conn = conn;
    this.useAjax = !conn || !conn.events;
};

Ext.extend(Ext.data.HttpProxy, Ext.data.DataProxy, {

    getConnection: function() {
        return this.useAjax ? Ext.Ajax: this.conn;

    },
    load: function(params, reader, callback, scope, arg) {
        if (this.fireEvent("beforeload", this, params) !== false) {
            var o = {
                params: params || {},
                request: {
                    callback: callback,
                    scope: scope,
                    arg: arg

                },
                reader: reader,
                callback: this.loadResponse,
                scope: this

            };
            if (this.useAjax) {
                Ext.applyIf(o, this.conn);
                if (this.activeRequest) {
                    Ext.Ajax.abort(this.activeRequest);

                }
                this.activeRequest = Ext.Ajax.request(o);

            } else {
                this.conn.request(o);

            }

        } else {
            callback.call(scope || this, null, arg, false);

        }

    },
    loadResponse: function(o, success, response) {
        delete this.activeRequest;
        if (!success) {
            this.fireEvent("loadexception", this, o, response);
            o.request.callback.call(o.request.scope, null, o.request.arg, false);
            return;

        }
        var result;
        try {
            result = o.reader.read(response);

        } catch(e) {
            this.fireEvent("loadexception", this, o, response, e);
            o.request.callback.call(o.request.scope, null, o.request.arg, false);
            return;

        }
        this.fireEvent("load", this, o, o.request.arg);
        o.request.callback.call(o.request.scope, result, o.request.arg, true);

    },
    update: function(dataSet) {

	},
	updateResponse: function(dataSet) {

	}

});

Ext.data.ScriptTagProxy = function(config) {
    Ext.data.ScriptTagProxy.superclass.constructor.call(this);
    Ext.apply(this, config);
    this.head = document.getElementsByTagName("head")[0];



};

Ext.data.ScriptTagProxy.TRANS_ID = 1000;

Ext.extend(Ext.data.ScriptTagProxy, Ext.data.DataProxy, {


    timeout: 30000,
    callbackParam: "callback",
    nocache: true,
    
	load: function(params, reader, callback, scope, arg) {
        if (this.fireEvent("beforeload", this, params) !== false) {

            var p = Ext.urlEncode(Ext.apply(params, this.extraParams));

            var url = this.url;
            url += (url.indexOf("?") != -1 ? "&": "?") + p;
            if (this.nocache) {
                url += "&_dc=" + (new Date().getTime());

            }
            var transId = ++Ext.data.ScriptTagProxy.TRANS_ID;
            var trans = {
                id: transId,
                cb: "stcCallback" + transId,
                scriptId: "stcScript" + transId,
                params: params,
                arg: arg,
                url: url,
                callback: callback,
                scope: scope,
                reader: reader

            };
            var conn = this;

            window[trans.cb] = function(o) {
                conn.handleResponse(o, trans);

            };

            url += String.format("&{0}={1}", this.callbackParam, trans.cb);

            if (this.autoAbort !== false) {
                this.abort();

            }

            trans.timeoutId = this.handleFailure.defer(this.timeout, this, [trans]);

            var script = document.createElement("script");
            script.setAttribute("src", url);
            script.setAttribute("type", "text/javascript");
            script.setAttribute("id", trans.scriptId);
            this.head.appendChild(script);

            this.trans = trans;

        } else {
            callback.call(scope || this, null, arg, false);

        }

    },
    isLoading: function() {
        return this.trans ? true: false;

    },
    abort: function() {
        if (this.isLoading()) {
            this.destroyTrans(this.trans);

        }

    },
    destroyTrans: function(trans, isLoaded) {
        this.head.removeChild(document.getElementById(trans.scriptId));
        clearTimeout(trans.timeoutId);
        if (isLoaded) {
            window[trans.cb] = undefined;
            try {
                delete window[trans.cb];

            } catch(e) {}

        } else {

            window[trans.cb] = function() {
                window[trans.cb] = undefined;
                try {
                    delete window[trans.cb];

                } catch(e) {}

            };

        }

    },
    handleResponse: function(o, trans) {
        this.trans = false;
        this.destroyTrans(trans, true);
        var result;
        try {
            result = trans.reader.readRecords(o);

        } catch(e) {
            this.fireEvent("loadexception", this, o, trans.arg, e);
            trans.callback.call(trans.scope || window, null, trans.arg, false);
            return;

        }
        this.fireEvent("load", this, o, trans.arg);
        trans.callback.call(trans.scope || window, result, trans.arg, true);

    },
    handleFailure: function(trans) {
        this.trans = false;
        this.destroyTrans(trans, false);
        this.fireEvent("loadexception", this, null, trans.arg);
        trans.callback.call(trans.scope || window, null, trans.arg, false);

    }

});

Ext.data.JsonReader = function(meta, recordType) {
    meta = meta || {};
    Ext.data.JsonReader.superclass.constructor.call(this, meta, recordType || meta.fields);

};
Ext.extend(Ext.data.JsonReader, Ext.data.DataReader, {


    read: function(response) {
        var json = response.responseText;
        var o = eval("(" + json + ")");
        if (!o) {
            throw {
                message: "JsonReader.read: Json object not found"
            };

        }
        return this.readRecords(o);

    },
    onMetaChange: function(meta, recordType, o) {

        },
        simpleAccess: function(obj, subsc) {
        return obj[subsc];

    },
    getJsonAccessor: function() {
        var re = /[\[\.]/;
        return function(expr) {
            try {
                return (re.test(expr))
                ? new Function("obj", "return obj." + expr)
                : function(obj) {
                    return obj[expr];

                };

            } catch(e) {}
            return Ext.emptyFn;

        };

    } (),
    readRecords: function(o) {

        this.jsonData = o;
        if (o.metaData) {
            delete this.ef;
            this.meta = o.metaData;
            this.recordType = Ext.data.Record.create(o.metaData.fields);
            this.onMetaChange(this.meta, this.recordType, o);

        }
        var s = this.meta,
        Record = this.recordType,
        f = Record.prototype.fields,
        fi = f.items,
        fl = f.length;

        if (!this.ef) {
            if (s.totalProperty) {
                this.getTotal = this.getJsonAccessor(s.totalProperty);

            }
            if (s.successProperty) {
                this.getSuccess = this.getJsonAccessor(s.successProperty);

            }
            this.getRoot = s.root ? this.getJsonAccessor(s.root) : function(p) {
                return p;
            };
            if (s.id) {
                var g = this.getJsonAccessor(s.id);
                this.getId = function(rec) {
                    var r = g(rec);
                    return (r === undefined || r === "") ? null: r;

                };

            } else {
                this.getId = function() {
                    return null;
                };

            }
            this.ef = [];
            for (var i = 0; i < fl; i++) {
                f = fi[i];
                var map = (f.mapping !== undefined && f.mapping !== null) ? f.mapping: f.name;
                this.ef[i] = this.getJsonAccessor(map);

            }

        }

        var root = this.getRoot(o),
        c = root.length,
        totalRecords = c,
        success = true;
        if (s.totalProperty) {
            var v = parseInt(this.getTotal(o), 10);
            if (!isNaN(v)) {
                totalRecords = v;

            }

        }
        if (s.successProperty) {
            var v = this.getSuccess(o);
            if (v === false || v === 'false') {
                success = false;

            }

        }
        var records = [];
        for (var i = 0; i < c; i++) {
            var n = root[i];
            var values = {};
            var id = this.getId(n);
            for (var j = 0; j < fl; j++) {
                f = fi[j];
                var v = this.ef[j](n);
                values[f.name] = f.convert((v !== undefined) ? v: f.defaultValue, n);

            }
            var record = new Record(values, id);
            record.json = n;
            records[i] = record;

        }
        return {
            success: success,
            records: records,
            totalRecords: totalRecords

        };

    }

});

Ext.data.XmlReader = function(meta, recordType) {
    meta = meta || {};
    Ext.data.XmlReader.superclass.constructor.call(this, meta, recordType || meta.fields);

};
Ext.extend(Ext.data.XmlReader, Ext.data.DataReader, {

    read: function(response) {
        var doc = response.responseXML;
        if (!doc) {
            throw {
                message: "XmlReader.read: XML Document not available"
            };

        }
        return this.readRecords(doc);

    },
    readRecords: function(doc) {

        this.xmlData = doc;
        var root = doc.documentElement || doc;
        var q = Ext.DomQuery;
        var recordType = this.recordType,
        fields = recordType.prototype.fields;
        var sid = this.meta.id;
        var totalRecords = 0,
        success = true;
        if (this.meta.totalRecords) {
            totalRecords = q.selectNumber(this.meta.totalRecords, root, 0);

        }

        if (this.meta.success) {
            var sv = q.selectValue(this.meta.success, root, true);
            success = sv !== false && sv !== 'false';

        }
        var records = [];
        var ns = q.select(this.meta.record, root);
        for (var i = 0, len = ns.length; i < len; i++) {
            var n = ns[i];
            var values = {};
            var id = sid ? q.selectValue(sid, n) : undefined;
            for (var j = 0, jlen = fields.length; j < jlen; j++) {
                var f = fields.items[j];
                var v = q.selectValue(f.mapping || f.name, n, f.defaultValue);
                v = f.convert(v, n);
                values[f.name] = v;

            }
            var record = new recordType(values, id);
            record.node = n;
            records[records.length] = record;

        }

        return {
            success: success,
            records: records,
            totalRecords: totalRecords || records.length

        };

    }

});

Ext.data.ArrayReader = Ext.extend(Ext.data.JsonReader, {

    readRecords: function(o) {
        var sid = this.meta ? this.meta.id: null;
        var recordType = this.recordType,
        fields = recordType.prototype.fields;
        var records = [];
        var root = o;
        for (var i = 0; i < root.length; i++) {
            var n = root[i];
            var values = {};
            var id = ((sid || sid === 0) && n[sid] !== undefined && n[sid] !== "" ? n[sid] : null);
            for (var j = 0, jlen = fields.length; j < jlen; j++) {
                var f = fields.items[j];
                var k = f.mapping !== undefined && f.mapping !== null ? f.mapping: j;
                var v = n[k] !== undefined ? n[k] : f.defaultValue;
                v = f.convert(v, n);
                values[f.name] = v;

            }
            var record = new recordType(values, id);
            record.json = n;
            records[records.length] = record;

        }
        return {
            records: records,
            totalRecords: records.length

        };

    }

});

Ext.data.Tree = function(root) {
    this.nodeHash = {};

    this.root = null;
    if (root) {
        this.setRootNode(root);

    }
    this.addEvents(

    "append", 

    "remove", 

    "move", 

    "insert", 

    "beforeappend", 

    "beforeremove", 

    "beforemove", 

    "beforeinsert"
    );

    Ext.data.Tree.superclass.constructor.call(this);

};

Ext.extend(Ext.data.Tree, Ext.util.Observable, {

    pathSeparator: "/",
    proxyNodeEvent: function() {
        return this.fireEvent.apply(this, arguments);

    },
    getRootNode: function() {
        return this.root;

    },
    setRootNode: function(node) {
        this.root = node;
        node.ownerTree = this;
        node.isRoot = true;
        this.registerNode(node);
        return node;

    },
    getNodeById: function(id) {
        return this.nodeHash[id];

    },
    registerNode: function(node) {
        this.nodeHash[node.id] = node;

    },
    unregisterNode: function(node) {
        delete this.nodeHash[node.id];

    },
    toString: function() {
        return "[Tree" + (this.id ? " " + this.id: "") + "]";

    }

});


Ext.data.Node = function(attributes) {

    this.attributes = attributes || {};
    this.leaf = this.attributes.leaf;

    this.id = this.attributes.id;
    if (!this.id) {
        this.id = Ext.id(null, "ynode-");
        this.attributes.id = this.id;

    }

    this.childNodes = [];
    if (!this.childNodes.indexOf) {
        this.childNodes.indexOf = function(o) {
            for (var i = 0, len = this.length; i < len; i++) {
                if (this[i] == o) return i;

            }
            return - 1;

        };

    }

    this.parentNode = null;

    this.firstChild = null;

    this.lastChild = null;

    this.previousSibling = null;

    this.nextSibling = null;

    this.addEvents({

        "append": true,
                "remove": true,
                "move": true,
                "insert": true,
                "beforeappend": true,
                "beforeremove": true,
                "beforemove": true,
                "beforeinsert": true

    });
    this.listeners = this.attributes.listeners;
    Ext.data.Node.superclass.constructor.call(this);

};

Ext.extend(Ext.data.Node, Ext.util.Observable, {

    fireEvent: function(evtName) {

        if (Ext.data.Node.superclass.fireEvent.apply(this, arguments) === false) {
            return false;

        }

        var ot = this.getOwnerTree();
        if (ot) {
            if (ot.proxyNodeEvent.apply(ot, arguments) === false) {
                return false;

            }

        }
        return true;

    },
    isLeaf: function() {
        return this.leaf === true;

    },
    setFirstChild: function(node) {
        this.firstChild = node;

    },
    setLastChild: function(node) {
        this.lastChild = node;

    },
    
isLast: function() {
        return (!this.parentNode ? true: this.parentNode.lastChild == this);

    },
    isFirst: function() {
        return (!this.parentNode ? true: this.parentNode.firstChild == this);

    },
    hasChildNodes: function() {
        return ! this.isLeaf() && this.childNodes.length > 0;

    },
    appendChild: function(node) {
        var multi = false;
        if (Ext.isArray(node)) {
            multi = node;

        } else if (arguments.length > 1) {
            multi = arguments;

        }

        if (multi) {
            for (var i = 0, len = multi.length; i < len; i++) {
                this.appendChild(multi[i]);

            }

        } else {
            if (this.fireEvent("beforeappend", this.ownerTree, this, node) === false) {
                return false;

            }
            var index = this.childNodes.length;
            var oldParent = node.parentNode;

            if (oldParent) {
                if (node.fireEvent("beforemove", node.getOwnerTree(), node, oldParent, this, index) === false) {
                    return false;

                }
                oldParent.removeChild(node);

            }
            index = this.childNodes.length;
            if (index == 0) {
                this.setFirstChild(node);

            }
            this.childNodes.push(node);
            node.parentNode = this;
            var ps = this.childNodes[index - 1];
            if (ps) {
                node.previousSibling = ps;
                ps.nextSibling = node;

            } else {
                node.previousSibling = null;

            }
            node.nextSibling = null;
            this.setLastChild(node);
            node.setOwnerTree(this.getOwnerTree());
            this.fireEvent("append", this.ownerTree, this, node, index);
            if (oldParent) {
                node.fireEvent("move", this.ownerTree, node, oldParent, this, index);

            }
            return node;

        }

    },
    removeChild: function(node) {
        var index = this.childNodes.indexOf(node);
        if (index == -1) {
            return false;

        }
        if (this.fireEvent("beforeremove", this.ownerTree, this, node) === false) {
            return false;

        }


        this.childNodes.splice(index, 1);


        if (node.previousSibling) {
            node.previousSibling.nextSibling = node.nextSibling;

        }
        if (node.nextSibling) {
            node.nextSibling.previousSibling = node.previousSibling;

        }


        if (this.firstChild == node) {
            this.setFirstChild(node.nextSibling);

        }
        if (this.lastChild == node) {
            this.setLastChild(node.previousSibling);

        }

        node.setOwnerTree(null);

        node.parentNode = null;
        node.previousSibling = null;
        node.nextSibling = null;
        this.fireEvent("remove", this.ownerTree, this, node);
        return node;

    },
    insertBefore: function(node, refNode) {
        if (!refNode) {
            return this.appendChild(node);

        }

        if (node == refNode) {
            return false;

        }

        if (this.fireEvent("beforeinsert", this.ownerTree, this, node, refNode) === false) {
            return false;

        }
        var index = this.childNodes.indexOf(refNode);
        var oldParent = node.parentNode;
        var refIndex = index;


        if (oldParent == this && this.childNodes.indexOf(node) < index) {
            refIndex--;

        }


        if (oldParent) {
            if (node.fireEvent("beforemove", node.getOwnerTree(), node, oldParent, this, index, refNode) === false) {
                return false;

            }
            oldParent.removeChild(node);

        }
        if (refIndex == 0) {
            this.setFirstChild(node);

        }
        this.childNodes.splice(refIndex, 0, node);
        node.parentNode = this;
        var ps = this.childNodes[refIndex - 1];
        if (ps) {
            node.previousSibling = ps;
            ps.nextSibling = node;

        } else {
            node.previousSibling = null;

        }
        node.nextSibling = refNode;
        refNode.previousSibling = node;
        node.setOwnerTree(this.getOwnerTree());
        this.fireEvent("insert", this.ownerTree, this, node, refNode);
        if (oldParent) {
            node.fireEvent("move", this.ownerTree, node, oldParent, this, refIndex, refNode);

        }
        return node;

    },
    remove: function() {
        this.parentNode.removeChild(this);
        return this;

    },
    item: function(index) {
        return this.childNodes[index];

    },
    replaceChild: function(newChild, oldChild) {
        this.insertBefore(newChild, oldChild);
        this.removeChild(oldChild);
        return oldChild;

    },
    indexOf: function(child) {
        return this.childNodes.indexOf(child);

    },
    getOwnerTree: function() {

        if (!this.ownerTree) {
            var p = this;
            while (p) {
                if (p.ownerTree) {
                    this.ownerTree = p.ownerTree;
                    break;

                }
                p = p.parentNode;

            }

        }
        return this.ownerTree;

    },
    getDepth: function() {
        var depth = 0;
        var p = this;
        while (p.parentNode) {
            ++depth;
            p = p.parentNode;

        }
        return depth;

    },
    setOwnerTree: function(tree) {

        if (tree != this.ownerTree) {
            if (this.ownerTree) {
                this.ownerTree.unregisterNode(this);

            }
            this.ownerTree = tree;
            var cs = this.childNodes;
            for (var i = 0, len = cs.length; i < len; i++) {
                cs[i].setOwnerTree(tree);

            }
            if (tree) {
                tree.registerNode(this);

            }

        }

    },
    getPath: function(attr) {
        attr = attr || "id";
        var p = this.parentNode;
        var b = [this.attributes[attr]];
        while (p) {
            b.unshift(p.attributes[attr]);
            p = p.parentNode;

        }
        var sep = this.getOwnerTree().pathSeparator;
        return sep + b.join(sep);

    },
    bubble: function(fn, scope, args) {
        var p = this;
        while (p) {
            if (fn.apply(scope || p, args || [p]) === false) {
                break;

            }
            p = p.parentNode;

        }

    },
    cascade: function(fn, scope, args) {
        if (fn.apply(scope || this, args || [this]) !== false) {
            var cs = this.childNodes;
            for (var i = 0, len = cs.length; i < len; i++) {
                cs[i].cascade(fn, scope, args);

            }

        }

    },
    eachChild: function(fn, scope, args) {
        var cs = this.childNodes;
        for (var i = 0, len = cs.length; i < len; i++) {
            if (fn.apply(scope || this, args || [cs[i]]) === false) {
                break;

            }

        }

    },
    findChild: function(attribute, value) {
        var cs = this.childNodes;
        for (var i = 0, len = cs.length; i < len; i++) {
            if (cs[i].attributes[attribute] == value) {
                return cs[i];

            }

        }
        return null;

    },
    findChildBy: function(fn, scope) {
        var cs = this.childNodes;
        for (var i = 0, len = cs.length; i < len; i++) {
            if (fn.call(scope || cs[i], cs[i]) === true) {
                return cs[i];

            }

        }
        return null;

    },
    sort: function(fn, scope) {
        var cs = this.childNodes;
        var len = cs.length;
        if (len > 0) {
            var sortFn = scope ? 
            function() {
                fn.apply(scope, arguments);
            }: fn;
            cs.sort(sortFn);
            for (var i = 0; i < len; i++) {
                var n = cs[i];
                n.previousSibling = cs[i - 1];
                n.nextSibling = cs[i + 1];
                if (i == 0) {
                    this.setFirstChild(n);

                }
                if (i == len - 1) {
                    this.setLastChild(n);

                }

            }

        }

    },
    contains: function(node) {
        return node.isAncestor(this);

    },
    isAncestor: function(node) {
        var p = this.parentNode;
        while (p) {
            if (p == node) {
                return true;

            }
            p = p.parentNode;

        }
        return false;

    },
    toString: function() {
        return "[Node" + (this.id ? " " + this.id: "") + "]";

    }

});

Ext.data.GroupingStore = Ext.extend(Ext.data.Store, {


    remoteGroup: false,
    groupOnSort: false,
    
clearGrouping: function() {
        this.groupField = false;
        if (this.remoteGroup) {
            if (this.baseParams) {
                delete this.baseParams.groupBy;

            }
            this.reload();

        } else {
            this.applySort();
            this.fireEvent('datachanged', this);

        }

    },
    groupBy: function(field, forceRegroup) {
        if (this.groupField == field && !forceRegroup) {
            return;

        }
        this.groupField = field;
        if (this.remoteGroup) {
            if (!this.baseParams) {
                this.baseParams = {};

            }
            this.baseParams['groupBy'] = field;

        }
        if (this.groupOnSort) {
            this.sort(field);
            return;

        }
        if (this.remoteGroup) {
            this.reload();

        } else {
            var si = this.sortInfo || {};
            if (si.field != field) {
                this.applySort();

            } else {
                this.sortData(field);

            }
            this.fireEvent('datachanged', this);

        }

    },
    applySort: function() {
        Ext.data.GroupingStore.superclass.applySort.call(this);
        if (!this.groupOnSort && !this.remoteGroup) {
            var gs = this.getGroupState();
            if (gs && gs != this.sortInfo.field) {
                this.sortData(this.groupField);

            }

        }

    },
    applyGrouping: function(alwaysFireChange) {
        if (this.groupField !== false) {
            this.groupBy(this.groupField, true);
            return true;

        } else {
            if (alwaysFireChange === true) {
                this.fireEvent('datachanged', this);

            }
            return false;

        }

    },
    getGroupState: function() {
        return this.groupOnSort && this.groupField !== false ? 
        (this.sortInfo ? this.sortInfo.field: undefined) : this.groupField;

    }

});

Ext.ComponentMgr = function() {
    var all = new Ext.util.MixedCollection();
    var types = {};

    return {

        register: function(c) {
            all.add(c);

        },
        unregister: function(c) {
            all.remove(c);

        },
        get: function(id) {
            return all.get(id);

        },
        onAvailable: function(id, fn, scope) {
            all.on("add", 
            function(index, o) {
                if (o.id == id) {
                    fn.call(scope || o, o);
                    all.un("add", fn, scope);

                }

            });

        },
        all: all,
        registerType: function(xtype, cls) {
            types[xtype] = cls;
            cls.xtype = xtype;

        },
        create: function(config, defaultType) {
            return new types[config.xtype || defaultType](config);

        }

    };

} ();


Ext.reg = Ext.ComponentMgr.registerType;
// this will be called a lot internally, shorthand to keep the bytes down

Ext.Component = function(config) {
    config = config || {};
    if (config.initialConfig) {
        if (config.isAction) {
            this.baseAction = config;

        }
        config = config.initialConfig;
    } else if (config.tagName || config.dom || typeof config == "string") {
        config = {
            applyTo: config,
            id: config.id || config
        };

    }


    this.initialConfig = config;

    Ext.apply(this, config);
    this.addEvents(

    'disable', 

    'enable', 

    'beforeshow', 

    'show', 

    'beforehide', 

    'hide', 

    'beforerender', 

    'render', 

    'beforedestroy', 

    'destroy', 

    'beforestaterestore', 

    'staterestore', 

    'beforestatesave', 

    'statesave'
    );
    this.getId();
    Ext.ComponentMgr.register(this);
    Ext.Component.superclass.constructor.call(this);

    if (this.baseAction) {
        this.baseAction.addComponent(this);

    }

    this.initComponent();

    if (this.plugins) {
        if (Ext.isArray(this.plugins)) {
            for (var i = 0, len = this.plugins.length; i < len; i++) {
                this.plugins[i].init(this);

            }

        } else {
            this.plugins.init(this);

        }

    }

    if (this.stateful !== false) {
        this.initState(config);

    }

    if (this.applyTo) {
        this.applyToMarkup(this.applyTo);
        delete this.applyTo;

    } else if (this.renderTo) {
        this.render(this.renderTo);
        delete this.renderTo;

    }

};

Ext.Component.AUTO_ID = 1000;

Ext.extend(Ext.Component, Ext.util.Observable, {
















    disabledClass: "x-item-disabled",
    allowDomMove: true,
    autoShow: false,
    hideMode: 'display',
    hideParent: false,
    

	hidden: false,
    disabled: false,
    rendered: false,
    ctype: "Ext.Component",
    actionMode: "el",
    getActionEl: function() {
        return this[this.actionMode];

    },
    initComponent: Ext.emptyFn,
    render: function(container, position) {
        if (!this.rendered && this.fireEvent("beforerender", this) !== false) {
            if (!container && this.el) {
                this.el = Ext.get(this.el);
                container = this.el.dom.parentNode;
                this.allowDomMove = false;

            }
            this.container = Ext.get(container);
            if (this.ctCls) {
                this.container.addClass(this.ctCls);

            }
            this.rendered = true;
            if (position !== undefined) {
                if (typeof position == 'number') {
                    position = this.container.dom.childNodes[position];

                } else {
                    position = Ext.getDom(position);

                }

            }
            this.onRender(this.container, position || null);
            if (this.autoShow) {
                this.el.removeClass(['x-hidden', 'x-hide-' + this.hideMode]);

            }
            if (this.cls) {
                this.el.addClass(this.cls);
                delete this.cls;

            }
            if (this.style) {
                this.el.applyStyles(this.style);
                delete this.style;

            }
            this.fireEvent("render", this);
            this.afterRender(this.container);
            if (this.hidden) {
                this.hide();

            }
            if (this.disabled) {
                this.disable();

            }

            this.initStateEvents();

        }
        return this;

    },
    initState: function(config) {
        if (Ext.state.Manager) {
            var state = Ext.state.Manager.get(this.stateId || this.id);
            if (state) {
                if (this.fireEvent('beforestaterestore', this, state) !== false) {
                    this.applyState(state);
                    this.fireEvent('staterestore', this, state);

                }

            }

        }

    },
    initStateEvents: function() {
        if (this.stateEvents) {
            for (var i = 0, e; e = this.stateEvents[i]; i++) {
                this.on(e, this.saveState, this, {
                    delay: 100
                });

            }

        }

    },
    applyState: function(state, config) {
        if (state) {
            Ext.apply(this, state);

        }

    },
    getState: function() {
        return null;

    },
    saveState: function() {
        if (Ext.state.Manager) {
            var state = this.getState();
            if (this.fireEvent('beforestatesave', this, state) !== false) {
                Ext.state.Manager.set(this.stateId || this.id, state);
                this.fireEvent('statesave', this, state);

            }

        }

    },
    applyToMarkup: function(el) {
        this.allowDomMove = false;
        this.el = Ext.get(el);
        this.render(this.el.dom.parentNode);

    },
    addClass: function(cls) {
        if (this.el) {
            this.el.addClass(cls);

        } else {
            this.cls = this.cls ? this.cls + ' ' + cls: cls;

        }

    },
    removeClass: function(cls) {
        if (this.el) {
            this.el.removeClass(cls);

        } else if (this.cls) {
            this.cls = this.cls.split(' ').remove(cls).join(' ');

        }

    },
    onRender: function(ct, position) {
        if (this.autoEl) {
            if (typeof this.autoEl == 'string') {
                this.el = document.createElement(this.autoEl);

            } else {
                var div = document.createElement('div');
                Ext.DomHelper.overwrite(div, this.autoEl);
                this.el = div.firstChild;

            }
            if (!this.el.id) {
                this.el.id = this.getId();

            }

        }
        if (this.el) {
            this.el = Ext.get(this.el);
            if (this.allowDomMove !== false) {
                ct.dom.insertBefore(this.el.dom, position);

            }
            if (this.overCls) {
                this.el.addClassOnOver(this.overCls);

            }

        }

    },
    getAutoCreate: function() {
        var cfg = typeof this.autoCreate == "object" ? 
        this.autoCreate: Ext.apply({},
        this.defaultAutoCreate);
        if (this.id && !cfg.id) {
            cfg.id = this.id;

        }
        return cfg;

    },
    afterRender: Ext.emptyFn,
    destroy: function() {
        if (this.fireEvent("beforedestroy", this) !== false) {
            this.beforeDestroy();
            if (this.rendered) {
                this.el.removeAllListeners();
                this.el.remove();
                if (this.actionMode == "container") {
                    this.container.remove();

                }

            }
            this.onDestroy();
            Ext.ComponentMgr.unregister(this);
            this.fireEvent("destroy", this);
            this.purgeListeners();

        }

    },
    beforeDestroy: Ext.emptyFn,
    onDestroy: Ext.emptyFn,
    
getEl: function() {
        return this.el;

    },
    getId: function() {
        return this.id || (this.id = "ext-comp-" + (++Ext.Component.AUTO_ID));

    },
    getItemId: function() {
        return this.itemId || this.getId();

    },
    focus: function(selectText, delay) {
        if (delay) {
            this.focus.defer(typeof delay == 'number' ? delay: 10, this, [selectText, false]);
            return;

        }
        if (this.rendered) {
            this.el.focus();
            if (selectText === true) {
                this.el.dom.select();

            }

        }
        return this;

    },
    blur: function() {
        if (this.rendered) {
            this.el.blur();

        }
        return this;

    },
    disable: function() {
        if (this.rendered) {
            this.onDisable();

        }
        this.disabled = true;
        this.fireEvent("disable", this);
        return this;

    },
    onDisable: function() {
        this.getActionEl().addClass(this.disabledClass);
        this.el.dom.disabled = true;

    },
    enable: function() {
        if (this.rendered) {
            this.onEnable();

        }
        this.disabled = false;
        this.fireEvent("enable", this);
        return this;

    },
    onEnable: function() {
        this.getActionEl().removeClass(this.disabledClass);
        this.el.dom.disabled = false;

    },
    setDisabled: function(disabled) {
        this[disabled ? "disable": "enable"]();

    },
    show: function() {
        if (this.fireEvent("beforeshow", this) !== false) {
            this.hidden = false;
            if (this.autoRender) {
                this.render(typeof this.autoRender == 'boolean' ? Ext.getBody() : this.autoRender);

            }
            if (this.rendered) {
                this.onShow();

            }
            this.fireEvent("show", this);

        }
        return this;

    },
    onShow: function() {
        if (this.hideParent) {
            this.container.removeClass('x-hide-' + this.hideMode);

        } else {
            this.getActionEl().removeClass('x-hide-' + this.hideMode);

        }


    },
    hide: function() {
        if (this.fireEvent("beforehide", this) !== false) {
            this.hidden = true;
            if (this.rendered) {
                this.onHide();

            }
            this.fireEvent("hide", this);

        }
        return this;

    },
    onHide: function() {
        if (this.hideParent) {
            this.container.addClass('x-hide-' + this.hideMode);

        } else {
            this.getActionEl().addClass('x-hide-' + this.hideMode);

        }

    },
    setVisible: function(visible) {
        if (visible) {
            this.show();

        } else {
            this.hide();

        }
        return this;

    },
    isVisible: function() {
        return this.rendered && this.getActionEl().isVisible();

    },
    cloneConfig: function(overrides) {
        overrides = overrides || {};
        var id = overrides.id || Ext.id();
        var cfg = Ext.applyIf(overrides, this.initialConfig);
        cfg.id = id;
        return new this.constructor(cfg);

    },
    getXType: function() {
        return this.constructor.xtype;

    },
    isXType: function(xtype, shallow) {
        return ! shallow ? 
        ('/' + this.getXTypes() + '/').indexOf('/' + xtype + '/') != -1: 
        this.constructor.xtype == xtype;

    },
    getXTypes: function() {
        var tc = this.constructor;
        if (!tc.xtypes) {
            var c = [],
            sc = this;
            while (sc && sc.constructor.xtype) {
                c.unshift(sc.constructor.xtype);
                sc = sc.constructor.superclass;

            }
            tc.xtypeChain = c;
            tc.xtypes = c.join('/');

        }
        return tc.xtypes;

    },
    findParentBy: function(fn) {
        for (var p = this.ownerCt; (p != null) && !fn(p, this); p = p.ownerCt);
        return p || null;

    },
    findParentByType: function(xtype) {
        return typeof xtype == 'function' ? 
        this.findParentBy(function(p) {
            return p.constructor === xtype;

        }) : 
        this.findParentBy(function(p) {
            return p.constructor.xtype === xtype;

        });

    },
    mon: function(item, ename, fn, scope, opt) {
        if (!this.mons) {
            this.mons = [];
            this.on('beforedestroy', 
            function() {
                for (var i = 0, len = this.mons.length; i < len; i++) {
                    var m = this.mons[i];
                    m.item.un(m.ename, m.fn, m.scope);

                }

            },
            this);

        }
        this.mons.push({
            item: item,
            ename: ename,
            fn: fn,
            scope: scope

        });
        item.on(ename, fn, scope, opt);

    }

});

Ext.reg('component', Ext.Component);


Ext.Action = function(config) {
    this.initialConfig = config;
    this.items = [];

}

Ext.Action.prototype = {








    isAction: true,
    setText: function(text) {
        this.initialConfig.text = text;
        this.callEach('setText', [text]);

    },
    getText: function() {
        return this.initialConfig.text;

    },
    setIconClass: function(cls) {
        this.initialConfig.iconCls = cls;
        this.callEach('setIconClass', [cls]);

    },
    getIconClass: function() {
        return this.initialConfig.iconCls;

    },
    setDisabled: function(v) {
        this.initialConfig.disabled = v;
        this.callEach('setDisabled', [v]);

    },
    enable: function() {
        this.setDisabled(false);

    },
    disable: function() {
        this.setDisabled(true);

    },
    isDisabled: function() {
        return this.initialConfig.disabled;

    },
    setHidden: function(v) {
        this.initialConfig.hidden = v;
        this.callEach('setVisible', [!v]);

    },
    show: function() {
        this.setHidden(false);

    },
    hide: function() {
        this.setHidden(true);

    },
    isHidden: function() {
        return this.initialConfig.hidden;

    },
    setHandler: function(fn, scope) {
        this.initialConfig.handler = fn;
        this.initialConfig.scope = scope;
        this.callEach('setHandler', [fn, scope]);

    },
    each: function(fn, scope) {
        Ext.each(this.items, fn, scope);

    },
    callEach: function(fnName, args) {
        var cs = this.items;
        for (var i = 0, len = cs.length; i < len; i++) {
            cs[i][fnName].apply(cs[i], args);

        }

    },
    addComponent: function(comp) {
        this.items.push(comp);
        comp.on('destroy', this.removeComponent, this);

    },
    removeComponent: function(comp) {
        this.items.remove(comp);

    },
    execute: function() {
        this.initialConfig.handler.apply(this.initialConfig.scope || window, arguments);

    }

};

 (function() {
    Ext.Layer = function(config, existingEl) {
        config = config || {};
        var dh = Ext.DomHelper;
        var cp = config.parentEl,
        pel = cp ? Ext.getDom(cp) : document.body;
        if (existingEl) {
            this.dom = Ext.getDom(existingEl);

        }
        if (!this.dom) {
            var o = config.dh || {
                tag: "div",
                cls: "x-layer"
            };
            this.dom = dh.append(pel, o);

        }
        if (config.cls) {
            this.addClass(config.cls);

        }
        this.constrain = config.constrain !== false;
        this.visibilityMode = Ext.Element.VISIBILITY;
        if (config.id) {
            this.id = this.dom.id = config.id;

        } else {
            this.id = Ext.id(this.dom);

        }
        this.zindex = config.zindex || this.getZIndex();
        this.position("absolute", this.zindex);
        if (config.shadow) {
            this.shadowOffset = config.shadowOffset || 4;
            this.shadow = new Ext.Shadow({
                offset: this.shadowOffset,
                mode: config.shadow

            });

        } else {
            this.shadowOffset = 0;

        }
        this.useShim = config.shim !== false && Ext.useShims;
        this.useDisplay = config.useDisplay;
        this.hide();

    };

    var supr = Ext.Element.prototype;


    var shims = [];

    Ext.extend(Ext.Layer, Ext.Element, {

        getZIndex: function() {
            return this.zindex || parseInt(this.getStyle("z-index"), 10) || 11000;

        },
        getShim: function() {
            if (!this.useShim) {
                return null;

            }
            if (this.shim) {
                return this.shim;

            }
            var shim = shims.shift();
            if (!shim) {
                shim = this.createShim();
                shim.enableDisplayMode('block');
                shim.dom.style.display = 'none';
                shim.dom.style.visibility = 'visible';

            }
            var pn = this.dom.parentNode;
            if (shim.dom.parentNode != pn) {
                pn.insertBefore(shim.dom, this.dom);

            }
            shim.setStyle('z-index', this.getZIndex() - 2);
            this.shim = shim;
            return shim;

        },
        hideShim: function() {
            if (this.shim) {
                this.shim.setDisplayed(false);
                shims.push(this.shim);
                delete this.shim;

            }

        },
        disableShadow: function() {
            if (this.shadow) {
                this.shadowDisabled = true;
                this.shadow.hide();
                this.lastShadowOffset = this.shadowOffset;
                this.shadowOffset = 0;

            }

        },
        enableShadow: function(show) {
            if (this.shadow) {
                this.shadowDisabled = false;
                this.shadowOffset = this.lastShadowOffset;
                delete this.lastShadowOffset;
                if (show) {
                    this.sync(true);

                }

            }

        },
        

sync: function(doShow) {
            var sw = this.shadow;
            if (!this.updating && this.isVisible() && (sw || this.useShim)) {
                var sh = this.getShim();

                var w = this.getWidth(),
                h = this.getHeight();

                var l = this.getLeft(true),
                t = this.getTop(true);

                if (sw && !this.shadowDisabled) {
                    if (doShow && !sw.isVisible()) {
                        sw.show(this);

                    } else {
                        sw.realign(l, t, w, h);

                    }
                    if (sh) {
                        if (doShow) {
                            sh.show();

                        }

                        var a = sw.adjusts,
                        s = sh.dom.style;
                        s.left = (Math.min(l, l + a.l)) + "px";
                        s.top = (Math.min(t, t + a.t)) + "px";
                        s.width = (w + a.w) + "px";
                        s.height = (h + a.h) + "px";

                    }

                } else if (sh) {
                    if (doShow) {
                        sh.show();

                    }
                    sh.setSize(w, h);
                    sh.setLeftTop(l, t);

                }


            }

        },
        destroy: function() {
            this.hideShim();
            if (this.shadow) {
                this.shadow.hide();

            }
            this.removeAllListeners();
            Ext.removeNode(this.dom);
            Ext.Element.uncache(this.id);

        },
        remove: function() {
            this.destroy();

        },
        beginUpdate: function() {
            this.updating = true;

        },
        endUpdate: function() {
            this.updating = false;
            this.sync(true);

        },
        hideUnders: function(negOffset) {
            if (this.shadow) {
                this.shadow.hide();

            }
            this.hideShim();

        },
        constrainXY: function() {
            if (this.constrain) {
                var vw = Ext.lib.Dom.getViewWidth(),
                vh = Ext.lib.Dom.getViewHeight();
                var s = Ext.getDoc().getScroll();

                var xy = this.getXY();
                var x = xy[0],
                y = xy[1];
                var w = this.dom.offsetWidth + this.shadowOffset,
                h = this.dom.offsetHeight + this.shadowOffset;

                var moved = false;

                if ((x + w) > vw + s.left) {
                    x = vw - w - this.shadowOffset;
                    moved = true;

                }
                if ((y + h) > vh + s.top) {
                    y = vh - h - this.shadowOffset;
                    moved = true;

                }

                if (x < s.left) {
                    x = s.left;
                    moved = true;

                }
                if (y < s.top) {
                    y = s.top;
                    moved = true;

                }
                if (moved) {
                    if (this.avoidY) {
                        var ay = this.avoidY;
                        if (y <= ay && (y + h) >= ay) {
                            y = ay - h - 5;

                        }

                    }
                    xy = [x, y];
                    this.storeXY(xy);
                    supr.setXY.call(this, xy);
                    this.sync();

                }

            }

        },
        isVisible: function() {
            return this.visible;

        },
        showAction: function() {
            this.visible = true;
            if (this.useDisplay === true) {
                this.setDisplayed("");

            } else if (this.lastXY) {
                supr.setXY.call(this, this.lastXY);

            } else if (this.lastLT) {
                supr.setLeftTop.call(this, this.lastLT[0], this.lastLT[1]);

            }

        },
        hideAction: function() {
            this.visible = false;
            if (this.useDisplay === true) {
                this.setDisplayed(false);

            } else {
                this.setLeftTop( - 10000, -10000);

            }

        },
        setVisible: function(v, a, d, c, e) {
            if (v) {
                this.showAction();

            }
            if (a && v) {
                var cb = function() {
                    this.sync(true);
                    if (c) {
                        c();

                    }

                }.createDelegate(this);
                supr.setVisible.call(this, true, true, d, cb, e);

            } else {
                if (!v) {
                    this.hideUnders(true);

                }
                var cb = c;
                if (a) {
                    cb = function() {
                        this.hideAction();
                        if (c) {
                            c();

                        }

                    }.createDelegate(this);

                }
                supr.setVisible.call(this, v, a, d, cb, e);
                if (v) {
                    this.sync(true);

                } else if (!a) {
                    this.hideAction();

                }

            }

        },
        storeXY: function(xy) {
            delete this.lastLT;
            this.lastXY = xy;

        },
        storeLeftTop: function(left, top) {
            delete this.lastXY;
            this.lastLT = [left, top];

        },
        beforeFx: function() {
            this.beforeAction();
            return Ext.Layer.superclass.beforeFx.apply(this, arguments);

        },
        afterFx: function() {
            Ext.Layer.superclass.afterFx.apply(this, arguments);
            this.sync(this.isVisible());

        },
        beforeAction: function() {
            if (!this.updating && this.shadow) {
                this.shadow.hide();

            }

        },
        setLeft: function(left) {
            this.storeLeftTop(left, this.getTop(true));
            supr.setLeft.apply(this, arguments);
            this.sync();

        },
        setTop: function(top) {
            this.storeLeftTop(this.getLeft(true), top);
            supr.setTop.apply(this, arguments);
            this.sync();

        },
        setLeftTop: function(left, top) {
            this.storeLeftTop(left, top);
            supr.setLeftTop.apply(this, arguments);
            this.sync();

        },
        setXY: function(xy, a, d, c, e) {
            this.fixDisplay();
            this.beforeAction();
            this.storeXY(xy);
            var cb = this.createCB(c);
            supr.setXY.call(this, xy, a, d, cb, e);
            if (!a) {
                cb();

            }

        },
        createCB: function(c) {
            var el = this;
            return function() {
                el.constrainXY();
                el.sync(true);
                if (c) {
                    c();

                }

            };

        },
        setX: function(x, a, d, c, e) {
            this.setXY([x, this.getY()], a, d, c, e);

        },
        setY: function(y, a, d, c, e) {
            this.setXY([this.getX(), y], a, d, c, e);

        },
        setSize: function(w, h, a, d, c, e) {
            this.beforeAction();
            var cb = this.createCB(c);
            supr.setSize.call(this, w, h, a, d, cb, e);
            if (!a) {
                cb();

            }

        },
        setWidth: function(w, a, d, c, e) {
            this.beforeAction();
            var cb = this.createCB(c);
            supr.setWidth.call(this, w, a, d, cb, e);
            if (!a) {
                cb();

            }

        },
        setHeight: function(h, a, d, c, e) {
            this.beforeAction();
            var cb = this.createCB(c);
            supr.setHeight.call(this, h, a, d, cb, e);
            if (!a) {
                cb();

            }

        },
        setBounds: function(x, y, w, h, a, d, c, e) {
            this.beforeAction();
            var cb = this.createCB(c);
            if (!a) {
                this.storeXY([x, y]);
                supr.setXY.call(this, [x, y]);
                supr.setSize.call(this, w, h, a, d, cb, e);
                cb();

            } else {
                supr.setBounds.call(this, x, y, w, h, a, d, cb, e);

            }
            return this;

        },
        setZIndex: function(zindex) {
            this.zindex = zindex;
            this.setStyle("z-index", zindex + 2);
            if (this.shadow) {
                this.shadow.setZIndex(zindex + 1);

            }
            if (this.shim) {
                this.shim.setStyle("z-index", zindex);

            }

        }

    });

})();

Ext.Shadow = function(config) {
    Ext.apply(this, config);
    if (typeof this.mode != "string") {
        this.mode = this.defaultMode;

    }
    var o = this.offset,
    a = {
        h: 0
    };
    var rad = Math.floor(this.offset / 2);
    switch (this.mode.toLowerCase()) {
    case "drop":
        a.w = 0;
        a.l = a.t = o;
        a.t -= 1;
        if (Ext.isIE) {
            a.l -= this.offset + rad;
            a.t -= this.offset + rad;
            a.w -= rad;
            a.h -= rad;
            a.t += 1;

        }
        break;
        case "sides":
        a.w = (o * 2);
        a.l = -o;
        a.t = o - 1;
        if (Ext.isIE) {
            a.l -= (this.offset - rad);
            a.t -= this.offset + rad;
            a.l += 1;
            a.w -= (this.offset - rad) * 2;
            a.w -= rad + 1;
            a.h -= 1;

        }
        break;
        case "frame":
        a.w = a.h = (o * 2);
        a.l = a.t = -o;
        a.t += 1;
        a.h -= 2;
        if (Ext.isIE) {
            a.l -= (this.offset - rad);
            a.t -= (this.offset - rad);
            a.l += 1;
            a.w -= (this.offset + rad + 1);
            a.h -= (this.offset + rad);
            a.h += 1;

        }
        break;

    };

    this.adjusts = a;

};

Ext.Shadow.prototype = {


    offset: 4,
    defaultMode: "drop",
    
show: function(target) {
        target = Ext.get(target);
        if (!this.el) {
            this.el = Ext.Shadow.Pool.pull();
            if (this.el.dom.nextSibling != target.dom) {
                this.el.insertBefore(target);

            }

        }
        this.el.setStyle("z-index", this.zIndex || parseInt(target.getStyle("z-index"), 10) - 1);
        if (Ext.isIE) {
            this.el.dom.style.filter = "progid:DXImageTransform.Microsoft.alpha(opacity=50) progid:DXImageTransform.Microsoft.Blur(pixelradius=" + (this.offset) + ")";

        }
        this.realign(
        target.getLeft(true), 
        target.getTop(true), 
        target.getWidth(), 
        target.getHeight()
        );
        this.el.dom.style.display = "block";

    },
    isVisible: function() {
        return this.el ? true: false;

    },
    realign: function(l, t, w, h) {
        if (!this.el) {
            return;

        }
        var a = this.adjusts,
        d = this.el.dom,
        s = d.style;
        var iea = 0;
        s.left = (l + a.l) + "px";
        s.top = (t + a.t) + "px";
        var sw = (w + a.w),
        sh = (h + a.h),
        sws = sw + "px",
        shs = sh + "px";
        if (s.width != sws || s.height != shs) {
            s.width = sws;
            s.height = shs;
            if (!Ext.isIE) {
                var cn = d.childNodes;
                var sww = Math.max(0, (sw - 12)) + "px";
                cn[0].childNodes[1].style.width = sww;
                cn[1].childNodes[1].style.width = sww;
                cn[2].childNodes[1].style.width = sww;
                cn[1].style.height = Math.max(0, (sh - 12)) + "px";

            }

        }

    },
    hide: function() {
        if (this.el) {
            this.el.dom.style.display = "none";
            Ext.Shadow.Pool.push(this.el);
            delete this.el;

        }

    },
    setZIndex: function(z) {
        this.zIndex = z;
        if (this.el) {
            this.el.setStyle("z-index", z);

        }

    }

};

Ext.Shadow.Pool = function() {
    var p = [];
    var markup = Ext.isIE ? 
    '<div class="x-ie-shadow"></div>': 
    '<div class="x-shadow"><div class="xst"><div class="xstl"></div><div class="xstc"></div><div class="xstr"></div></div><div class="xsc"><div class="xsml"></div><div class="xsmc"></div><div class="xsmr"></div></div><div class="xsb"><div class="xsbl"></div><div class="xsbc"></div><div class="xsbr"></div></div></div>';
    return {
        pull: function() {
            var sh = p.shift();
            if (!sh) {
                sh = Ext.get(Ext.DomHelper.insertHtml("beforeBegin", document.body.firstChild, markup));
                sh.autoBoxAdjust = false;

            }
            return sh;

        },
        push: function(sh) {
            p.push(sh);

        }

    };

} ();

Ext.BoxComponent = Ext.extend(Ext.Component, {











    initComponent: function() {
        Ext.BoxComponent.superclass.initComponent.call(this);
        this.addEvents(

        'resize', 

        'move'
        );

    },
    boxReady: false,
    deferHeight: false,
    setSize: function(w, h) {
        if (typeof w == 'object') {
            h = w.height;
            w = w.width;

        }
        if (!this.boxReady) {
            this.width = w;
            this.height = h;
            return this;

        }

        if (this.lastSize && this.lastSize.width == w && this.lastSize.height == h) {
            return this;

        }
        this.lastSize = {
            width: w,
            height: h
        };
        var adj = this.adjustSize(w, h);
        var aw = adj.width,
        ah = adj.height;
        if (aw !== undefined || ah !== undefined) {
            var rz = this.getResizeEl();
            if (!this.deferHeight && aw !== undefined && ah !== undefined) {
                rz.setSize(aw, ah);

            } else if (!this.deferHeight && ah !== undefined) {
                rz.setHeight(ah);

            } else if (aw !== undefined) {
                rz.setWidth(aw);

            }
            this.onResize(aw, ah, w, h);
            this.fireEvent('resize', this, aw, ah, w, h);

        }
        return this;

    },
    setWidth: function(width) {
        return this.setSize(width);

    },
    setHeight: function(height) {
        return this.setSize(undefined, height);

    },
    getSize: function() {
        return this.el.getSize();

    },
    getPosition: function(local) {
        if (local === true) {
            return [this.el.getLeft(true), this.el.getTop(true)];

        }
        return this.xy || this.el.getXY();

    },
    getBox: function(local) {
        var s = this.el.getSize();
        if (local === true) {
            s.x = this.el.getLeft(true);
            s.y = this.el.getTop(true);

        } else {
            var xy = this.xy || this.el.getXY();
            s.x = xy[0];
            s.y = xy[1];

        }
        return s;

    },
    updateBox: function(box) {
        this.setSize(box.width, box.height);
        this.setPagePosition(box.x, box.y);
        return this;

    },
    getResizeEl: function() {
        return this.resizeEl || this.el;

    },
    getPositionEl: function() {
        return this.positionEl || this.el;

    },
    setPosition: function(x, y) {
        if (x && typeof x[1] == 'number') {
            y = x[1];
            x = x[0];

        }
        this.x = x;
        this.y = y;
        if (!this.boxReady) {
            return this;

        }
        var adj = this.adjustPosition(x, y);
        var ax = adj.x,
        ay = adj.y;

        var el = this.getPositionEl();
        if (ax !== undefined || ay !== undefined) {
            if (ax !== undefined && ay !== undefined) {
                el.setLeftTop(ax, ay);

            } else if (ax !== undefined) {
                el.setLeft(ax);

            } else if (ay !== undefined) {
                el.setTop(ay);

            }
            this.onPosition(ax, ay);
            this.fireEvent('move', this, ax, ay);

        }
        return this;

    },
    setPagePosition: function(x, y) {
        if (x && typeof x[1] == 'number') {
            y = x[1];
            x = x[0];

        }
        this.pageX = x;
        this.pageY = y;
        if (!this.boxReady) {
            return;

        }
        if (x === undefined || y === undefined) {
            return;

        }
        var p = this.el.translatePoints(x, y);
        this.setPosition(p.left, p.top);
        return this;

    },
    onRender: function(ct, position) {
        Ext.BoxComponent.superclass.onRender.call(this, ct, position);
        if (this.resizeEl) {
            this.resizeEl = Ext.get(this.resizeEl);

        }
        if (this.positionEl) {
            this.positionEl = Ext.get(this.positionEl);

        }

    },
    afterRender: function() {
        Ext.BoxComponent.superclass.afterRender.call(this);
        this.boxReady = true;
        this.setSize(this.width, this.height);
        if (this.x || this.y) {
            this.setPosition(this.x, this.y);

        } else if (this.pageX || this.pageY) {
            this.setPagePosition(this.pageX, this.pageY);

        }

    },
    syncSize: function() {
        delete this.lastSize;
        this.setSize(this.autoWidth ? undefined: this.el.getWidth(), this.autoHeight ? undefined: this.el.getHeight());
        return this;

    },
    onResize: function(adjWidth, adjHeight, rawWidth, rawHeight) {

    },
    onPosition: function(x, y) {

    },
    adjustSize: function(w, h) {
	    if (this.autoWidth) {
	        w = 'auto';
	
	    }
	    if (this.autoHeight) {
	        h = 'auto';
	
	    }
	    return {
	        width: w,
	        height: h
	    };

    },
    adjustPosition: function(x, y) {
        return {
            x: x,
            y: y
        };

    }

});
Ext.reg('box', Ext.BoxComponent);

Ext.SplitBar = function(dragElement, resizingElement, orientation, placement, existingProxy) {


    this.el = Ext.get(dragElement, true);
    this.el.dom.unselectable = "on";

    this.resizingEl = Ext.get(resizingElement, true);


    this.orientation = orientation || Ext.SplitBar.HORIZONTAL;


    this.minSize = 0;


    this.maxSize = 2000;


    this.animate = false;


    this.useShim = false;


    this.shim = null;

    if (!existingProxy) {

        this.proxy = Ext.SplitBar.createProxy(this.orientation);

    } else {
        this.proxy = Ext.get(existingProxy).dom;

    }

    this.dd = new Ext.dd.DDProxy(this.el.dom.id, "XSplitBars", {
        dragElId: this.proxy.id
    });


    this.dd.b4StartDrag = this.onStartProxyDrag.createDelegate(this);


    this.dd.endDrag = this.onEndProxyDrag.createDelegate(this);


    this.dragSpecs = {};


    this.adapter = new Ext.SplitBar.BasicLayoutAdapter();
    this.adapter.init(this);

    if (this.orientation == Ext.SplitBar.HORIZONTAL) {

        this.placement = placement || (this.el.getX() > this.resizingEl.getX() ? Ext.SplitBar.LEFT: Ext.SplitBar.RIGHT);
        this.el.addClass("x-splitbar-h");

    } else {

        this.placement = placement || (this.el.getY() > this.resizingEl.getY() ? Ext.SplitBar.TOP: Ext.SplitBar.BOTTOM);
        this.el.addClass("x-splitbar-v");

    }

    this.addEvents(

    "resize", 

    "moved", 

    "beforeresize", 

    "beforeapply"
    );

    Ext.SplitBar.superclass.constructor.call(this);

};

Ext.extend(Ext.SplitBar, Ext.util.Observable, {
    onStartProxyDrag: function(x, y) {
        this.fireEvent("beforeresize", this);
        this.overlay = Ext.DomHelper.append(document.body, {
            cls: "x-drag-overlay",
            html: "&#160;"
        },
        true);
        this.overlay.unselectable();
        this.overlay.setSize(Ext.lib.Dom.getViewWidth(true), Ext.lib.Dom.getViewHeight(true));
        this.overlay.show();
        Ext.get(this.proxy).setDisplayed("block");
        var size = this.adapter.getElementSize(this);
        this.activeMinSize = this.getMinimumSize();;
        this.activeMaxSize = this.getMaximumSize();;
        var c1 = size - this.activeMinSize;
        var c2 = Math.max(this.activeMaxSize - size, 0);
        if (this.orientation == Ext.SplitBar.HORIZONTAL) {
            this.dd.resetConstraints();
            this.dd.setXConstraint(
            this.placement == Ext.SplitBar.LEFT ? c1: c2, 
            this.placement == Ext.SplitBar.LEFT ? c2: c1
            );
            this.dd.setYConstraint(0, 0);

        } else {
            this.dd.resetConstraints();
            this.dd.setXConstraint(0, 0);
            this.dd.setYConstraint(
            this.placement == Ext.SplitBar.TOP ? c1: c2, 
            this.placement == Ext.SplitBar.TOP ? c2: c1
            );

        }
        this.dragSpecs.startSize = size;
        this.dragSpecs.startPoint = [x, y];
        Ext.dd.DDProxy.prototype.b4StartDrag.call(this.dd, x, y);

    },
    onEndProxyDrag: function(e) {
        Ext.get(this.proxy).setDisplayed(false);
        var endPoint = Ext.lib.Event.getXY(e);
        if (this.overlay) {
            this.overlay.remove();
            delete this.overlay;

        }
        var newSize;
        if (this.orientation == Ext.SplitBar.HORIZONTAL) {
            newSize = this.dragSpecs.startSize + 
            (this.placement == Ext.SplitBar.LEFT ? 
            endPoint[0] - this.dragSpecs.startPoint[0] : 
            this.dragSpecs.startPoint[0] - endPoint[0]
            );

        } else {
            newSize = this.dragSpecs.startSize + 
            (this.placement == Ext.SplitBar.TOP ? 
            endPoint[1] - this.dragSpecs.startPoint[1] : 
            this.dragSpecs.startPoint[1] - endPoint[1]
            );

        }
        newSize = Math.min(Math.max(newSize, this.activeMinSize), this.activeMaxSize);
        if (newSize != this.dragSpecs.startSize) {
            if (this.fireEvent('beforeapply', this, newSize) !== false) {
                this.adapter.setElementSize(this, newSize);
                this.fireEvent("moved", this, newSize);
                this.fireEvent("resize", this, newSize);

            }

        }

    },
    getAdapter: function() {
        return this.adapter;

    },
    setAdapter: function(adapter) {
        this.adapter = adapter;
        this.adapter.init(this);

    },
    getMinimumSize: function() {
        return this.minSize;

    },
    setMinimumSize: function(minSize) {
        this.minSize = minSize;

    },
    getMaximumSize: function() {
        return this.maxSize;

    },
    setMaximumSize: function(maxSize) {
        this.maxSize = maxSize;

    },
    setCurrentSize: function(size) {
        var oldAnimate = this.animate;
        this.animate = false;
        this.adapter.setElementSize(this, size);
        this.animate = oldAnimate;

    },
    destroy: function(removeEl) {
        if (this.shim) {
            this.shim.remove();

        }
        this.dd.unreg();
        Ext.removeNode(this.proxy);
        if (removeEl) {
            this.el.remove();

        }

    }

});


Ext.SplitBar.createProxy = function(dir) {
    var proxy = new Ext.Element(document.createElement("div"));
    proxy.unselectable();
    var cls = 'x-splitbar-proxy';
    proxy.addClass(cls + ' ' + (dir == Ext.SplitBar.HORIZONTAL ? cls + '-h': cls + '-v'));
    document.body.appendChild(proxy.dom);
    return proxy.dom;

};


Ext.SplitBar.BasicLayoutAdapter = function() {
    };

Ext.SplitBar.BasicLayoutAdapter.prototype = {

    init: function(s) {

        },
        getElementSize: function(s) {
        if (s.orientation == Ext.SplitBar.HORIZONTAL) {
            return s.resizingEl.getWidth();

        } else {
            return s.resizingEl.getHeight();

        }

    },
    setElementSize: function(s, newSize, onComplete) {
        if (s.orientation == Ext.SplitBar.HORIZONTAL) {
            if (!s.animate) {
                s.resizingEl.setWidth(newSize);
                if (onComplete) {
                    onComplete(s, newSize);

                }

            } else {
                s.resizingEl.setWidth(newSize, true, .1, onComplete, 'easeOut');

            }

        } else {

            if (!s.animate) {
                s.resizingEl.setHeight(newSize);
                if (onComplete) {
                    onComplete(s, newSize);

                }

            } else {
                s.resizingEl.setHeight(newSize, true, .1, onComplete, 'easeOut');

            }

        }

    }

};


Ext.SplitBar.AbsoluteLayoutAdapter = function(container) {
    this.basic = new Ext.SplitBar.BasicLayoutAdapter();
    this.container = Ext.get(container);

};

Ext.SplitBar.AbsoluteLayoutAdapter.prototype = {
    init: function(s) {
        this.basic.init(s);

    },
    getElementSize: function(s) {
        return this.basic.getElementSize(s);

    },
    setElementSize: function(s, newSize, onComplete) {
        this.basic.setElementSize(s, newSize, this.moveSplitter.createDelegate(this, [s]));

    },
    moveSplitter: function(s) {
        var yes = Ext.SplitBar;
        switch (s.placement) {
            case yes.LEFT:
            s.el.setX(s.resizingEl.getRight());
            break;
            case yes.RIGHT:
            s.el.setStyle("right", (this.container.getWidth() - s.resizingEl.getLeft()) + "px");
            break;
            case yes.TOP:
            s.el.setY(s.resizingEl.getBottom());
            break;
            case yes.BOTTOM:
            s.el.setY(s.resizingEl.getTop() - s.el.getHeight());
            break;

        }

    }

};


Ext.SplitBar.VERTICAL = 1;


Ext.SplitBar.HORIZONTAL = 2;


Ext.SplitBar.LEFT = 1;


Ext.SplitBar.RIGHT = 2;


Ext.SplitBar.TOP = 3;


Ext.SplitBar.BOTTOM = 4;


Ext.Container = Ext.extend(Ext.BoxComponent, {
    autoDestroy: true,
    defaultType: 'panel',
    initComponent: function() {
        Ext.Container.superclass.initComponent.call(this);

        this.addEvents(

        'afterlayout', 

        'beforeadd', 

        'beforeremove', 

        'add', 

        'remove'
        );


        var items = this.items;
        if (items) {
            delete this.items;
            if (Ext.isArray(items)) {
                this.add.apply(this, items);

            } else {
                this.add(items);

            }

        }

    },
    initItems: function() {
        if (!this.items) {
            this.items = new Ext.util.MixedCollection(false, this.getComponentId);
            this.getLayout();
        }

    },
    setLayout: function(layout) {
        if (this.layout && this.layout != layout) {
            this.layout.setContainer(null);

        }
        this.initItems();
        this.layout = layout;
        layout.setContainer(this);

    },
    render: function() {
        Ext.Container.superclass.render.apply(this, arguments);
        if (this.layout) {
            if (typeof this.layout == 'string') {
                this.layout = new Ext.Container.LAYOUTS[this.layout.toLowerCase()](this.layoutConfig);

            }
            this.setLayout(this.layout);

            if (this.activeItem !== undefined) {
                var item = this.activeItem;
                delete this.activeItem;
                this.layout.setActiveItem(item);
                return;

            }

        }
        if (!this.ownerCt) {
            this.doLayout();

        }
        if (this.monitorResize === true) {
            Ext.EventManager.onWindowResize(this.doLayout, this, [false]);

        }

    },
    getLayoutTarget: function() {
        return this.el;

    },
    getComponentId: function(comp) {
        return comp.itemId || comp.id;

    },
    add: function(comp) {
        if (!this.items) {
            this.initItems();

        }
        var a = arguments,
        len = a.length;
        if (len > 1) {
            for (var i = 0; i < len; i++) {
                this.add(a[i]);

            }
            return;

        }
        var c = this.lookupComponent(this.applyDefaults(comp));
        var pos = this.items.length;
        if (this.fireEvent('beforeadd', this, c, pos) !== false && this.onBeforeAdd(c) !== false) {
            this.items.add(c);
            c.ownerCt = this;
            this.fireEvent('add', this, c, pos);

        }
        return c;

    },
    insert: function(index, comp) {
        if (!this.items) {
            this.initItems();

        }
        var a = arguments,
        len = a.length;
        if (len > 2) {
            for (var i = len - 1; i >= 1; --i) {
                this.insert(index, a[i]);

            }
            return;

        }
        var c = this.lookupComponent(this.applyDefaults(comp));

        if (c.ownerCt == this && this.items.indexOf(c) < index) {
            --index;

        }

        if (this.fireEvent('beforeadd', this, c, index) !== false && this.onBeforeAdd(c) !== false) {
            this.items.insert(index, c);
            c.ownerCt = this;
            this.fireEvent('add', this, c, index);

        }
        return c;

    },
    applyDefaults: function(c) {
        if (this.defaults) {
            if (typeof c == 'string') {
                c = Ext.ComponentMgr.get(c);
                Ext.apply(c, this.defaults);

            } else if (!c.events) {
                Ext.applyIf(c, this.defaults);

            } else {
                Ext.apply(c, this.defaults);

            }

        }
        return c;

    },
    onBeforeAdd: function(item) {
        if (item.ownerCt) {
            item.ownerCt.remove(item, false);

        }
        if (this.hideBorders === true) {
            item.border = (item.border === true);

        }

    },
    remove: function(comp, autoDestroy) {
        var c = this.getComponent(comp);
        if (c && this.fireEvent('beforeremove', this, c) !== false) {
            this.items.remove(c);
            delete c.ownerCt;
            if (autoDestroy === true || (autoDestroy !== false && this.autoDestroy)) {
                c.destroy();

            }
            if (this.layout && this.layout.activeItem == c) {
                delete this.layout.activeItem;

            }
            this.fireEvent('remove', this, c);

        }
        return c;

    },
    getComponent: function(comp) {
        if (typeof comp == 'object') {
            return comp;

        }
        return this.items.get(comp);

    },
    lookupComponent: function(comp) {
        if (typeof comp == 'string') {
            return Ext.ComponentMgr.get(comp);

        } else if (!comp.events) {
            return this.createComponent(comp);

        }
        return comp;

    },
    createComponent: function(config) {
        return Ext.ComponentMgr.create(config, this.defaultType);

    },
    doLayout: function(shallow) {
        if (this.rendered && this.layout) {
            this.layout.layout();

        }
        if (shallow !== false && this.items) {
            var cs = this.items.items;
            for (var i = 0, len = cs.length; i < len; i++) {
                var c = cs[i];
                if (c.doLayout) {
                    c.doLayout();

                }

            }

        }

    },
    getLayout: function() {
        if (!this.layout) {
            var layout = new Ext.layout.ContainerLayout(this.layoutConfig);
            this.setLayout(layout);

        }
        return this.layout;

    },
    onDestroy: function() {
        if (this.items) {
            var cs = this.items.items;
            for (var i = 0, len = cs.length; i < len; i++) {
                Ext.destroy(cs[i]);

            }

        }
        if (this.monitorResize) {
            Ext.EventManager.removeResizeListener(this.doLayout, this);

        }
        Ext.Container.superclass.onDestroy.call(this);

    },
    bubble: function(fn, scope, args) {
        var p = this;
        while (p) {
            if (fn.apply(scope || p, args || [p]) === false) {
                break;

            }
            p = p.ownerCt;

        }

    },
    cascade: function(fn, scope, args) {
        if (fn.apply(scope || this, args || [this]) !== false) {
            if (this.items) {
                var cs = this.items.items;
                for (var i = 0, len = cs.length; i < len; i++) {
                    if (cs[i].cascade) {
                        cs[i].cascade(fn, scope, args);

                    } else {
                        fn.apply(scope || this, args || [cs[i]]);

                    }

                }

            }

        }

    },
    findById: function(id) {
        var m,
        ct = this;
        this.cascade(function(c) {
            if (ct != c && c.id === id) {
                m = c;
                return false;

            }

        });
        return m || null;

    },
    findByType: function(xtype) {
        return typeof xtype == 'function' ? 
        this.findBy(function(c) {
            return c.constructor === xtype;

        }) : 
        this.findBy(function(c) {
            return c.constructor.xtype === xtype;

        });

    },
    find: function(prop, value) {
        return this.findBy(function(c) {
            return c[prop] === value;

        });

    },
    findBy: function(fn, scope) {
        var m = [],
        ct = this;
        this.cascade(function(c) {
            if (ct != c && fn.call(scope || c, c, ct) === true) {
                m.push(c);

            }

        });
        return m;

    }

});

Ext.Container.LAYOUTS = {};
Ext.reg('container', Ext.Container);

Ext.layout.ContainerLayout = function(config) {
    Ext.apply(this, config);

};

Ext.layout.ContainerLayout.prototype = {





    monitorResize: false,
    activeItem: null,
    layout: function() {
        var target = this.container.getLayoutTarget();
        this.onLayout(this.container, target);
        this.container.fireEvent('afterlayout', this.container, this);

    },
    onLayout: function(ct, target) {
        this.renderAll(ct, target);

    },
    isValidParent: function(c, target) {
        var el = c.getPositionEl ? c.getPositionEl() : c.getEl();
        return el.dom.parentNode == target.dom;

    },
    renderAll: function(ct, target) {
        var items = ct.items.items;
        for (var i = 0, len = items.length; i < len; i++) {
            var c = items[i];
            if (c && (!c.rendered || !this.isValidParent(c, target))) {
                this.renderItem(c, i, target);

            }

        }

    },
    renderItem: function(c, position, target) {
        if (c && !c.rendered) {
            c.render(target, position);
            if (this.extraCls) {
                var t = c.getPositionEl ? c.getPositionEl() : c;
                t.addClass(this.extraCls);

            }
            if (this.renderHidden && c != this.activeItem) {
                c.hide();

            }

        } else if (c && !this.isValidParent(c, target)) {
            if (this.extraCls) {
                c.addClass(this.extraCls);

            }
            if (typeof position == 'number') {
                position = target.dom.childNodes[position];

            }
            target.dom.insertBefore(c.getEl().dom, position || null);
            if (this.renderHidden && c != this.activeItem) {
                c.hide();

            }

        }

    },
    onResize: function() {
        if (this.container.collapsed) {
            return;

        }
        var b = this.container.bufferResize;
        if (b) {
            if (!this.resizeTask) {
                this.resizeTask = new Ext.util.DelayedTask(this.layout, this);
                this.resizeBuffer = typeof b == 'number' ? b: 100;

            }
            this.resizeTask.delay(this.resizeBuffer);

        } else {
            this.layout();

        }

    },
    setContainer: function(ct) {
        if (this.monitorResize && ct != this.container) {
            if (this.container) {
                this.container.un('resize', this.onResize, this);

            }
            if (ct) {
                ct.on('resize', this.onResize, this);

            }

        }
        this.container = ct;

    },
    parseMargins: function(v) {
        var ms = v.split(' ');
        var len = ms.length;
        if (len == 1) {
            ms[1] = ms[0];
            ms[2] = ms[0];
            ms[3] = ms[0];

        }
        if (len == 2) {
            ms[2] = ms[0];
            ms[3] = ms[1];

        }
        return {
            top: parseInt(ms[0], 10) || 0,
            right: parseInt(ms[1], 10) || 0,
            bottom: parseInt(ms[2], 10) || 0,
            left: parseInt(ms[3], 10) || 0

        };

    }

};
Ext.Container.LAYOUTS['auto'] = Ext.layout.ContainerLayout;

Ext.layout.FitLayout = Ext.extend(Ext.layout.ContainerLayout, {

    monitorResize: true,
    onLayout: function(ct, target) {
        Ext.layout.FitLayout.superclass.onLayout.call(this, ct, target);
        if (!this.container.collapsed) {
            this.setItemSize(this.activeItem || ct.items.itemAt(0), target.getStyleSize());

        }

    },
    setItemSize: function(item, size) {
        if (item && size.height > 0) {
            item.setSize(size);

        }

    }

});
Ext.Container.LAYOUTS['fit'] = Ext.layout.FitLayout;

Ext.layout.CardLayout = Ext.extend(Ext.layout.FitLayout, {

    deferredRender: false,
    renderHidden: true,
    setActiveItem: function(item) {
        item = this.container.getComponent(item);
        if (this.activeItem != item) {
            if (this.activeItem) {
                this.activeItem.hide();

            }
            this.activeItem = item;
            item.show();
            this.layout();

        }

    },
    renderAll: function(ct, target) {
        if (this.deferredRender) {
            this.renderItem(this.activeItem, undefined, target);

        } else {
            Ext.layout.CardLayout.superclass.renderAll.call(this, ct, target);

        }

    }

});
Ext.Container.LAYOUTS['card'] = Ext.layout.CardLayout;

Ext.layout.AnchorLayout = Ext.extend(Ext.layout.ContainerLayout, {

    monitorResize: true,
    getAnchorViewSize: function(ct, target) {
        return target.dom == document.body ? 
        target.getViewSize() : target.getStyleSize();

    },
    onLayout: function(ct, target) {
        Ext.layout.AnchorLayout.superclass.onLayout.call(this, ct, target);

        var size = this.getAnchorViewSize(ct, target);

        var w = size.width,
        h = size.height;

        if (w < 20 || h < 20) {
            return;

        }


        var aw,
        ah;
        if (ct.anchorSize) {
            if (typeof ct.anchorSize == 'number') {
                aw = ct.anchorSize;

            } else {
                aw = ct.anchorSize.width;
                ah = ct.anchorSize.height;

            }

        } else {
            aw = ct.initialConfig.width;
            ah = ct.initialConfig.height;

        }

        var cs = ct.items.items,
        len = cs.length,
        i,
        c,
        a,
        cw,
        ch;
        for (i = 0; i < len; i++) {
            c = cs[i];
            if (c.anchor) {
                a = c.anchorSpec;
                if (!a) {
                    var vs = c.anchor.split(' ');
                    c.anchorSpec = a = {
                        right: this.parseAnchor(vs[0], c.initialConfig.width, aw),
                        bottom: this.parseAnchor(vs[1], c.initialConfig.height, ah)

                    };

                }
                cw = a.right ? this.adjustWidthAnchor(a.right(w), c) : undefined;
                ch = a.bottom ? this.adjustHeightAnchor(a.bottom(h), c) : undefined;

                if (cw || ch) {
                    c.setSize(cw || undefined, ch || undefined);

                }

            }

        }

    },
    parseAnchor: function(a, start, cstart) {
        if (a && a != 'none') {
            var last;
            if (/^(r|right|b|bottom)$/i.test(a)) {
                var diff = cstart - start;
                return function(v) {
                    if (v !== last) {
                        last = v;
                        return v - diff;

                    }

                }

            } else if (a.indexOf('%') != -1) {
                var ratio = parseFloat(a.replace('%', '')) * .01;
                return function(v) {
                    if (v !== last) {
                        last = v;
                        return Math.floor(v * ratio);

                    }

                }

            } else {
                a = parseInt(a, 10);
                if (!isNaN(a)) {
                    return function(v) {
                        if (v !== last) {
                            last = v;
                            return v + a;

                        }

                    }

                }

            }

        }
        return false;

    },
    adjustWidthAnchor: function(value, comp) {
        return value;

    },
    adjustHeightAnchor: function(value, comp) {
        return value;

    }



});
Ext.Container.LAYOUTS['anchor'] = Ext.layout.AnchorLayout;

Ext.layout.ColumnLayout = Ext.extend(Ext.layout.ContainerLayout, {

    monitorResize: true,
    extraCls: 'x-column',
    scrollOffset: 0,
    
isValidParent: function(c, target) {
        return c.getEl().dom.parentNode == this.innerCt.dom;

    },
    onLayout: function(ct, target) {
        var cs = ct.items.items,
        len = cs.length,
        c,
        i;

        if (!this.innerCt) {
            target.addClass('x-column-layout-ct');



            this.innerCt = target.createChild({
                cls: 'x-column-inner'
            });
            this.innerCt.createChild({
                cls: 'x-clear'
            });

        }
        this.renderAll(ct, this.innerCt);

        var size = target.getViewSize();

        if (size.width < 1 && size.height < 1) {
            return;

        }

        var w = size.width - target.getPadding('lr') - this.scrollOffset,
        h = size.height - target.getPadding('tb'),
        pw = w;

        this.innerCt.setWidth(w);




        for (i = 0; i < len; i++) {
            c = cs[i];
            if (!c.columnWidth) {
                pw -= (c.getSize().width + c.getEl().getMargins('lr'));

            }

        }

        pw = pw < 0 ? 0: pw;

        for (i = 0; i < len; i++) {
            c = cs[i];
            if (c.columnWidth) {
                c.setSize(Math.floor(c.columnWidth * pw) - c.getEl().getMargins('lr'));

            }

        }

    }



});

Ext.Container.LAYOUTS['column'] = Ext.layout.ColumnLayout;

Ext.layout.BorderLayout = Ext.extend(Ext.layout.ContainerLayout, {
    monitorResize: true,
    rendered: false,
    onLayout: function(ct, target) {
        var collapsed;
        if (!this.rendered) {
            target.position();
            target.addClass('x-border-layout-ct');
            var items = ct.items.items;
            collapsed = [];
            for (var i = 0, len = items.length; i < len; i++) {
                var c = items[i];
                var pos = c.region;
                if (c.collapsed) {
                    collapsed.push(c);

                }
                c.collapsed = false;
                if (!c.rendered) {
                    c.cls = c.cls ? c.cls + ' x-border-panel': 'x-border-panel';
                    c.render(target, i);

                }
                this[pos] = pos != 'center' && c.split ? 
                new Ext.layout.BorderLayout.SplitRegion(this, c.initialConfig, pos) : 
                new Ext.layout.BorderLayout.Region(this, c.initialConfig, pos);
                this[pos].render(target, c);

            }
            this.rendered = true;

        }

        var size = target.getViewSize();
        if (size.width < 20 || size.height < 20) {
            if (collapsed) {
                this.restoreCollapsed = collapsed;

            }
            return;

        } else if (this.restoreCollapsed) {
            collapsed = this.restoreCollapsed;
            delete this.restoreCollapsed;

        }

        var w = size.width,
        h = size.height;
        var centerW = w,
        centerH = h,
        centerY = 0,
        centerX = 0;

        var n = this.north,
        s = this.south,
        west = this.west,
        e = this.east,
        c = this.center;
        if (!c) {
            throw 'No center region defined in BorderLayout ' + ct.id;

        }

        if (n && n.isVisible()) {
            var b = n.getSize();
            var m = n.getMargins();
            b.width = w - (m.left + m.right);
            b.x = m.left;
            b.y = m.top;
            centerY = b.height + b.y + m.bottom;
            centerH -= centerY;
            n.applyLayout(b);

        }
        if (s && s.isVisible()) {
            var b = s.getSize();
            var m = s.getMargins();
            b.width = w - (m.left + m.right);
            b.x = m.left;
            var totalHeight = (b.height + m.top + m.bottom);
            b.y = h - totalHeight + m.top;
            centerH -= totalHeight;
            s.applyLayout(b);

        }
        if (west && west.isVisible()) {
            var b = west.getSize();
            var m = west.getMargins();
            b.height = centerH - (m.top + m.bottom);
            b.x = m.left;
            b.y = centerY + m.top;
            var totalWidth = (b.width + m.left + m.right);
            centerX += totalWidth;
            centerW -= totalWidth;
            west.applyLayout(b);

        }
        if (e && e.isVisible()) {
            var b = e.getSize();
            var m = e.getMargins();
            b.height = centerH - (m.top + m.bottom);
            var totalWidth = (b.width + m.left + m.right);
            b.x = w - totalWidth + m.left;
            b.y = centerY + m.top;
            centerW -= totalWidth;
            e.applyLayout(b);

        }

        var m = c.getMargins();
        var centerBox = {
            x: centerX + m.left,
            y: centerY + m.top,
            width: centerW - (m.left + m.right),
            height: centerH - (m.top + m.bottom)

        };
        c.applyLayout(centerBox);

        if (collapsed) {
            for (var i = 0, len = collapsed.length; i < len; i++) {
                collapsed[i].collapse(false);

            }

        }

        if (Ext.isIE && Ext.isStrict) {
            target.repaint();

        }

    }



});


Ext.layout.BorderLayout.Region = function(layout, config, pos) {
    Ext.apply(this, config);
    this.layout = layout;
    this.position = pos;
    this.state = {};
    if (typeof this.margins == 'string') {
        this.margins = this.layout.parseMargins(this.margins);

    }
    this.margins = Ext.applyIf(this.margins || {},
    this.defaultMargins);
    if (this.collapsible) {
        if (typeof this.cmargins == 'string') {
            this.cmargins = this.layout.parseMargins(this.cmargins);

        }
        if (this.collapseMode == 'mini' && !this.cmargins) {
            this.cmargins = {
                left: 0,
                top: 0,
                right: 0,
                bottom: 0
            };

        } else {
            this.cmargins = Ext.applyIf(this.cmargins || {},
            pos == 'north' || pos == 'south' ? this.defaultNSCMargins: this.defaultEWCMargins);

        }

    }

};

Ext.layout.BorderLayout.Region.prototype = {







    collapsible: false,
            split: false,
            floatable: true,
            minWidth: 50,
            minHeight: 50,
            defaultMargins: {
        left: 0,
        top: 0,
        right: 0,
        bottom: 0
    },
    defaultNSCMargins: {
        left: 5,
        top: 5,
        right: 5,
        bottom: 5
    },
    defaultEWCMargins: {
        left: 5,
        top: 0,
        right: 5,
        bottom: 0
    },
    isCollapsed: false,
    


render: function(ct, p) {
        this.panel = p;
        p.el.enableDisplayMode();
        this.targetEl = ct;
        this.el = p.el;

        var gs = p.getState,
        ps = this.position;
        p.getState = function() {
            return Ext.apply(gs.call(p) || {},
            this.state);

        }.createDelegate(this);

        if (ps != 'center') {
            p.allowQueuedExpand = false;
            p.on({
                beforecollapse: this.beforeCollapse,
                collapse: this.onCollapse,
                beforeexpand: this.beforeExpand,
                expand: this.onExpand,
                hide: this.onHide,
                show: this.onShow,
                scope: this

            });
            if (this.collapsible) {
                p.collapseEl = 'el';
                p.slideAnchor = this.getSlideAnchor();

            }
            if (p.tools && p.tools.toggle) {
                p.tools.toggle.addClass('x-tool-collapse-' + ps);
                p.tools.toggle.addClassOnOver('x-tool-collapse-' + ps + '-over');

            }

        }

    },
    getCollapsedEl: function() {
        if (!this.collapsedEl) {
            if (!this.toolTemplate) {
                var tt = new Ext.Template(
                '<div class="x-tool x-tool-{id}">&#160;</div>'
                );
                tt.disableFormats = true;
                tt.compile();
                Ext.layout.BorderLayout.Region.prototype.toolTemplate = tt;

            }
            this.collapsedEl = this.targetEl.createChild({
                cls: "x-layout-collapsed x-layout-collapsed-" + this.position,
                id: this.panel.id + '-xcollapsed'

            });
            this.collapsedEl.enableDisplayMode('block');

            if (this.collapseMode == 'mini') {
                this.collapsedEl.addClass('x-layout-cmini-' + this.position);
                this.miniCollapsedEl = this.collapsedEl.createChild({
                    cls: "x-layout-mini x-layout-mini-" + this.position,
                    html: "&#160;"

                });
                this.miniCollapsedEl.addClassOnOver('x-layout-mini-over');
                this.collapsedEl.addClassOnOver("x-layout-collapsed-over");
                this.collapsedEl.on('click', this.onExpandClick, this, {
                    stopEvent: true
                });

            } else {
                var t = this.toolTemplate.append(
                this.collapsedEl.dom, 
                {
                    id: 'expand-' + this.position
                },
                true);
                t.addClassOnOver('x-tool-expand-' + this.position + '-over');
                t.on('click', this.onExpandClick, this, {
                    stopEvent: true
                });

                if (this.floatable !== false) {
                    this.collapsedEl.addClassOnOver("x-layout-collapsed-over");
                    this.collapsedEl.on("click", this.collapseClick, this);

                }

            }

        }
        return this.collapsedEl;

    },
    onExpandClick: function(e) {
        if (this.isSlid) {
            this.afterSlideIn();
            this.panel.expand(false);

        } else {
            this.panel.expand();

        }

    },
    onCollapseClick: function(e) {
        this.panel.collapse();

    },
    beforeCollapse: function(p, animate) {
        this.lastAnim = animate;
        if (this.splitEl) {
            this.splitEl.hide();

        }
        this.getCollapsedEl().show();
        this.panel.el.setStyle('z-index', 100);
        this.isCollapsed = true;
        this.layout.layout();

    },
    onCollapse: function(animate) {
        this.panel.el.setStyle('z-index', 1);
        if (this.lastAnim === false || this.panel.animCollapse === false) {
            this.getCollapsedEl().dom.style.visibility = 'visible';

        } else {
            this.getCollapsedEl().slideIn(this.panel.slideAnchor, {
                duration: .2
            });

        }
        this.state.collapsed = true;
        this.panel.saveState();

    },
    beforeExpand: function(animate) {
        var c = this.getCollapsedEl();
        this.el.show();
        if (this.position == 'east' || this.position == 'west') {
            this.panel.setSize(undefined, c.getHeight());

        } else {
            this.panel.setSize(c.getWidth(), undefined);

        }
        c.hide();
        c.dom.style.visibility = 'hidden';
        this.panel.el.setStyle('z-index', 100);

    },
    onExpand: function() {
        this.isCollapsed = false;
        if (this.splitEl) {
            this.splitEl.show();

        }
        this.layout.layout();
        this.panel.el.setStyle('z-index', 1);
        this.state.collapsed = false;
        this.panel.saveState();

    },
    collapseClick: function(e) {
        if (this.isSlid) {
            e.stopPropagation();
            this.slideIn();

        } else {
            e.stopPropagation();
            this.slideOut();

        }

    },
    onHide: function() {
        if (this.isCollapsed) {
            this.getCollapsedEl().hide();

        } else if (this.splitEl) {
            this.splitEl.hide();

        }

    },
    onShow: function() {
        if (this.isCollapsed) {
            this.getCollapsedEl().show();

        } else if (this.splitEl) {
            this.splitEl.show();

        }

    },
    isVisible: function() {
        return ! this.panel.hidden;

    },
    getMargins: function() {
        return this.isCollapsed && this.cmargins ? this.cmargins: this.margins;

    },
    getSize: function() {
        return this.isCollapsed ? this.getCollapsedEl().getSize() : this.panel.getSize();

    },
    setPanel: function(panel) {
        this.panel = panel;

    },
    getMinWidth: function() {
        return this.minWidth;

    },
    getMinHeight: function() {
        return this.minHeight;

    },
    applyLayoutCollapsed: function(box) {
        var ce = this.getCollapsedEl();
        ce.setLeftTop(box.x, box.y);
        ce.setSize(box.width, box.height);

    },
    applyLayout: function(box) {
        if (this.isCollapsed) {
            this.applyLayoutCollapsed(box);

        } else {
            this.panel.setPosition(box.x, box.y);
            this.panel.setSize(box.width, box.height);

        }

    },
    beforeSlide: function() {
        this.panel.beforeEffect();

    },
    afterSlide: function() {
        this.panel.afterEffect();

    },
    initAutoHide: function() {
        if (this.autoHide !== false) {
            if (!this.autoHideHd) {
                var st = new Ext.util.DelayedTask(this.slideIn, this);
                this.autoHideHd = {
                    "mouseout": function(e) {
                        if (!e.within(this.el, true)) {
                            st.delay(500);

                        }

                    },
                    "mouseover": function(e) {
                        st.cancel();

                    },
                    scope: this

                };

            }
            this.el.on(this.autoHideHd);

        }

    },
    clearAutoHide: function() {
        if (this.autoHide !== false) {
            this.el.un("mouseout", this.autoHideHd.mouseout);
            this.el.un("mouseover", this.autoHideHd.mouseover);

        }

    },
    clearMonitor: function() {
        Ext.getDoc().un("click", this.slideInIf, this);

    },
    slideOut: function() {
        if (this.isSlid || this.el.hasActiveFx()) {
            return;

        }
        this.isSlid = true;
        var ts = this.panel.tools;
        if (ts && ts.toggle) {
            ts.toggle.hide();

        }
        this.el.show();
        if (this.position == 'east' || this.position == 'west') {
            this.panel.setSize(undefined, this.collapsedEl.getHeight());

        } else {
            this.panel.setSize(this.collapsedEl.getWidth(), undefined);

        }
        this.restoreLT = [this.el.dom.style.left, this.el.dom.style.top];
        this.el.alignTo(this.collapsedEl, this.getCollapseAnchor());
        this.el.setStyle("z-index", 102);
        if (this.animFloat !== false) {
            this.beforeSlide();
            this.el.slideIn(this.getSlideAnchor(), {
                callback: function() {
                    this.afterSlide();
                    this.initAutoHide();
                    Ext.getDoc().on("click", this.slideInIf, this);

                },
                scope: this,
                block: true

            });

        } else {
            this.initAutoHide();
            Ext.getDoc().on("click", this.slideInIf, this);

        }

    },
    afterSlideIn: function() {
        this.clearAutoHide();
        this.isSlid = false;
        this.clearMonitor();
        this.el.setStyle("z-index", "");
        this.el.dom.style.left = this.restoreLT[0];
        this.el.dom.style.top = this.restoreLT[1];

        var ts = this.panel.tools;
        if (ts && ts.toggle) {
            ts.toggle.show();

        }

    },
    slideIn: function(cb) {
        if (!this.isSlid || this.el.hasActiveFx()) {
            Ext.callback(cb);
            return;

        }
        this.isSlid = false;
        if (this.animFloat !== false) {
            this.beforeSlide();
            this.el.slideOut(this.getSlideAnchor(), {
                callback: function() {
                    this.el.hide();
                    this.afterSlide();
                    this.afterSlideIn();
                    Ext.callback(cb);

                },
                scope: this,
                block: true

            });

        } else {
            this.el.hide();
            this.afterSlideIn();

        }

    },
    slideInIf: function(e) {
        if (!e.within(this.el)) {
            this.slideIn();

        }

    },
    anchors: {
        "west": "left",
        "east": "right",
        "north": "top",
        "south": "bottom"

    },
    sanchors: {
        "west": "l",
        "east": "r",
        "north": "t",
        "south": "b"

    },
    canchors: {
        "west": "tl-tr",
        "east": "tr-tl",
        "north": "tl-bl",
        "south": "bl-tl"

    },
    getAnchor: function() {
        return this.anchors[this.position];

    },
    getCollapseAnchor: function() {
        return this.canchors[this.position];

    },
    getSlideAnchor: function() {
        return this.sanchors[this.position];

    },
    getAlignAdj: function() {
        var cm = this.cmargins;
        switch (this.position) {
            case "west":
            return [0, 0];
            break;
            case "east":
            return [0, 0];
            break;
            case "north":
            return [0, 0];
            break;
            case "south":
            return [0, 0];
            break;

        }

    },
    getExpandAdj: function() {
        var c = this.collapsedEl,
        cm = this.cmargins;
        switch (this.position) {
            case "west":
            return [ - (cm.right + c.getWidth() + cm.left), 0];
            break;
            case "east":
            return [cm.right + c.getWidth() + cm.left, 0];
            break;
            case "north":
            return [0, -(cm.top + cm.bottom + c.getHeight())];
            break;
            case "south":
            return [0, cm.top + cm.bottom + c.getHeight()];
            break;

        }

    }

};


Ext.layout.BorderLayout.SplitRegion = function(layout, config, pos) {
    Ext.layout.BorderLayout.SplitRegion.superclass.constructor.call(this, layout, config, pos);
    this.applyLayout = this.applyFns[pos];

};

Ext.extend(Ext.layout.BorderLayout.SplitRegion, Ext.layout.BorderLayout.Region, {

    splitTip: "Drag to resize.",
    collapsibleSplitTip: "Drag to resize. Double click to hide.",
    useSplitTips: false,
    splitSettings: {
        north: {
            orientation: Ext.SplitBar.VERTICAL,
            placement: Ext.SplitBar.TOP,
            maxFn: 'getVMaxSize',
            minProp: 'minHeight',
            maxProp: 'maxHeight'

        },
        south: {
            orientation: Ext.SplitBar.VERTICAL,
            placement: Ext.SplitBar.BOTTOM,
            maxFn: 'getVMaxSize',
            minProp: 'minHeight',
            maxProp: 'maxHeight'

        },
        east: {
            orientation: Ext.SplitBar.HORIZONTAL,
            placement: Ext.SplitBar.RIGHT,
            maxFn: 'getHMaxSize',
            minProp: 'minWidth',
            maxProp: 'maxWidth'

        },
        west: {
            orientation: Ext.SplitBar.HORIZONTAL,
            placement: Ext.SplitBar.LEFT,
            maxFn: 'getHMaxSize',
            minProp: 'minWidth',
            maxProp: 'maxWidth'

        }

    },
    applyFns: {
        west: function(box) {
            if (this.isCollapsed) {
                return this.applyLayoutCollapsed(box);

            }
            var sd = this.splitEl.dom,
            s = sd.style;
            this.panel.setPosition(box.x, box.y);
            var sw = sd.offsetWidth;
            s.left = (box.x + box.width - sw) + 'px';
            s.top = (box.y) + 'px';
            s.height = Math.max(0, box.height) + 'px';
            this.panel.setSize(box.width - sw, box.height);

        },
        east: function(box) {
            if (this.isCollapsed) {
                return this.applyLayoutCollapsed(box);

            }
            var sd = this.splitEl.dom,
            s = sd.style;
            var sw = sd.offsetWidth;
            this.panel.setPosition(box.x + sw, box.y);
            s.left = (box.x) + 'px';
            s.top = (box.y) + 'px';
            s.height = Math.max(0, box.height) + 'px';
            this.panel.setSize(box.width - sw, box.height);

        },
        north: function(box) {
            if (this.isCollapsed) {
                return this.applyLayoutCollapsed(box);

            }
            var sd = this.splitEl.dom,
            s = sd.style;
            var sh = sd.offsetHeight;
            this.panel.setPosition(box.x, box.y);
            s.left = (box.x) + 'px';
            s.top = (box.y + box.height - sh) + 'px';
            s.width = Math.max(0, box.width) + 'px';
            this.panel.setSize(box.width, box.height - sh);

        },
        south: function(box) {
            if (this.isCollapsed) {
                return this.applyLayoutCollapsed(box);

            }
            var sd = this.splitEl.dom,
            s = sd.style;
            var sh = sd.offsetHeight;
            this.panel.setPosition(box.x, box.y + sh);
            s.left = (box.x) + 'px';
            s.top = (box.y) + 'px';
            s.width = Math.max(0, box.width) + 'px';
            this.panel.setSize(box.width, box.height - sh);

        }

    },
    render: function(ct, p) {
        Ext.layout.BorderLayout.SplitRegion.superclass.render.call(this, ct, p);

        var ps = this.position;

        this.splitEl = ct.createChild({
            cls: "x-layout-split x-layout-split-" + ps,
            html: "&#160;",
            id: this.panel.id + '-xsplit'

        });

        if (this.collapseMode == 'mini') {
            this.miniSplitEl = this.splitEl.createChild({
                cls: "x-layout-mini x-layout-mini-" + ps,
                html: "&#160;"

            });
            this.miniSplitEl.addClassOnOver('x-layout-mini-over');
            this.miniSplitEl.on('click', this.onCollapseClick, this, {
                stopEvent: true
            });

        }

        var s = this.splitSettings[ps];

        this.split = new Ext.SplitBar(this.splitEl.dom, p.el, s.orientation);
        this.split.placement = s.placement;
        this.split.getMaximumSize = this[s.maxFn].createDelegate(this);
        this.split.minSize = this.minSize || this[s.minProp];
        this.split.on("beforeapply", this.onSplitMove, this);
        this.split.useShim = this.useShim === true;
        this.maxSize = this.maxSize || this[s.maxProp];

        if (p.hidden) {
            this.splitEl.hide();

        }

        if (this.useSplitTips) {
            this.splitEl.dom.title = this.collapsible ? this.collapsibleSplitTip: this.splitTip;

        }
        if (this.collapsible) {
            this.splitEl.on("dblclick", this.onCollapseClick, this);

        }

    },
    getSize: function() {
        if (this.isCollapsed) {
            return this.collapsedEl.getSize();

        }
        var s = this.panel.getSize();
        if (this.position == 'north' || this.position == 'south') {
            s.height += this.splitEl.dom.offsetHeight;

        } else {
            s.width += this.splitEl.dom.offsetWidth;

        }
        return s;

    },
    getHMaxSize: function() {
        var cmax = this.maxSize || 10000;
        var center = this.layout.center;
        return Math.min(cmax, (this.el.getWidth() + center.el.getWidth()) - center.getMinWidth());

    },
    getVMaxSize: function() {
        var cmax = this.maxSize || 10000;
        var center = this.layout.center;
        return Math.min(cmax, (this.el.getHeight() + center.el.getHeight()) - center.getMinHeight());

    },
    onSplitMove: function(split, newSize) {
        var s = this.panel.getSize();
        this.lastSplitSize = newSize;
        if (this.position == 'north' || this.position == 'south') {
            this.panel.setSize(s.width, newSize);
            this.state.height = newSize;

        } else {
            this.panel.setSize(newSize, s.height);
            this.state.width = newSize;

        }
        this.layout.layout();
        this.panel.saveState();
        return false;

    },
    getSplitBar: function() {
        return this.split;

    }

});

Ext.Container.LAYOUTS['border'] = Ext.layout.BorderLayout;

Ext.layout.FormLayout = Ext.extend(Ext.layout.AnchorLayout, {



    labelSeparator: ':',
    getAnchorViewSize: function(ct, target) {
        return ct.body.getStyleSize();

    },
    setContainer: function(ct) {
        Ext.layout.FormLayout.superclass.setContainer.call(this, ct);

        if (ct.labelAlign) {
            ct.addClass('x-form-label-' + ct.labelAlign);

        }

        if (ct.hideLabels) {
            this.labelStyle = "display:none";
            this.elementStyle = "padding-left:0;";
            this.labelAdjust = 0;

        } else {
            this.labelSeparator = ct.labelSeparator || this.labelSeparator;
            ct.labelWidth = ct.labelWidth || 100;
            if (typeof ct.labelWidth == 'number') {
                var pad = (typeof ct.labelPad == 'number' ? ct.labelPad: 5);
                this.labelAdjust = ct.labelWidth + pad;
                this.labelStyle = "width:" + ct.labelWidth + "px;";
                this.elementStyle = "padding-left:" + (ct.labelWidth + pad) + 'px';

            }
            if (ct.labelAlign == 'top') {
                this.labelStyle = "width:auto;";
                this.labelAdjust = 0;
                this.elementStyle = "padding-left:0;";

            }

        }

        if (!this.fieldTpl) {
            var t = new Ext.Template(
            '<div class="x-form-item {5}" tabIndex="-1">', 
            '<label for="{0}" style="{2}" class="x-form-item-label">{1}{4}</label>', 
            '<div class="x-form-element" id="x-form-el-{0}" style="{3}">', 
            '</div><div class="{6}"></div>', 
            '</div>'
            );
            t.disableFormats = true;
            t.compile();
            Ext.layout.FormLayout.prototype.fieldTpl = t;

        }

    },
    renderItem: function(c, position, target) {
        if (c && !c.rendered && c.isFormField && c.inputType != 'hidden') {
            var args = [
            c.id, c.fieldLabel, 
            c.labelStyle || this.labelStyle || '', 
            this.elementStyle || '', 
            typeof c.labelSeparator == 'undefined' ? this.labelSeparator: c.labelSeparator, 
            (c.itemCls || this.container.itemCls || '') + (c.hideLabel ? ' x-hide-label': ''), 
            c.clearCls || 'x-form-clear-left'
            ];
            if (typeof position == 'number') {
                position = target.dom.childNodes[position] || null;

            }
            if (position) {
                this.fieldTpl.insertBefore(position, args);

            } else {
                this.fieldTpl.append(target, args);

            }
            c.render('x-form-el-' + c.id);

        } else {
            Ext.layout.FormLayout.superclass.renderItem.apply(this, arguments);

        }

    },
    adjustWidthAnchor: function(value, comp) {
        return value - (comp.isFormField ? (comp.hideLabel ? 0: this.labelAdjust) : 0);

    },
    isValidParent: function(c, target) {
        return true;

    }



});

Ext.Container.LAYOUTS['form'] = Ext.layout.FormLayout;

Ext.layout.Accordion = Ext.extend(Ext.layout.FitLayout, {

    fill: true,
    autoWidth: true,
    titleCollapse: true,
    hideCollapseTool: false,
    collapseFirst: false,
    animate: false,
    sequence: false,
    activeOnTop: false,
    renderItem: function(c) {
        if (this.animate === false) {
            c.animCollapse = false;

        }
        c.collapsible = true;
        if (this.autoWidth) {
            c.autoWidth = true;

        }
        if (this.titleCollapse) {
            c.titleCollapse = true;

        }
        if (this.hideCollapseTool) {
            c.hideCollapseTool = true;

        }
        if (this.collapseFirst !== undefined) {
            c.collapseFirst = this.collapseFirst;

        }
        if (!this.activeItem && !c.collapsed) {
            this.activeItem = c;

        } else if (this.activeItem) {
            c.collapsed = true;

        }
        Ext.layout.Accordion.superclass.renderItem.apply(this, arguments);
        c.header.addClass('x-accordion-hd');
        c.on('beforeexpand', this.beforeExpand, this);

    },
    beforeExpand: function(p, anim) {
        var ai = this.activeItem;
        if (ai) {
            if (this.sequence) {
                delete this.activeItem;
                if (!ai.collapsed) {
                    ai.collapse({
                        callback: function() {
                            p.expand(anim || true);

                        },
                        scope: this
                    });
                    return false;

                }

            } else {
                ai.collapse(this.animate);

            }

        }
        this.activeItem = p;
        if (this.activeOnTop) {
            p.el.dom.parentNode.insertBefore(p.el.dom, p.el.dom.parentNode.firstChild);

        }
        this.layout();

    },
    setItemSize: function(item, size) {
        if (this.fill && item) {
            var items = this.container.items.items;
            var hh = 0;
            for (var i = 0, len = items.length; i < len; i++) {
                var p = items[i];
                if (p != item) {
                    hh += (p.getSize().height - p.bwrap.getHeight());

                }

            }
            size.height -= hh;
            item.setSize(size);

        }

    }

});
Ext.Container.LAYOUTS['accordion'] = Ext.layout.Accordion;

Ext.layout.TableLayout = Ext.extend(Ext.layout.ContainerLayout, {



    monitorResize: false,
    setContainer: function(ct) {
        Ext.layout.TableLayout.superclass.setContainer.call(this, ct);

        this.currentRow = 0;
        this.currentColumn = 0;
        this.cells = [];

    },
    onLayout: function(ct, target) {
        var cs = ct.items.items,
        len = cs.length,
        c,
        i;

        if (!this.table) {
            target.addClass('x-table-layout-ct');

            this.table = target.createChild(
            {
                tag: 'table',
                cls: 'x-table-layout',
                cellspacing: 0,
                cn: {
                    tag: 'tbody'
                }
            },
            null, true);

            this.renderAll(ct, target);

        }

    },
    getRow: function(index) {
        var row = this.table.tBodies[0].childNodes[index];
        if (!row) {
            row = document.createElement('tr');
            this.table.tBodies[0].appendChild(row);

        }
        return row;

    },
    getNextCell: function(c) {
        var cell = this.getNextNonSpan(this.currentColumn, this.currentRow);
        var curCol = this.currentColumn = cell[0],
        curRow = this.currentRow = cell[1];
        for (var rowIndex = curRow; rowIndex < curRow + (c.rowspan || 1); rowIndex++) {
            if (!this.cells[rowIndex]) {
                this.cells[rowIndex] = [];

            }
            for (var colIndex = curCol; colIndex < curCol + (c.colspan || 1); colIndex++) {
                this.cells[rowIndex][colIndex] = true;

            }

        }
        var td = document.createElement('td');
        if (c.cellId) {
            td.id = c.cellId;

        }
        var cls = 'x-table-layout-cell';
        if (c.cellCls) {
            cls += ' ' + c.cellCls;

        }
        td.className = cls;
        if (c.colspan) {
            td.colSpan = c.colspan;

        }
        if (c.rowspan) {
            td.rowSpan = c.rowspan;

        }
        this.getRow(curRow).appendChild(td);
        return td;

    },
    getNextNonSpan: function(colIndex, rowIndex) {
        var cols = this.columns;
        while ((cols && colIndex >= cols) || (this.cells[rowIndex] && this.cells[rowIndex][colIndex])) {
            if (cols && colIndex >= cols) {
                rowIndex++;
                colIndex = 0;

            } else {
                colIndex++;

            }

        }
        return [colIndex, rowIndex];

    },
    renderItem: function(c, position, target) {
        if (c && !c.rendered) {
            c.render(this.getNextCell(c));

        }

    },
    isValidParent: function(c, target) {
        return true;

    }



});

Ext.Container.LAYOUTS['table'] = Ext.layout.TableLayout;

Ext.layout.AbsoluteLayout = Ext.extend(Ext.layout.AnchorLayout, {
    extraCls: 'x-abs-layout-item',
    isForm: false,
    setContainer: function(ct) {
        Ext.layout.AbsoluteLayout.superclass.setContainer.call(this, ct);
        if (ct.isXType('form')) {
            this.isForm = true;

        }

    },
    onLayout: function(ct, target) {
        if (this.isForm) {
            ct.body.position();
        } else {
            target.position();
        }
        Ext.layout.AbsoluteLayout.superclass.onLayout.call(this, ct, target);

    },
    getAnchorViewSize: function(ct, target) {
        return this.isForm ? ct.body.getStyleSize() : Ext.layout.AbsoluteLayout.superclass.getAnchorViewSize.call(this, ct, target);

    },
    isValidParent: function(c, target) {
        return this.isForm ? true: Ext.layout.AbsoluteLayout.superclass.isValidParent.call(this, c, target);

    },
    adjustWidthAnchor: function(value, comp) {
        return value ? value - comp.getPosition(true)[0] : value;

    },
    adjustHeightAnchor: function(value, comp) {
        return value ? value - comp.getPosition(true)[1] : value;

    }


});
Ext.Container.LAYOUTS['absolute'] = Ext.layout.AbsoluteLayout;

Ext.Viewport = Ext.extend(Ext.Container, {












    initComponent: function() {
        Ext.Viewport.superclass.initComponent.call(this);
        document.getElementsByTagName('html')[0].className += ' x-viewport';
        this.el = Ext.getBody();
        this.el.setHeight = Ext.emptyFn;
        this.el.setWidth = Ext.emptyFn;
        this.el.setSize = Ext.emptyFn;
        this.el.dom.scroll = 'no';
        this.allowDomMove = false;
        this.autoWidth = true;
        this.autoHeight = true;
        Ext.EventManager.onWindowResize(this.fireResize, this);
        this.renderTo = this.el;

    },
    fireResize: function(w, h) {
        this.fireEvent('resize', this, w, h, w, h);

    }

});
Ext.reg('viewport', Ext.Viewport);

Ext.Panel = Ext.extend(Ext.Container, {
    baseCls: 'x-panel',
    collapsedCls: 'x-panel-collapsed',
    maskDisabled: true,
    animCollapse: Ext.enableFx,
    headerAsText: true,
    buttonAlign: 'right',
    collapsed: false,
    collapseFirst: true,
    minButtonWidth: 75,
    elements: 'body',
    toolTarget: 'header',
    collapseEl: 'bwrap',
    slideAnchor: 't',
    deferHeight: true,
    expandDefaults: {
        duration: .25
    },
    collapseDefaults: {
        duration: .25
    },
    initComponent: function() {
        Ext.Panel.superclass.initComponent.call(this);

        this.addEvents(

        'bodyresize', 

        'titlechange', 

        'collapse', 

        'expand', 

        'beforecollapse', 

        'beforeexpand', 

        'beforeclose', 

        'close', 

        'activate', 

        'deactivate'
        );

        if (this.tbar) {
            this.elements += ',tbar';
            if (typeof this.tbar == 'object') {
                this.topToolbar = this.tbar;

            }
            delete this.tbar;

        }
        if (this.bbar) {
            this.elements += ',bbar';
            if (typeof this.bbar == 'object') {
                this.bottomToolbar = this.bbar;

            }
            delete this.bbar;

        }

        if (this.header === true) {
            this.elements += ',header';
            delete this.header;

        } else if (this.title && this.header !== false) {
            this.elements += ',header';

        }

        if (this.footer === true) {
            this.elements += ',footer';
            delete this.footer;

        }

        if (this.buttons) {
            var btns = this.buttons;

            this.buttons = [];
            for (var i = 0, len = btns.length; i < len; i++) {
                if (btns[i].render) {
                    this.buttons.push(btns[i]);

                } else {
                    this.addButton(btns[i]);

                }

            }

        }
        if (this.autoLoad) {
            this.on('render', this.doAutoLoad, this, {
                delay: 10
            });

        }

    },
    createElement: function(name, pnode) {
        if (this[name]) {
            pnode.appendChild(this[name].dom);
            return;

        }

        if (name === 'bwrap' || this.elements.indexOf(name) != -1) {
            if (this[name + 'Cfg']) {
                this[name] = Ext.fly(pnode).createChild(this[name + 'Cfg']);

            } else {
                var el = document.createElement('div');
                el.className = this[name + 'Cls'];
                this[name] = Ext.get(pnode.appendChild(el));

            }

        }

    },
    onRender: function(ct, position) {
        Ext.Panel.superclass.onRender.call(this, ct, position);

        this.createClasses();

        if (this.el) {
            this.el.addClass(this.baseCls);
            this.header = this.el.down('.' + this.headerCls);
            this.bwrap = this.el.down('.' + this.bwrapCls);
            var cp = this.bwrap ? this.bwrap: this.el;
            this.tbar = cp.down('.' + this.tbarCls);
            this.body = cp.down('.' + this.bodyCls);
            this.bbar = cp.down('.' + this.bbarCls);
            this.footer = cp.down('.' + this.footerCls);
            this.fromMarkup = true;

        } else {
            this.el = ct.createChild({
                id: this.id,
                cls: this.baseCls

            },
            position);

        }
        var el = this.el,
        d = el.dom;
        if (this.cls) {
            this.el.addClass(this.cls);

        }

        if (this.buttons) {
            this.elements += ',footer';

        }


        if (this.frame) {
            el.insertHtml('afterBegin', String.format(Ext.Element.boxMarkup, this.baseCls));

            this.createElement('header', d.firstChild.firstChild.firstChild);
            this.createElement('bwrap', d);

            var bw = this.bwrap.dom;
            var ml = d.childNodes[1],
            bl = d.childNodes[2];
            bw.appendChild(ml);
            bw.appendChild(bl);

            var mc = bw.firstChild.firstChild.firstChild;
            this.createElement('tbar', mc);
            this.createElement('body', mc);
            this.createElement('bbar', mc);
            this.createElement('footer', bw.lastChild.firstChild.firstChild);

            if (!this.footer) {
                this.bwrap.dom.lastChild.className += ' x-panel-nofooter';

            }

        } else {

            this.createElement('header', d);
            this.createElement('bwrap', d);

            var bw = this.bwrap.dom;
            this.createElement('tbar', bw);
            this.createElement('body', bw);
            this.createElement('bbar', bw);
            this.createElement('footer', bw);

            if (!this.header) {
                this.body.addClass(this.bodyCls + '-noheader');
                if (this.tbar) {
                    this.tbar.addClass(this.tbarCls + '-noheader');
                }
            }
        }

        if (this.border === false) {
            this.el.addClass(this.baseCls + '-noborder');
            this.body.addClass(this.bodyCls + '-noborder');
            if (this.header) {
                this.header.addClass(this.headerCls + '-noborder');
            }
            if (this.footer) {
                this.footer.addClass(this.footerCls + '-noborder');
            }
            if (this.tbar) {
                this.tbar.addClass(this.tbarCls + '-noborder');
            }
            if (this.bbar) {
                this.bbar.addClass(this.bbarCls + '-noborder');
            }
        }

        if (this.bodyBorder === false) {
            this.body.addClass(this.bodyCls + '-noborder');
        }

        if (this.bodyStyle) {
            this.body.applyStyles(this.bodyStyle);
        }

        this.bwrap.enableDisplayMode('block');

        if (this.header) {
            this.header.unselectable();

            if (this.headerAsText) {
                this.header.dom.innerHTML = 
                '<span class="' + this.headerTextCls + '">' + this.header.dom.innerHTML + '</span>';

                if (this.iconCls) {
                    this.setIconClass(this.iconCls);

                }

            }

        }

        if (this.floating) {
            this.makeFloating(this.floating);

        }

        if (this.collapsible) {
            this.tools = this.tools ? this.tools.slice(0) : [];
            if (!this.hideCollapseTool) {
                this.tools[this.collapseFirst ? 'unshift': 'push']({
                    id: 'toggle',
                    handler: this.toggleCollapse,
                    scope: this

                });

            }
            if (this.titleCollapse && this.header) {
                this.header.on('click', this.toggleCollapse, this);
                this.header.setStyle('cursor', 'pointer');

            }

        }
        if (this.tools) {
            var ts = this.tools;
            this.tools = {};
            this.addTool.apply(this, ts);

        } else {
            this.tools = {};

        }

        if (this.buttons && this.buttons.length > 0) {
            var tb = this.footer.createChild({
                cls: 'x-panel-btns-ct',
                cn: {
                    cls: "x-panel-btns x-panel-btns-" + this.buttonAlign,
                    html: '<table cellspacing="0"><tbody><tr></tr></tbody></table><div class="x-clear"></div>'

                }
            },
            null, true);
            var tr = tb.getElementsByTagName('tr')[0];
            for (var i = 0, len = this.buttons.length; i < len; i++) {
                var b = this.buttons[i];
                var td = document.createElement('td');
                td.className = 'x-panel-btn-td';
                b.render(tr.appendChild(td));

            }

        }

        if (this.tbar && this.topToolbar) {
            if (Ext.isArray(this.topToolbar)) {
                this.topToolbar = new Ext.Toolbar(this.topToolbar);

            }
            this.topToolbar.render(this.tbar);
            this.topToolbar.ownerCt = this;

        }
        if (this.bbar && this.bottomToolbar) {
            if (Ext.isArray(this.bottomToolbar)) {
                this.bottomToolbar = new Ext.Toolbar(this.bottomToolbar);

            }
            this.bottomToolbar.render(this.bbar);
            this.bottomToolbar.ownerCt = this;

        }

    },
    setIconClass: function(cls) {
        var old = this.iconCls;
        this.iconCls = cls;
        if (this.rendered && this.header) {
            if (this.frame) {
                this.header.addClass('x-panel-icon');
                this.header.replaceClass(old, this.iconCls);

            } else {
                var hd = this.header.dom;
                var img = hd.firstChild && String(hd.firstChild.tagName).toLowerCase() == 'img' ? hd.firstChild: null;
                if (img) {
                    Ext.fly(img).replaceClass(old, this.iconCls);

                } else {
                    Ext.DomHelper.insertBefore(hd.firstChild, {
                        tag: 'img',
                        src: Ext.BLANK_IMAGE_URL,
                        cls: 'x-panel-inline-icon ' + this.iconCls

                    });

                }

            }

        }

    },
    makeFloating: function(cfg) {
        this.floating = true;
        this.el = new Ext.Layer(
        typeof cfg == 'object' ? cfg: {
            shadow: this.shadow !== undefined ? this.shadow: 'sides',
            shadowOffset: this.shadowOffset,
            constrain: false,
            shim: this.shim === false ? false: undefined

        },
        this.el
        );

    },
    getTopToolbar: function() {
        return this.topToolbar;

    },
    getBottomToolbar: function() {
        return this.bottomToolbar;

    },
    addButton: function(config, handler, scope) {
        var bc = {
            handler: handler,
            scope: scope,
            minWidth: this.minButtonWidth,
            hideParent: true

        };
        if (typeof config == "string") {
            bc.text = config;

        } else {
            Ext.apply(bc, config);

        }
        var btn = new Ext.Button(bc);
        btn.ownerCt = this;
        if (!this.buttons) {
            this.buttons = [];

        }
        this.buttons.push(btn);
        return btn;

    },
    addTool: function() {
        if (!this[this.toolTarget]) {
            return;

        }
        if (!this.toolTemplate) {
            var tt = new Ext.Template(
            '<div class="x-tool x-tool-{id}">&#160;</div>'
            );
            tt.disableFormats = true;
            tt.compile();
            Ext.Panel.prototype.toolTemplate = tt;

        }
        for (var i = 0, a = arguments, len = a.length; i < len; i++) {
            var tc = a[i],
            overCls = 'x-tool-' + tc.id + '-over';
            var t = this.toolTemplate.insertFirst((tc.align !== 'left') ? this[this.toolTarget] : this[this.toolTarget].child('span'), tc, true);
            this.tools[tc.id] = t;
            t.enableDisplayMode('block');
            t.on('click', this.createToolHandler(t, tc, overCls, this));
            if (tc.on) {
                t.on(tc.on);

            }
            if (tc.hidden) {
                t.hide();

            }
            if (tc.qtip) {
                if (typeof tc.qtip == 'object') {
                    Ext.QuickTips.register(Ext.apply({
                        target: t.id

                    },
                    tc.qtip));

                } else {
                    t.dom.qtip = tc.qtip;

                }

            }
            t.addClassOnOver(overCls);

        }

    },
    onShow: function() {
        if (this.floating) {
            return this.el.show();

        }
        Ext.Panel.superclass.onShow.call(this);

    },
    onHide: function() {
        if (this.floating) {
            return this.el.hide();

        }
        Ext.Panel.superclass.onHide.call(this);

    },
    createToolHandler: function(t, tc, overCls, panel) {
        return function(e) {
            t.removeClass(overCls);
            e.stopEvent();
            if (tc.handler) {
                tc.handler.call(tc.scope || t, e, t, panel);

            }

        };

    },
    afterRender: function() {
        if (this.fromMarkup && this.height === undefined && !this.autoHeight) {
            this.height = this.el.getHeight();

        }
        if (this.floating && !this.hidden && !this.initHidden) {
            this.el.show();

        }
        if (this.title) {
            this.setTitle(this.title);

        }
        this.setAutoScroll();
        if (this.html) {
            this.body.update(typeof this.html == 'object' ? 
            Ext.DomHelper.markup(this.html) : 
            this.html);
            delete this.html;

        }
        if (this.contentEl) {
            var ce = Ext.getDom(this.contentEl);
            Ext.fly(ce).removeClass(['x-hidden', 'x-hide-display']);
            this.body.dom.appendChild(ce);

        }
        if (this.collapsed) {
            this.collapsed = false;
            this.collapse(false);

        }
        Ext.Panel.superclass.afterRender.call(this);
        this.initEvents();

    },
    setAutoScroll: function() {
        if (this.rendered && this.autoScroll) {
            this.body.setOverflow('auto');

        }

    },
    getKeyMap: function() {
        if (!this.keyMap) {
            this.keyMap = new Ext.KeyMap(this.el, this.keys);

        }
        return this.keyMap;

    },
    initEvents: function() {
        if (this.keys) {
            this.getKeyMap();

        }
        if (this.draggable) {
            this.initDraggable();

        }

    },
    initDraggable: function() {

        this.dd = new Ext.Panel.DD(this, typeof this.draggable == 'boolean' ? null: this.draggable);

    },
    beforeEffect: function() {
        if (this.floating) {
            this.el.beforeAction();

        }
        this.el.addClass('x-panel-animated');

    },
    afterEffect: function() {
        this.syncShadow();
        this.el.removeClass('x-panel-animated');

    },
    createEffect: function(a, cb, scope) {
        var o = {
            scope: scope,
            block: true

        };
        if (a === true) {
            o.callback = cb;
            return o;

        } else if (!a.callback) {
            o.callback = cb;

        } else {
            o.callback = function() {
                cb.call(scope);
                Ext.callback(a.callback, a.scope);

            };

        }
        return Ext.applyIf(o, a);

    },
    collapse: function(animate) {
        if (this.collapsed || this.el.hasFxBlock() || this.fireEvent('beforecollapse', this, animate) === false) {
            return;

        }
        var doAnim = animate === true || (animate !== false && this.animCollapse);
        this.beforeEffect();
        this.onCollapse(doAnim, animate);
        return this;

    },
    onCollapse: function(doAnim, animArg) {
        if (doAnim) {
            this[this.collapseEl].slideOut(this.slideAnchor, 
            Ext.apply(this.createEffect(animArg || true, this.afterCollapse, this), 
            this.collapseDefaults));

        } else {
            this[this.collapseEl].hide();
            this.afterCollapse();

        }

    },
    afterCollapse: function() {
        this.collapsed = true;
        this.el.addClass(this.collapsedCls);
        this.afterEffect();
        this.fireEvent('collapse', this);

    },
    expand: function(animate) {
        if (!this.collapsed || this.el.hasFxBlock() || this.fireEvent('beforeexpand', this, animate) === false) {
            return;

        }
        var doAnim = animate === true || (animate !== false && this.animCollapse);
        this.el.removeClass(this.collapsedCls);
        this.beforeEffect();
        this.onExpand(doAnim, animate);
        return this;

    },
    onExpand: function(doAnim, animArg) {
        if (doAnim) {
            this[this.collapseEl].slideIn(this.slideAnchor, 
            Ext.apply(this.createEffect(animArg || true, this.afterExpand, this), 
            this.expandDefaults));

        } else {
            this[this.collapseEl].show();
            this.afterExpand();

        }

    },
    afterExpand: function() {
        this.collapsed = false;
        this.afterEffect();
        this.fireEvent('expand', this);

    },
    toggleCollapse: function(animate) {
        this[this.collapsed ? 'expand': 'collapse'](animate);
        return this;

    },
    onDisable: function() {
        if (this.rendered && this.maskDisabled) {
            this.el.mask();

        }
        Ext.Panel.superclass.onDisable.call(this);

    },
    onEnable: function() {
        if (this.rendered && this.maskDisabled) {
            this.el.unmask();

        }
        Ext.Panel.superclass.onEnable.call(this);

    },
    onResize: function(w, h) {
        if (w !== undefined || h !== undefined) {
            if (!this.collapsed) {
                if (typeof w == 'number') {
                    this.body.setWidth(
                    this.adjustBodyWidth(w - this.getFrameWidth()));

                } else if (w == 'auto') {
                    this.body.setWidth(w);

                }

                if (typeof h == 'number') {
                    this.body.setHeight(
                    this.adjustBodyHeight(h - this.getFrameHeight()));

                } else if (h == 'auto') {
                    this.body.setHeight(h);

                }

            } else {
                this.queuedBodySize = {
                    width: w,
                    height: h
                };
                if (!this.queuedExpand && this.allowQueuedExpand !== false) {
                    this.queuedExpand = true;
                    this.on('expand', 
                    function() {
                        delete this.queuedExpand;
                        this.onResize(this.queuedBodySize.width, this.queuedBodySize.height);
                        this.doLayout();

                    },
                    this, {
                        single: true
                    });

                }

            }
            this.fireEvent('bodyresize', this, w, h);

        }
        this.syncShadow();

    },
    adjustBodyHeight: function(h) {
        return h;

    },
    adjustBodyWidth: function(w) {
        return w;

    },
    onPosition: function() {
        this.syncShadow();

    },
    onDestroy: function() {
        if (this.tools) {
            for (var k in this.tools) {
                Ext.destroy(this.tools[k]);

            }

        }
        if (this.buttons) {
            for (var b in this.buttons) {
                Ext.destroy(this.buttons[b]);

            }

        }
        Ext.destroy(
        this.topToolbar, 
        this.bottomToolbar
        );
        Ext.Panel.superclass.onDestroy.call(this);

    },
    getFrameWidth: function() {
        var w = this.el.getFrameWidth('lr');

        if (this.frame) {
            var l = this.bwrap.dom.firstChild;
            w += (Ext.fly(l).getFrameWidth('l') + Ext.fly(l.firstChild).getFrameWidth('r'));
            var mc = this.bwrap.dom.firstChild.firstChild.firstChild;
            w += Ext.fly(mc).getFrameWidth('lr');

        }
        return w;

    },
    getFrameHeight: function() {
        var h = this.el.getFrameWidth('tb');
        h += (this.tbar ? this.tbar.getHeight() : 0) + 
        (this.bbar ? this.bbar.getHeight() : 0);

        if (this.frame) {
            var hd = this.el.dom.firstChild;
            var ft = this.bwrap.dom.lastChild;
            h += (hd.offsetHeight + ft.offsetHeight);
            var mc = this.bwrap.dom.firstChild.firstChild.firstChild;
            h += Ext.fly(mc).getFrameWidth('tb');

        } else {
            h += (this.header ? this.header.getHeight() : 0) + 
            (this.footer ? this.footer.getHeight() : 0);

        }
        return h;

    },
    getInnerWidth: function() {
        return this.getSize().width - this.getFrameWidth();

    },
    getInnerHeight: function() {
        return this.getSize().height - this.getFrameHeight();

    },
    syncShadow: function() {
        if (this.floating) {
            this.el.sync(true);

        }

    },
    getLayoutTarget: function() {
        return this.body;

    },
    setTitle: function(title, iconCls) {
        this.title = title;
        if (this.header && this.headerAsText) {
            this.header.child('span').update(title);

        }
        if (iconCls) {
            this.setIconClass(iconCls);

        }
        this.fireEvent('titlechange', this, title);
        return this;

    },
    getUpdater: function() {
        return this.body.getUpdater();

    },
    load: function() {
        var um = this.body.getUpdater();
        um.update.apply(um, arguments);
        return this;

    },
    beforeDestroy: function() {
        Ext.Element.uncache(
        this.header, 
        this.tbar, 
        this.bbar, 
        this.footer, 
        this.body
        );

    },
    createClasses: function() {
        this.headerCls = this.baseCls + '-header';
        this.headerTextCls = this.baseCls + '-header-text';
        this.bwrapCls = this.baseCls + '-bwrap';
        this.tbarCls = this.baseCls + '-tbar';
        this.bodyCls = this.baseCls + '-body';
        this.bbarCls = this.baseCls + '-bbar';
        this.footerCls = this.baseCls + '-footer';

    },
    createGhost: function(cls, useShim, appendTo) {
        var el = document.createElement('div');
        el.className = 'x-panel-ghost ' + (cls ? cls: '');
        if (this.header) {
            el.appendChild(this.el.dom.firstChild.cloneNode(true));

        }
        Ext.fly(el.appendChild(document.createElement('ul'))).setHeight(this.bwrap.getHeight());
        el.style.width = this.el.dom.offsetWidth + 'px';;
        if (!appendTo) {
            this.container.dom.appendChild(el);

        } else {
            Ext.getDom(appendTo).appendChild(el);

        }
        if (useShim !== false && this.el.useShim !== false) {
            var layer = new Ext.Layer({
                shadow: false,
                useDisplay: true,
                constrain: false
            },
            el);
            layer.show();
            return layer;

        } else {
            return new Ext.Element(el);

        }

    },
    doAutoLoad: function() {
        this.body.load(
        typeof this.autoLoad == 'object' ? 
        this.autoLoad: {
            url: this.autoLoad
        });

    }



});
Ext.reg('panel', Ext.Panel);


Ext.Window = Ext.extend(Ext.Panel, {

    baseCls: 'x-window',
    resizable: true,
    draggable: true,
    closable: true,
    constrain: false,
    constrainHeader: false,
    plain: false,
    minimizable: false,
    maximizable: false,
    minHeight: 100,
    minWidth: 200,
    expandOnShow: true,
    closeAction: 'close',
    elements: 'header,body',

	collapsible: false,
	
	initHidden: true,
	
	monitorResize: true,
	
	frame: true,
	
	floating: true,
	
	initComponent: function() {
        Ext.Window.superclass.initComponent.call(this);
        this.addEvents(



        'resize', 

        'maximize', 

        'minimize', 

        'restore'
        );

    },
    getState: function() {
        return Ext.apply(Ext.Window.superclass.getState.call(this) || {},
        this.getBox());

    },
    onRender: function(ct, position) {
        Ext.Window.superclass.onRender.call(this, ct, position);

        if (this.plain) {
            this.el.addClass('x-window-plain');

        }

        this.focusEl = this.el.createChild({
            tag: "a",
            href: "#",
            cls: "x-dlg-focus",
            tabIndex: "-1",
            html: "&#160;"
        });
        this.focusEl.swallowEvent('click', true);

        this.proxy = this.el.createProxy("x-window-proxy");
        this.proxy.enableDisplayMode('block');

        if (this.modal) {
            this.mask = this.container.createChild({
                cls: "ext-el-mask"
            },
            this.el.dom);
            this.mask.enableDisplayMode("block");
            this.mask.hide();

        }

    },
    initEvents: function() {
        Ext.Window.superclass.initEvents.call(this);
        if (this.animateTarget) {
            this.setAnimateTarget(this.animateTarget);

        }

        if (this.resizable) {
            this.resizer = new Ext.Resizable(this.el, {
                minWidth: this.minWidth,
                minHeight: this.minHeight,
                handles: this.resizeHandles || "all",
                pinned: true,
                resizeElement: this.resizerAction

            });
            this.resizer.window = this;
            this.resizer.on("beforeresize", this.beforeResize, this);

        }

        if (this.draggable) {
            this.header.addClass("x-window-draggable");

        }
        this.initTools();

        this.el.on("mousedown", this.toFront, this);
        this.manager = this.manager || Ext.WindowMgr;
        this.manager.register(this);
        this.hidden = true;
        if (this.maximized) {
            this.maximized = false;
            this.maximize();

        }
        if (this.closable) {
            var km = this.getKeyMap();
            km.on(27, this.onEsc, this);
            km.disable();

        }

    },
    initDraggable: function() {

        this.dd = new Ext.Window.DD(this);

    },
    onEsc: function() {
        this[this.closeAction]();

    },
    beforeDestroy: function() {
        Ext.destroy(
        this.resizer, 
        this.dd, 
        this.proxy, 
        this.mask
        );
        Ext.Window.superclass.beforeDestroy.call(this);

    },
    onDestroy: function() {
        if (this.manager) {
            this.manager.unregister(this);

        }
        Ext.Window.superclass.onDestroy.call(this);

    },
    initTools: function() {
        if (this.minimizable) {
            this.addTool({
                id: 'minimize',
                handler: this.minimize.createDelegate(this, [])

            });

        }
        if (this.maximizable) {
            this.addTool({
                id: 'maximize',
                handler: this.maximize.createDelegate(this, [])

            });
            this.addTool({
                id: 'restore',
                handler: this.restore.createDelegate(this, []),
                hidden: true

            });
            this.header.on('dblclick', this.toggleMaximize, this);

        }
        if (this.closable) {
            this.addTool({
                id: 'close',
                handler: this[this.closeAction].createDelegate(this, [])

            });

        }

    },
    resizerAction: function() {
        var box = this.proxy.getBox();
        this.proxy.hide();
        this.window.handleResize(box);
        return box;

    },
    beforeResize: function() {
        this.resizer.minHeight = Math.max(this.minHeight, this.getFrameHeight() + 40);
        this.resizer.minWidth = Math.max(this.minWidth, this.getFrameWidth() + 40);
        this.resizeBox = this.el.getBox();

    },
    updateHandles: function() {
        if (Ext.isIE && this.resizer) {
            this.resizer.syncHandleHeight();
            this.el.repaint();

        }

    },
    handleResize: function(box) {
        var rz = this.resizeBox;
        if (rz.x != box.x || rz.y != box.y) {
            this.updateBox(box);

        } else {
            this.setSize(box);

        }
        this.focus();
        this.updateHandles();
        this.saveState();
        this.fireEvent("resize", this, box.width, box.height);

    },
    focus: function() {
        var f = this.focusEl,
        db = this.defaultButton,
        t = typeof db;
        if (t != 'undefined') {
            if (t == 'number') {
                f = this.buttons[db];

            } else if (t == 'string') {
                f = Ext.getCmp(db);

            } else {
                f = db;

            }

        }
        f.focus.defer(10, f);

    },
    setAnimateTarget: function(el) {
        el = Ext.get(el);
        this.animateTarget = el;

    },
    beforeShow: function() {
        delete this.el.lastXY;
        delete this.el.lastLT;
        if (this.x === undefined || this.y === undefined) {
            var xy = this.el.getAlignToXY(this.container, 'c-c');
            var pos = this.el.translatePoints(xy[0], xy[1]);
            this.x = this.x === undefined ? pos.left: this.x;
            this.y = this.y === undefined ? pos.top: this.y;

        }
        this.el.setLeftTop(this.x, this.y);

        if (this.expandOnShow) {
            this.expand(false);

        }

        if (this.modal) {
            Ext.getBody().addClass("x-body-masked");
            this.mask.setSize(Ext.lib.Dom.getViewWidth(true), Ext.lib.Dom.getViewHeight(true));
            this.mask.show();

        }

    },
    show: function(animateTarget, cb, scope) {
        if (!this.rendered) {
            this.render(Ext.getBody());

        }
        if (this.hidden === false) {
            this.toFront();
            return;

        }
        if (this.fireEvent("beforeshow", this) === false) {
            return;

        }
        if (cb) {
            this.on('show', cb, scope, {
                single: true
            });

        }
        this.hidden = false;
        if (animateTarget !== undefined) {
            this.setAnimateTarget(animateTarget);

        }
        this.beforeShow();
        if (this.animateTarget) {
            this.animShow();

        } else {
            this.afterShow();

        }

    },
    afterShow: function() {
        this.proxy.hide();
        this.el.setStyle('display', 'block');
        this.el.show();
        if (this.maximized) {
            this.fitContainer();

        }
        if (Ext.isMac && Ext.isGecko) {
            this.cascade(this.setAutoScroll);

        }

        if (this.monitorResize || this.modal || this.constrain || this.constrainHeader) {
            Ext.EventManager.onWindowResize(this.onWindowResize, this);

        }
        this.doConstrain();
        if (this.layout) {
            this.doLayout();

        }
        if (this.keyMap) {
            this.keyMap.enable();

        }
        this.toFront();
        this.updateHandles();
        this.fireEvent("show", this);

    },
    animShow: function() {
        this.proxy.show();
        this.proxy.setBox(this.animateTarget.getBox());
        this.proxy.setOpacity(0);
        var b = this.getBox(false);
        b.callback = this.afterShow;
        b.scope = this;
        b.duration = .25;
        b.easing = 'easeNone';
        b.opacity = .5;
        b.block = true;
        this.el.setStyle('display', 'none');
        this.proxy.shift(b);

    },
    hide: function(animateTarget, cb, scope) {
        if (this.hidden || this.fireEvent("beforehide", this) === false) {
            return;

        }
        if (cb) {
            this.on('hide', cb, scope, {
                single: true
            });

        }
        this.hidden = true;
        if (animateTarget !== undefined) {
            this.setAnimateTarget(animateTarget);

        }
        if (this.animateTarget) {
            this.animHide();

        } else {
            this.el.hide();
            this.afterHide();

        }

    },
    afterHide: function() {
        this.proxy.hide();
        if (this.monitorResize || this.modal || this.constrain || this.constrainHeader) {
            Ext.EventManager.removeResizeListener(this.onWindowResize, this);

        }
        if (this.modal) {
            this.mask.hide();
            Ext.getBody().removeClass("x-body-masked");

        }
        if (this.keyMap) {
            this.keyMap.disable();

        }
        this.fireEvent("hide", this);

    },
    animHide: function() {
        this.proxy.setOpacity(.5);
        this.proxy.show();
        var tb = this.getBox(false);
        this.proxy.setBox(tb);
        this.el.hide();
        var b = this.animateTarget.getBox();
        b.callback = this.afterHide;
        b.scope = this;
        b.duration = .25;
        b.easing = 'easeNone';
        b.block = true;
        b.opacity = 0;
        this.proxy.shift(b);

    },
    onWindowResize: function() {
        if (this.maximized) {
            this.fitContainer();

        }
        if (this.modal) {
            this.mask.setSize('100%', '100%');
            var force = this.mask.dom.offsetHeight;
            this.mask.setSize(Ext.lib.Dom.getViewWidth(true), Ext.lib.Dom.getViewHeight(true));

        }
        this.doConstrain();

    },
    doConstrain: function() {
        if (this.constrain || this.constrainHeader) {
            var offsets;
            if (this.constrain) {
                offsets = {
                    right: this.el.shadowOffset,
                    left: this.el.shadowOffset,
                    bottom: this.el.shadowOffset

                };

            } else {
                var s = this.getSize();
                offsets = {
                    right: -(s.width - 100),
                    bottom: -(s.height - 25)

                };

            }

            var xy = this.el.getConstrainToXY(this.container, true, offsets);
            if (xy) {
                this.setPosition(xy[0], xy[1]);

            }

        }

    },
    ghost: function(cls) {
        var ghost = this.createGhost(cls);
        var box = this.getBox(true);
        ghost.setLeftTop(box.x, box.y);
        ghost.setWidth(box.width);
        this.el.hide();
        this.activeGhost = ghost;
        return ghost;

    },
    unghost: function(show, matchPosition) {
        if (show !== false) {
            this.el.show();
            this.focus();
            if (Ext.isMac && Ext.isGecko) {
                this.cascade(this.setAutoScroll);

            }

        }
        if (matchPosition !== false) {
            this.setPosition(this.activeGhost.getLeft(true), this.activeGhost.getTop(true));

        }
        this.activeGhost.hide();
        this.activeGhost.remove();
        delete this.activeGhost;

    },
    minimize: function() {
        this.fireEvent('minimize', this);

    },
    close: function() {
        if (this.fireEvent("beforeclose", this) !== false) {
            this.hide(null, 
            function() {
                this.fireEvent('close', this);
                this.destroy();

            },
            this);

        }

    },
    maximize: function() {
        if (!this.maximized) {
            this.expand(false);
            this.restoreSize = this.getSize();
            this.restorePos = this.getPosition(true);
            if (this.maximizable) {
                this.tools.maximize.hide();
                this.tools.restore.show();

            }
            this.maximized = true;
            this.el.disableShadow();

            if (this.dd) {
                this.dd.lock();

            }
            if (this.collapsible) {
                this.tools.toggle.hide();

            }
            this.el.addClass('x-window-maximized');
            this.container.addClass('x-window-maximized-ct');

            this.setPosition(0, 0);
            this.fitContainer();
            this.fireEvent('maximize', this);

        }

    },
    restore: function() {
        if (this.maximized) {
            this.el.removeClass('x-window-maximized');
            this.tools.restore.hide();
            this.tools.maximize.show();
            this.setPosition(this.restorePos[0], this.restorePos[1]);
            this.setSize(this.restoreSize.width, this.restoreSize.height);
            delete this.restorePos;
            delete this.restoreSize;
            this.maximized = false;
            this.el.enableShadow(true);

            if (this.dd) {
                this.dd.unlock();

            }
            if (this.collapsible) {
                this.tools.toggle.show();

            }
            this.container.removeClass('x-window-maximized-ct');

            this.doConstrain();
            this.fireEvent('restore', this);

        }

    },
    toggleMaximize: function() {
        this[this.maximized ? 'restore': 'maximize']();

    },
    fitContainer: function() {
        var vs = this.container.getViewSize();
        this.setSize(vs.width, vs.height);

    },
    setZIndex: function(index) {
        if (this.modal) {
            this.mask.setStyle("z-index", index);

        }
        this.el.setZIndex(++index);
        index += 5;

        if (this.resizer) {
            this.resizer.proxy.setStyle("z-index", ++index);

        }

        this.lastZIndex = index;

    },
    alignTo: function(element, position, offsets) {
        var xy = this.el.getAlignToXY(element, position, offsets);
        this.setPagePosition(xy[0], xy[1]);
        return this;

    },
    anchorTo: function(el, alignment, offsets, monitorScroll, _pname) {
        var action = function() {
            this.alignTo(el, alignment, offsets);

        };
        Ext.EventManager.onWindowResize(action, this);
        var tm = typeof monitorScroll;
        if (tm != 'undefined') {
            Ext.EventManager.on(window, 'scroll', action, this, 
            {
                buffer: tm == 'number' ? monitorScroll: 50
            });

        }
        action.call(this);
        this[_pname] = action;
        return this;

    },
    toFront: function() {
        if (this.manager.bringToFront(this)) {
            this.focus();

        }
        return this;

    },
    setActive: function(active) {
        if (active) {
            if (!this.maximized) {
                this.el.enableShadow(true);

            }
            this.fireEvent('activate', this);

        } else {
            this.el.disableShadow();
            this.fireEvent('deactivate', this);

        }

    },
    toBack: function() {
        this.manager.sendToBack(this);
        return this;

    },
    center: function() {
        var xy = this.el.getAlignToXY(this.container, 'c-c');
        this.setPagePosition(xy[0], xy[1]);
        return this;

    }

});
Ext.reg('window', Ext.Window);

Ext.Window.DD = function(win) {
    this.win = win;
    Ext.Window.DD.superclass.constructor.call(this, win.el.id, 'WindowDD-' + win.id);
    this.setHandleElId(win.header.id);
    this.scroll = false;

};

Ext.extend(Ext.Window.DD, Ext.dd.DD, {
    moveOnly: true,
    headerOffsets: [100, 25],
    startDrag: function() {
        var w = this.win;
        this.proxy = w.ghost();
        if (w.constrain !== false) {
            var so = w.el.shadowOffset;
            this.constrainTo(w.container, {
                right: so,
                left: so,
                bottom: so
            });

        } else if (w.constrainHeader !== false) {
            var s = this.proxy.getSize();
            this.constrainTo(w.container, {
                right: -(s.width - this.headerOffsets[0]),
                bottom: -(s.height - this.headerOffsets[1])
            });

        }

    },
    b4Drag: Ext.emptyFn,
    onDrag: function(e) {
        this.alignElWithMouse(this.proxy, e.getPageX(), e.getPageY());

    },
    endDrag: function(e) {
        this.win.unghost();
        this.win.saveState();

    }

});


Ext.WindowGroup = function() {
    var list = {};
    var accessList = [];
    var front = null;

    var sortWindows = function(d1, d2) {
        return (!d1._lastAccess || d1._lastAccess < d2._lastAccess) ? -1: 1;

    };

    var orderWindows = function() {
        var a = accessList,
        len = a.length;
        if (len > 0) {
            a.sort(sortWindows);
            var seed = a[0].manager.zseed;
            for (var i = 0; i < len; i++) {
                var win = a[i];
                if (win && !win.hidden) {
                    win.setZIndex(seed + (i * 10));

                }

            }

        }
        activateLast();

    };

    var setActiveWin = function(win) {
        if (win != front) {
            if (front) {
                front.setActive(false);

            }
            front = win;
            if (win) {
                win.setActive(true);

            }

        }

    };

    var activateLast = function() {
        for (var i = accessList.length - 1; i >= 0; --i) {
            if (!accessList[i].hidden) {
                setActiveWin(accessList[i]);
                return;

            }

        }
        setActiveWin(null);

    };

    return {

        zseed: 9000,
        register: function(win) {
            list[win.id] = win;
            accessList.push(win);
            win.on('hide', activateLast);

        },
        unregister: function(win) {
            delete list[win.id];
            win.un('hide', activateLast);
            accessList.remove(win);

        },
        get: function(id) {
            return typeof id == "object" ? id: list[id];

        },
        bringToFront: function(win) {
            win = this.get(win);
            if (win != front) {
                win._lastAccess = new Date().getTime();
                orderWindows();
                return true;

            }
            return false;

        },
        sendToBack: function(win) {
            win = this.get(win);
            win._lastAccess = -(new Date().getTime());
            orderWindows();
            return win;

        },
        hideAll: function() {
            for (var id in list) {
                if (list[id] && typeof list[id] != "function" && list[id].isVisible()) {
                    list[id].hide();

                }

            }

        },
        getActive: function() {
            return front;

        },
        getBy: function(fn, scope) {
            var r = [];
            for (var i = accessList.length - 1; i >= 0; --i) {
                var win = accessList[i];
                if (fn.call(scope || win, win) !== false) {
                    r.push(win);

                }

            }
            return r;

        },
        each: function(fn, scope) {
            for (var id in list) {
                if (list[id] && typeof list[id] != "function") {
                    if (fn.call(scope || list[id], list[id]) === false) {
                        return;

                    }

                }

            }

        }

    };

};



Ext.WindowMgr = new Ext.WindowGroup();

Ext.dd.PanelProxy = function(panel, config) {
    this.panel = panel;
    this.id = this.panel.id + '-ddproxy';
    Ext.apply(this, config);

};

Ext.dd.PanelProxy.prototype = {

    insertProxy: true,
    setStatus: Ext.emptyFn,
    reset: Ext.emptyFn,
    update: Ext.emptyFn,
    stop: Ext.emptyFn,
    sync: Ext.emptyFn,
    getEl: function() {
        return this.ghost;

    },
    getGhost: function() {
        return this.ghost;

    },
    getProxy: function() {
        return this.proxy;

    },
    hide: function() {
        if (this.ghost) {
            if (this.proxy) {
                this.proxy.remove();
                delete this.proxy;

            }
            this.panel.el.dom.style.display = '';
            this.ghost.remove();
            delete this.ghost;

        }

    },
    show: function() {
        if (!this.ghost) {
            this.ghost = this.panel.createGhost(undefined, undefined, Ext.getBody());
            this.ghost.setXY(this.panel.el.getXY())
            if (this.insertProxy) {
                this.proxy = this.panel.el.insertSibling({
                    cls: 'x-panel-dd-spacer'
                });
                this.proxy.setSize(this.panel.getSize());

            }
            this.panel.el.dom.style.display = 'none';

        }

    },
    repair: function(xy, callback, scope) {
        this.hide();
        if (typeof callback == "function") {
            callback.call(scope || this);

        }

    },
    moveProxy: function(parentNode, before) {
        if (this.proxy) {
            parentNode.insertBefore(this.proxy.dom, before);

        }

    }

};


Ext.Panel.DD = function(panel, cfg) {
    this.panel = panel;
    this.dragData = {
        panel: panel
    };
    this.proxy = new Ext.dd.PanelProxy(panel, cfg);
    Ext.Panel.DD.superclass.constructor.call(this, panel.el, cfg);
    var h = panel.header;
    if (h) {
        this.setHandleElId(h.id);

    }
    (h ? h: this.panel.body).setStyle('cursor', 'move');
    this.scroll = false;

};

Ext.extend(Ext.Panel.DD, Ext.dd.DragSource, {
    showFrame: Ext.emptyFn,
    startDrag: Ext.emptyFn,
    b4StartDrag: function(x, y) {
        this.proxy.show();

    },
    b4MouseDown: function(e) {
        var x = e.getPageX();
        var y = e.getPageY();
        this.autoOffset(x, y);

    },
    onInitDrag: function(x, y) {
        this.onStartDrag(x, y);
        return true;

    },
    createFrame: Ext.emptyFn,
    getDragEl: function(e) {
        return this.proxy.ghost.dom;

    },
    endDrag: function(e) {
        this.proxy.hide();
        this.panel.saveState();

    },
    autoOffset: function(x, y) {
        x -= this.startPageX;
        y -= this.startPageY;
        this.setDelta(x, y);

    }

});

Ext.state.Provider = function() {

    this.addEvents("statechange");
    this.state = {};
    Ext.state.Provider.superclass.constructor.call(this);

};
Ext.extend(Ext.state.Provider, Ext.util.Observable, {

    get: function(name, defaultValue) {
        return typeof this.state[name] == "undefined" ? 
        defaultValue: this.state[name];

    },
    clear: function(name) {
        delete this.state[name];
        this.fireEvent("statechange", this, name, null);

    },
    set: function(name, value) {
        this.state[name] = value;
        this.fireEvent("statechange", this, name, value);

    },
    decodeValue: function(cookie) {
        var re = /^(a|n|d|b|s|o)\:(.*)$/;
        var matches = re.exec(unescape(cookie));
        if (!matches || !matches[1]) return;
        var type = matches[1];
        var v = matches[2];
        switch (type) {
            case "n":
            return parseFloat(v);
            case "d":
            return new Date(Date.parse(v));
            case "b":
            return (v == "1");
            case "a":
            var all = [];
            var values = v.split("^");
            for (var i = 0, len = values.length; i < len; i++) {
                all.push(this.decodeValue(values[i]));

            }
            return all;
            case "o":
            var all = {};
            var values = v.split("^");
            for (var i = 0, len = values.length; i < len; i++) {
                var kv = values[i].split("=");
                all[kv[0]] = this.decodeValue(kv[1]);

            }
            return all;
            default:
            return v;

        }

    },
    encodeValue: function(v) {
        var enc;
        if (typeof v == "number") {
            enc = "n:" + v;

        } else if (typeof v == "boolean") {
            enc = "b:" + (v ? "1": "0");

        } else if (Ext.isDate(v)) {
            enc = "d:" + v.toGMTString();

        } else if (Ext.isArray(v)) {
            var flat = "";
            for (var i = 0, len = v.length; i < len; i++) {
                flat += this.encodeValue(v[i]);
                if (i != len - 1) flat += "^";

            }
            enc = "a:" + flat;

        } else if (typeof v == "object") {
            var flat = "";
            for (var key in v) {
                if (typeof v[key] != "function" && v[key] !== undefined) {
                    flat += key + "=" + this.encodeValue(v[key]) + "^";

                }

            }
            enc = "o:" + flat.substring(0, flat.length - 1);

        } else {
            enc = "s:" + v;

        }
        return escape(enc);

    }

});


Ext.state.Manager = function() {
    var provider = new Ext.state.Provider();

    return {

        setProvider: function(stateProvider) {
            provider = stateProvider;

        },
        get: function(key, defaultValue) {
            return provider.get(key, defaultValue);

        },
        set: function(key, value) {
            provider.set(key, value);

        },
        clear: function(key) {
            provider.clear(key);

        },
        getProvider: function() {
            return provider;

        }

    };

} ();


Ext.state.CookieProvider = function(config) {
    Ext.state.CookieProvider.superclass.constructor.call(this);
    this.path = "/";
    this.expires = new Date(new Date().getTime() + (1000 * 60 * 60 * 24 * 7));
    this.domain = null;
    this.secure = false;
    Ext.apply(this, config);
    this.state = this.readCookies();

};

Ext.extend(Ext.state.CookieProvider, Ext.state.Provider, {

    set: function(name, value) {
        if (typeof value == "undefined" || value === null) {
            this.clear(name);
            return;

        }
        this.setCookie(name, value);
        Ext.state.CookieProvider.superclass.set.call(this, name, value);

    },
    clear: function(name) {
        this.clearCookie(name);
        Ext.state.CookieProvider.superclass.clear.call(this, name);

    },
    readCookies: function() {
        var cookies = {};
        var c = document.cookie + ";";
        var re = /\s?(.*?)=(.*?);/g;
        var matches;
        while ((matches = re.exec(c)) != null) {
            var name = matches[1];
            var value = matches[2];
            if (name && name.substring(0, 3) == "ys-") {
                cookies[name.substr(3)] = this.decodeValue(value);

            }

        }
        return cookies;

    },
    setCookie: function(name, value) {
        document.cookie = "ys-" + name + "=" + this.encodeValue(value) + 
        ((this.expires == null) ? "": ("; expires=" + this.expires.toGMTString())) + 
        ((this.path == null) ? "": ("; path=" + this.path)) + 
        ((this.domain == null) ? "": ("; domain=" + this.domain)) + 
        ((this.secure == true) ? "; secure": "");

    },
    clearCookie: function(name) {
        document.cookie = "ys-" + name + "=null; expires=Thu, 01-Jan-70 00:00:01 GMT" + 
        ((this.path == null) ? "": ("; path=" + this.path)) + 
        ((this.domain == null) ? "": ("; domain=" + this.domain)) + 
        ((this.secure == true) ? "; secure": "");

    }

});

Ext.DataView = Ext.extend(Ext.BoxComponent, {


    selectedClass: "x-view-selected",
    emptyText: "",
    
	deferEmptyText: true,
    last: false,
    initComponent: function() {
        Ext.DataView.superclass.initComponent.call(this);
        if (typeof this.tpl == "string") {
            this.tpl = new Ext.XTemplate(this.tpl);

        }

        this.addEvents(

        "beforeclick", 

        "click", 

        "containerclick", 

        "dblclick", 

        "contextmenu", 

        "selectionchange", 


        "beforeselect"
        );

        this.all = new Ext.CompositeElementLite();
        this.selected = new Ext.CompositeElementLite();

    },
    onRender: function() {
        if (!this.el) {
            this.el = document.createElement('div');
            this.el.id = this.id;

        }
        Ext.DataView.superclass.onRender.apply(this, arguments);

    },
    afterRender: function() {
        Ext.DataView.superclass.afterRender.call(this);

        this.el.on({
            "click": this.onClick,
            "dblclick": this.onDblClick,
            "contextmenu": this.onContextMenu,
            scope: this

        });

        if (this.overClass) {
            this.el.on({
                "mouseover": this.onMouseOver,
                "mouseout": this.onMouseOut,
                scope: this

            });

        }

        if (this.store) {
            this.setStore(this.store, true);

        }

    },
    refresh: function() {
        this.clearSelections(false, true);
        this.el.update("");
        var html = [];
        var records = this.store.getRange();
        if (records.length < 1) {
            if (!this.deferEmptyText || this.hasSkippedEmptyText) {
                this.el.update(this.emptyText);

            }
            this.hasSkippedEmptyText = true;
            this.all.clear();
            return;

        }
        this.tpl.overwrite(this.el, this.collectData(records, 0));
        this.all.fill(Ext.query(this.itemSelector, this.el.dom));
        this.updateIndexes(0);

    },
    prepareData: function(data) {
        return data;

    },
    collectData: function(records, startIndex) {
        var r = [];
        for (var i = 0, len = records.length; i < len; i++) {
            r[r.length] = this.prepareData(records[i].data, startIndex + i, records[i]);

        }
        return r;

    },
    bufferRender: function(records) {
        var div = document.createElement('div');
        this.tpl.overwrite(div, this.collectData(records));
        return Ext.query(this.itemSelector, div);

    },
    onUpdate: function(ds, record) {
        var index = this.store.indexOf(record);
        var sel = this.isSelected(index);
        var original = this.all.elements[index];
        var node = this.bufferRender([record], index)[0];

        this.all.replaceElement(index, node, true);
        if (sel) {
            this.selected.replaceElement(original, node);
            this.all.item(index).addClass(this.selectedClass);

        }
        this.updateIndexes(index, index);

    },
    onAdd: function(ds, records, index) {
        if (this.all.getCount() == 0) {
            this.refresh();
            return;

        }
        var nodes = this.bufferRender(records, index),
        n,
        a = this.all.elements;
        if (index < this.all.getCount()) {
            n = this.all.item(index).insertSibling(nodes, 'before', true);
            a.splice.apply(a, [index, 0].concat(nodes));

        } else {
            n = this.all.last().insertSibling(nodes, 'after', true);
            a.push.apply(a, nodes);

        }
        this.updateIndexes(index);

    },
    onRemove: function(ds, record, index) {
        this.deselect(index);
        this.all.removeElement(index, true);
        this.updateIndexes(index);

    },
    refreshNode: function(index) {
        this.onUpdate(this.store, this.store.getAt(index));

    },
    updateIndexes: function(startIndex, endIndex) {
        var ns = this.all.elements;
        startIndex = startIndex || 0;
        endIndex = endIndex || ((endIndex === 0) ? 0: (ns.length - 1));
        for (var i = startIndex; i <= endIndex; i++) {
            ns[i].viewIndex = i;

        }

    },
    setStore: function(store, initial) {
        if (!initial && this.store) {
            this.store.un("beforeload", this.onBeforeLoad, this);
            this.store.un("datachanged", this.refresh, this);
            this.store.un("add", this.onAdd, this);
            this.store.un("remove", this.onRemove, this);
            this.store.un("update", this.onUpdate, this);
            this.store.un("clear", this.refresh, this);

        }
        if (store) {
            store = Ext.StoreMgr.lookup(store);
            store.on("beforeload", this.onBeforeLoad, this);
            store.on("datachanged", this.refresh, this);
            store.on("add", this.onAdd, this);
            store.on("remove", this.onRemove, this);
            store.on("update", this.onUpdate, this);
            store.on("clear", this.refresh, this);

        }
        this.store = store;
        if (store) {
            this.refresh();

        }

    },
    findItemFromChild: function(node) {
        return Ext.fly(node).findParent(this.itemSelector, this.el);

    },
    onClick: function(e) {
        var item = e.getTarget(this.itemSelector, this.el);
        if (item) {
            var index = this.indexOf(item);
            if (this.onItemClick(item, index, e) !== false) {
                this.fireEvent("click", this, index, item, e);

            }

        } else {
            if (this.fireEvent("containerclick", this, e) !== false) {
                this.clearSelections();

            }

        }

    },
    onContextMenu: function(e) {
        var item = e.getTarget(this.itemSelector, this.el);
        if (item) {
            this.fireEvent("contextmenu", this, this.indexOf(item), item, e);

        }

    },
    onDblClick: function(e) {
        var item = e.getTarget(this.itemSelector, this.el);
        if (item) {
            this.fireEvent("dblclick", this, this.indexOf(item), item, e);

        }

    },
    onMouseOver: function(e) {
        var item = e.getTarget(this.itemSelector, this.el);
        if (item && item !== this.lastItem) {
            this.lastItem = item;
            Ext.fly(item).addClass(this.overClass);

        }

    },
    onMouseOut: function(e) {
        if (this.lastItem) {
            if (!e.within(this.lastItem, true)) {
                Ext.fly(this.lastItem).removeClass(this.overClass);
                delete this.lastItem;

            }

        }

    },
    onItemClick: function(item, index, e) {
        if (this.fireEvent("beforeclick", this, index, item, e) === false) {
            return false;

        }
        if (this.multiSelect) {
            this.doMultiSelection(item, index, e);
            e.preventDefault();

        } else if (this.singleSelect) {
            this.doSingleSelection(item, index, e);
            e.preventDefault();

        }
        return true;

    },
    doSingleSelection: function(item, index, e) {
        if (e.ctrlKey && this.isSelected(index)) {
            this.deselect(index);

        } else {
            this.select(index, false);

        }

    },
    doMultiSelection: function(item, index, e) {
        if (e.shiftKey && this.last !== false) {
            var last = this.last;
            this.selectRange(last, index, e.ctrlKey);
            this.last = last;
        } else {
            if ((e.ctrlKey || this.simpleSelect) && this.isSelected(index)) {
                this.deselect(index);

            } else {
                this.select(index, e.ctrlKey || e.shiftKey || this.simpleSelect);

            }

        }

    },
    getSelectionCount: function() {
        return this.selected.getCount()

    },
    getSelectedNodes: function() {
        return this.selected.elements;

    },
    getSelectedIndexes: function() {
        var indexes = [],
        s = this.selected.elements;
        for (var i = 0, len = s.length; i < len; i++) {
            indexes.push(s[i].viewIndex);

        }
        return indexes;

    },
    getSelectedRecords: function() {
        var r = [],
        s = this.selected.elements;
        for (var i = 0, len = s.length; i < len; i++) {
            r[r.length] = this.store.getAt(s[i].viewIndex);

        }
        return r;

    },
    getRecords: function(nodes) {
        var r = [],
        s = nodes;
        for (var i = 0, len = s.length; i < len; i++) {
            r[r.length] = this.store.getAt(s[i].viewIndex);

        }
        return r;

    },
    getRecord: function(node) {
        return this.store.getAt(node.viewIndex);

    },
    clearSelections: function(suppressEvent, skipUpdate) {
        if ((this.multiSelect || this.singleSelect) && this.selected.getCount() > 0) {
            if (!skipUpdate) {
                this.selected.removeClass(this.selectedClass);

            }
            this.selected.clear();
            this.last = false;
            if (!suppressEvent) {
                this.fireEvent("selectionchange", this, this.selected.elements);

            }

        }

    },
    isSelected: function(node) {
        return this.selected.contains(this.getNode(node));

    },
    deselect: function(node) {
        if (this.isSelected(node)) {
            var node = this.getNode(node);
            this.selected.removeElement(node);
            if (this.last == node.viewIndex) {
                this.last = false;

            }
            Ext.fly(node).removeClass(this.selectedClass);
            this.fireEvent("selectionchange", this, this.selected.elements);

        }

    },
    select: function(nodeInfo, keepExisting, suppressEvent) {
        if (Ext.isArray(nodeInfo)) {
            if (!keepExisting) {
                this.clearSelections(true);

            }
            for (var i = 0, len = nodeInfo.length; i < len; i++) {
                this.select(nodeInfo[i], true, true);

            }
            if (!suppressEvent) {
                this.fireEvent("selectionchange", this, this.selected.elements);

            }

        } else {
            var node = this.getNode(nodeInfo);
            if (!keepExisting) {
                this.clearSelections(true);

            }
            if (node && !this.isSelected(node)) {
                if (this.fireEvent("beforeselect", this, node, this.selected.elements) !== false) {
                    Ext.fly(node).addClass(this.selectedClass);
                    this.selected.add(node);
                    this.last = node.viewIndex;
                    if (!suppressEvent) {
                        this.fireEvent("selectionchange", this, this.selected.elements);

                    }

                }

            }

        }

    },
    selectRange: function(start, end, keepExisting) {
        if (!keepExisting) {
            this.clearSelections(true);

        }
        this.select(this.getNodes(start, end), true);

    },
    getNode: function(nodeInfo) {
        if (typeof nodeInfo == "string") {
            return document.getElementById(nodeInfo);

        } else if (typeof nodeInfo == "number") {
            return this.all.elements[nodeInfo];

        }
        return nodeInfo;

    },
    getNodes: function(start, end) {
        var ns = this.all.elements;
        start = start || 0;
        end = typeof end == "undefined" ? ns.length - 1: end;
        var nodes = [],
        i;
        if (start <= end) {
            for (i = start; i <= end; i++) {
                nodes.push(ns[i]);

            }

        } else {
            for (i = start; i >= end; i--) {
                nodes.push(ns[i]);

            }

        }
        return nodes;

    },
    indexOf: function(node) {
        node = this.getNode(node);
        if (typeof node.viewIndex == "number") {
            return node.viewIndex;

        }
        return this.all.indexOf(node);

    },
    onBeforeLoad: function() {
        if (this.loadingText) {
            this.clearSelections(false, true);
            this.el.update('<div class="loading-indicator">' + this.loadingText + '</div>');
            this.all.clear();

        }

    },
    onDestroy: function() {
        Ext.DataView.superclass.onDestroy.call(this);
        this.setStore(null);

    }

});

Ext.reg('dataview', Ext.DataView);

Ext.ColorPalette = function(config) {
    Ext.ColorPalette.superclass.constructor.call(this, config);
    this.addEvents(

    'select'
    );

    if (this.handler) {
        this.on("select", this.handler, this.scope, true);

    }

};
Ext.extend(Ext.ColorPalette, Ext.Component, {


    itemCls: "x-color-palette",
    value: null,
    clickEvent: 'click',
    ctype: "Ext.ColorPalette",
    allowReselect: false,
    colors: [
    "000000", "993300", "333300", "003300", "003366", "000080", "333399", "333333", 
    "800000", "FF6600", "808000", "008000", "008080", "0000FF", "666699", "808080", 
    "FF0000", "FF9900", "99CC00", "339966", "33CCCC", "3366FF", "800080", "969696", 
    "FF00FF", "FFCC00", "FFFF00", "00FF00", "00FFFF", "00CCFF", "993366", "C0C0C0", 
    "FF99CC", "FFCC99", "FFFF99", "CCFFCC", "CCFFFF", "99CCFF", "CC99FF", "FFFFFF"
    ],
    onRender: function(container, position) {
        var t = this.tpl || new Ext.XTemplate(
        '<tpl for="."><a href="#" class="color-{.}" hidefocus="on"><em><span style="background:#{.}" unselectable="on">&#160;</span></em></a></tpl>'
        );
        var el = document.createElement("div");
        el.className = this.itemCls;
        t.overwrite(el, this.colors);
        container.dom.insertBefore(el, position);
        this.el = Ext.get(el);
        this.el.on(this.clickEvent, this.handleClick, this, {
            delegate: "a"
        });
        if (this.clickEvent != 'click') {
            this.el.on('click', Ext.emptyFn, this, {
                delegate: "a",
                preventDefault: true
            });

        }

    },
    afterRender: function() {
        Ext.ColorPalette.superclass.afterRender.call(this);
        if (this.value) {
            var s = this.value;
            this.value = null;
            this.select(s);

        }

    },
    handleClick: function(e, t) {
        e.preventDefault();
        if (!this.disabled) {
            var c = t.className.match(/(?:^|\s)color-(.{6})(?:\s|$)/)[1];
            this.select(c.toUpperCase());

        }

    },
    select: function(color) {
        color = color.replace("#", "");
        if (color != this.value || this.allowReselect) {
            var el = this.el;
            if (this.value) {
                el.child("a.color-" + this.value).removeClass("x-color-palette-sel");

            }
            el.child("a.color-" + color).addClass("x-color-palette-sel");
            this.value = color;
            this.fireEvent("select", this, color);

        }

    }



});
Ext.reg('colorpalette', Ext.ColorPalette);

Ext.DatePicker = Ext.extend(Ext.Component, {

    todayText: "Today",
    okText: "&#160;OK&#160;",
    cancelText: "Cancel",
    todayTip: "{0} (Spacebar)",
    minDate: null,
    maxDate: null,
    minText: "This date is before the minimum date",
    maxText: "This date is after the maximum date",
    format: "m/d/y",
    disabledDays: null,
    disabledDaysText: "",
    disabledDatesRE: null,
    disabledDatesText: "",
    constrainToViewport: true,
    monthNames: Date.monthNames,
    dayNames: Date.dayNames,
    nextText: 'Next Month (Control+Right)',
    prevText: 'Previous Month (Control+Left)',
    monthYearText: 'Choose a month (Control+Up/Down to move years)',
    startDay: 0,
    initComponent: function() {
        Ext.DatePicker.superclass.initComponent.call(this);

        this.value = this.value ? 
        this.value.clearTime() : new Date().clearTime();

        this.addEvents(

        'select'
        );

        if (this.handler) {
            this.on("select", this.handler, this.scope || this);

        }

        this.initDisabledDays();

    },
    initDisabledDays: function() {
        if (!this.disabledDatesRE && this.disabledDates) {
            var dd = this.disabledDates;
            var re = "(?:";
            for (var i = 0; i < dd.length; i++) {
                re += dd[i];
                if (i != dd.length - 1) re += "|";

            }
            this.disabledDatesRE = new RegExp(re + ")");

        }

    },
    setValue: function(value) {
        var old = this.value;
        this.value = value.clearTime(true);
        if (this.el) {
            this.update(this.value);

        }

    },
    getValue: function() {
        return this.value;

    },
    focus: function() {
        if (this.el) {
            this.update(this.activeDate);

        }

    },
    onRender: function(container, position) {
        var m = [
        '<table cellspacing="0">', 
        '<tr><td class="x-date-left"><a href="#" title="', this.prevText, '">&#160;</a></td><td class="x-date-middle" align="center"></td><td class="x-date-right"><a href="#" title="', this.nextText, '">&#160;</a></td></tr>', 
        '<tr><td colspan="3"><table class="x-date-inner" cellspacing="0"><thead><tr>'];
        var dn = this.dayNames;
        for (var i = 0; i < 7; i++) {
            var d = this.startDay + i;
            if (d > 6) {
                d = d - 7;

            }
            m.push("<th><span>", dn[d].substr(0, 1), "</span></th>");

        }
        m[m.length] = "</tr></thead><tbody><tr>";
        for (var i = 0; i < 42; i++) {
            if (i % 7 == 0 && i != 0) {
                m[m.length] = "</tr><tr>";

            }
            m[m.length] = '<td><a href="#" hidefocus="on" class="x-date-date" tabIndex="1"><em><span></span></em></a></td>';

        }
        m[m.length] = '</tr></tbody></table></td></tr><tr><td colspan="3" class="x-date-bottom" align="center"></td></tr></table><div class="x-date-mp"></div>';

        var el = document.createElement("div");
        el.className = "x-date-picker";
        el.innerHTML = m.join("");

        container.dom.insertBefore(el, position);

        this.el = Ext.get(el);
        this.eventEl = Ext.get(el.firstChild);

        new Ext.util.ClickRepeater(this.el.child("td.x-date-left a"), {
            handler: this.showPrevMonth,
            scope: this,
            preventDefault: true,
            stopDefault: true

        });

        new Ext.util.ClickRepeater(this.el.child("td.x-date-right a"), {
            handler: this.showNextMonth,
            scope: this,
            preventDefault: true,
            stopDefault: true

        });

        this.eventEl.on("mousewheel", this.handleMouseWheel, this);

        this.monthPicker = this.el.down('div.x-date-mp');
        this.monthPicker.enableDisplayMode('block');

        var kn = new Ext.KeyNav(this.eventEl, {
            "left": function(e) {
                e.ctrlKey ? 
                this.showPrevMonth() : 
                this.update(this.activeDate.add("d", -1));

            },
            "right": function(e) {
                e.ctrlKey ? 
                this.showNextMonth() : 
                this.update(this.activeDate.add("d", 1));

            },
            "up": function(e) {
                e.ctrlKey ? 
                this.showNextYear() : 
                this.update(this.activeDate.add("d", -7));

            },
            "down": function(e) {
                e.ctrlKey ? 
                this.showPrevYear() : 
                this.update(this.activeDate.add("d", 7));

            },
            "pageUp": function(e) {
                this.showNextMonth();

            },
            "pageDown": function(e) {
                this.showPrevMonth();

            },
            "enter": function(e) {
                e.stopPropagation();
                return true;

            },
            scope: this

        });

        this.eventEl.on("click", this.handleDateClick, this, {
            delegate: "a.x-date-date"
        });

        this.eventEl.addKeyListener(Ext.EventObject.SPACE, this.selectToday, this);

        this.el.unselectable();

        this.cells = this.el.select("table.x-date-inner tbody td");
        this.textNodes = this.el.query("table.x-date-inner tbody span");

        this.mbtn = new Ext.Button({
            text: "&#160;",
            tooltip: this.monthYearText,
            renderTo: this.el.child("td.x-date-middle", true)

        });

        this.mbtn.on('click', this.showMonthPicker, this);
        this.mbtn.el.child(this.mbtn.menuClassTarget).addClass("x-btn-with-menu");


        var today = (new Date()).dateFormat(this.format);
        this.todayBtn = new Ext.Button({
            renderTo: this.el.child("td.x-date-bottom", true),
            text: String.format(this.todayText, today),
            tooltip: String.format(this.todayTip, today),
            handler: this.selectToday,
            scope: this

        });

        if (Ext.isIE) {
            this.el.repaint();

        }
        this.update(this.value);

    },
    createMonthPicker: function() {
        if (!this.monthPicker.dom.firstChild) {
            var buf = ['<table border="0" cellspacing="0">'];
            for (var i = 0; i < 6; i++) {
                buf.push(
                '<tr><td class="x-date-mp-month"><a href="#">', this.monthNames[i].substr(0, 3), '</a></td>', 
                '<td class="x-date-mp-month x-date-mp-sep"><a href="#">', this.monthNames[i + 6].substr(0, 3), '</a></td>', 
                i == 0 ? 
                '<td class="x-date-mp-ybtn" align="center"><a class="x-date-mp-prev"></a></td><td class="x-date-mp-ybtn" align="center"><a class="x-date-mp-next"></a></td></tr>': 
                '<td class="x-date-mp-year"><a href="#"></a></td><td class="x-date-mp-year"><a href="#"></a></td></tr>'
                );

            }
            buf.push(
            '<tr class="x-date-mp-btns"><td colspan="4"><button type="button" class="x-date-mp-ok">', 
            this.okText, 
            '</button><button type="button" class="x-date-mp-cancel">', 
            this.cancelText, 
            '</button></td></tr>', 
            '</table>'
            );
            this.monthPicker.update(buf.join(''));
            this.monthPicker.on('click', this.onMonthClick, this);
            this.monthPicker.on('dblclick', this.onMonthDblClick, this);

            this.mpMonths = this.monthPicker.select('td.x-date-mp-month');
            this.mpYears = this.monthPicker.select('td.x-date-mp-year');

            this.mpMonths.each(function(m, a, i) {
                i += 1;
                if ((i % 2) == 0) {
                    m.dom.xmonth = 5 + Math.round(i * .5);

                } else {
                    m.dom.xmonth = Math.round((i - 1) * .5);

                }

            });

        }

    },
    showMonthPicker: function() {
        this.createMonthPicker();
        var size = this.el.getSize();
        this.monthPicker.setSize(size);
        this.monthPicker.child('table').setSize(size);