ext2.2核心代码

Ext.DomHelper = function () {
    var L = null;
    var F = /^(?:br|frame|hr|img|input|link|meta|range|spacer|wbr|area|param|col)$/i;
    var B = /^table|tbody|tr|td$/i;
    var A = function (T) {
        if (typeof T == "string") {
            return T
        }
        var O = "";
        if (Ext.isArray(T)) {
            for (var R = 0, P = T.length; R < P; R++) {
                O += A(T[R])
            }
            return O
        }
        if (!T.tag) {
            T.tag = "div"
        }
        O += "<" + T.tag;
        for (var N in T) {
            if (N == "tag" || N == "children" || N == "cn" || N == "html" || typeof T[N] == "function") {
                continue
            }
            if (N == "style") {
                var S = T["style"];
                if (typeof S == "function") {
                    S = S.call()
                }
                if (typeof S == "string") {
                    O += " style=\"" + S + "\""
                } else {
                    if (typeof S == "object") {
                        O += " style=\"";
                        for (var Q in S) {
                            if (typeof S[Q] != "function") {
                                O += Q + ":" + S[Q] + ";"
                            }
                        }
                        O += "\""
                    }
                }
            } else {
                if (N == "cls") {
                    O += " class=\"" + T["cls"] + "\""
                } else {
                    if (N == "htmlFor") {
                        O += " for=\"" + T["htmlFor"] + "\""
                    } else {
                        O += " " + N + "=\"" + T[N] + "\""
                    }
                }
            }
        }
        if (F.test(T.tag)) {
            O += "/>"
        } else {
            O += ">";
            var U = T.children || T.cn;
            if (U) {
                O += A(U)
            } else {
                if (T.html) {
                    O += T.html
                }
            }
            O += "</" + T.tag + ">"
        }
        return O
    };
    var M = function (T, O) {
        var S;
        if (Ext.isArray(T)) {
            S = document.createDocumentFragment();
            for (var R = 0, P = T.length; R < P; R++) {
                M(T[R], S)
            }
        } else {
            if (typeof T == "string") {
                S = document.createTextNode(T)
            } else {
                S = document.createElement(T.tag || "div");
                var Q = !! S.setAttribute;
                for (var N in T) {
                    if (N == "tag" || N == "children" || N == "cn" || N == "html" || N == "style" || typeof T[N] == "function") {
                        continue
                    }
                    if (N == "cls") {
                        S.className = T["cls"]
                    } else {
                        if (Q) {
                            S.setAttribute(N, T[N])
                        } else {
                            S[N] = T[N]
                        }
                    }
                }
                Ext.DomHelper.applyStyles(S, T.style);
                var U = T.children || T.cn;
                if (U) {
                    M(U, S)
                } else {
                    if (T.html) {
                        S.innerHTML = T.html
                    }
                }
            }
        }
        if (O) {
            O.appendChild(S)
        }
        return S
    };
    var I = function (S, Q, P, R) {
        L.innerHTML = [Q, P, R].join("");
        var N = -1,
            O = L;
        while (++N < S) {
            O = O.firstChild
        }
        return O
    };
    var J = "<table>",
        E = "</table>",
        C = J + "<tbody>",
        K = "</tbody>" + E,
        H = C + "<tr>",
        D = "</tr>" + K;
    var G = function (N, O, Q, P) {
        if (!L) {
            L = document.createElement("div")
        }
        var R;
        var S = null;
        if (N == "td") {
            if (O == "afterbegin" || O == "beforeend") {
                return
            }
            if (O == "beforebegin") {
                S = Q;
                Q = Q.parentNode
            } else {
                S = Q.nextSibling;
                Q = Q.parentNode
            }
            R = I(4, H, P, D)
        } else {
            if (N == "tr") {
                if (O == "beforebegin") {
                    S = Q;
                    Q = Q.parentNode;
                    R = I(3, C, P, K)
                } else {
                    if (O == "afterend") {
                        S = Q.nextSibling;
                        Q = Q.parentNode;
                        R = I(3, C, P, K)
                    } else {
                        if (O == "afterbegin") {
                            S = Q.firstChild
                        }
                        R = I(4, H, P, D)
                    }
                }
            } else {
                if (N == "tbody") {
                    if (O == "beforebegin") {
                        S = Q;
                        Q = Q.parentNode;
                        R = I(2, J, P, E)
                    } else {
                        if (O == "afterend") {
                            S = Q.nextSibling;
                            Q = Q.parentNode;
                            R = I(2, J, P, E)
                        } else {
                            if (O == "afterbegin") {
                                S = Q.firstChild
                            }
                            R = I(3, C, P, K)
                        }
                    }
                } else {
                    if (O == "beforebegin" || O == "afterend") {
                        return
                    }
                    if (O == "afterbegin") {
                        S = Q.firstChild
                    }
                    R = I(2, J, P, E)
                }
            }
        }
        Q.insertBefore(R, S);
        return R
    };
    return {
        useDom: false,
        markup: function (N) {
            return A(N)
        }, applyStyles: function (P, Q) {
            if (Q) {
                P = Ext.fly(P);
                if (typeof Q == "string") {
                    var O = /\s?([a-z\-]*)\:\s?([^;]*);?/gi;
                    var R;
                    while ((R = O.exec(Q)) != null) {
                        P.setStyle(R[1], R[2])
                    }
                } else {
                    if (typeof Q == "object") {
                        for (var N in Q) {
                            P.setStyle(N, Q[N])
                        }
                    } else {
                        if (typeof Q == "function") {
                            Ext.DomHelper.applyStyles(P, Q.call())
                        }
                    }
                }
            }
        }, insertHtml: function (P, R, Q) {
            P = P.toLowerCase();
            if (R.insertAdjacentHTML) {
                if (B.test(R.tagName)) {
                    var O;
                    if (O = G(R.tagName.toLowerCase(), P, R, Q)) {
                        return O
                    }
                }
                switch (P) {
                case "beforebegin":
                    R.insertAdjacentHTML("BeforeBegin", Q);
                    return R.previousSibling;
                case "afterbegin":
                    R.insertAdjacentHTML("AfterBegin", Q);
                    return R.firstChild;
                case "beforeend":
                    R.insertAdjacentHTML("BeforeEnd", Q);
                    return R.lastChild;
                case "afterend":
                    R.insertAdjacentHTML("AfterEnd", Q);
                    return R.nextSibling
                }
                throw "Illegal insertion point -> \"" + P + "\""
            }
            var N = R.ownerDocument.createRange();
            var S;
            switch (P) {
            case "beforebegin":
                N.setStartBefore(R);
                S = N.createContextualFragment(Q);
                R.parentNode.insertBefore(S, R);
                return R.previousSibling;
            case "afterbegin":
                if (R.firstChild) {
                    N.setStartBefore(R.firstChild);
                    S = N.createContextualFragment(Q);
                    R.insertBefore(S, R.firstChild);
                    return R.firstChild
                } else {
                    R.innerHTML = Q;
                    return R.firstChild
                }
            case "beforeend":
                if (R.lastChild) {
                    N.setStartAfter(R.lastChild);
                    S = N.createContextualFragment(Q);
                    R.appendChild(S);
                    return R.lastChild
                } else {
                    R.innerHTML = Q;
                    return R.lastChild
                }
            case "afterend":
                N.setStartAfter(R);
                S = N.createContextualFragment(Q);
                R.parentNode.insertBefore(S, R.nextSibling);
                return R.nextSibling
            }
            throw "Illegal insertion point -> \"" + P + "\""
        }, insertBefore: function (N, P, O) {
            return this.doInsert(N, P, O, "beforeBegin")
        }, insertAfter: function (N, P, O) {
            return this.doInsert(N, P, O, "afterEnd", "nextSibling")
        }, insertFirst: function (N, P, O) {
            return this.doInsert(N, P, O, "afterBegin", "firstChild")
        }, doInsert: function (Q, S, R, T, P) {
            Q = Ext.getDom(Q);
            var O;
            if (this.useDom) {
                O = M(S, null);
                (P === "firstChild" ? Q : Q.parentNode).insertBefore(O, P ? Q[P] : Q)
            } else {
                var N = A(S);
                O = this.insertHtml(T, Q, N)
            }
            return R ? Ext.get(O, true) : O
        }, append: function (P, R, Q) {
            P = Ext.getDom(P);
            var O;
            if (this.useDom) {
                O = M(R, null);
                P.appendChild(O)
            } else {
                var N = A(R);
                O = this.insertHtml("beforeEnd", P, N)
            }
            return Q ? Ext.get(O, true) : O
        }, overwrite: function (N, P, O) {
            N = Ext.getDom(N);
            N.innerHTML = A(P);
            return O ? Ext.get(N.firstChild, true) : N.firstChild
        }, createTemplate: function (O) {
            var N = A(O);
            return new Ext.Template(N)
        }
    }
}();
Ext.Template = function (E) {
    var B = arguments;
    if (Ext.isArray(E)) {
        E = E.join("")
    } else {
        if (B.length > 1) {
            var C = [];
            for (var D = 0, A = B.length; D < A; D++) {
                if (typeof B[D] == "object") {
                    Ext.apply(this, B[D])
                } else {
                    C[C.length] = B[D]
                }
            }
            E = C.join("")
        }
    }
    this.html = E;
    if (this.compiled) {
        this.compile()
    }
};
Ext.Template.prototype = {
    applyTemplate: function (B) {
        if (this.compiled) {
            return this.compiled(B)
        }
        var A = this.disableFormats !== true;
        var E = Ext.util.Format,
            C = this;
        var D = function (G, I, L, H) {
            if (L && A) {
                if (L.substr(0, 5) == "this.") {
                    return C.call(L.substr(5), B[I], B)
                } else {
                    if (H) {
                        var K = /^\s*['"](.*)["']\s*$/;
                        H = H.split(",");
                        for (var J = 0, F = H.length; J < F; J++) {
                            H[J] = H[J].replace(K, "$1")
                        }
                        H = [B[I]].concat(H)
                    } else {
                        H = [B[I]]
                    }
                    return E[L].apply(E, H)
                }
            } else {
                return B[I] !== undefined ? B[I] : ""
            }
        };
        return this.html.replace(this.re, D)
    }, set: function (A, B) {
        this.html = A;
        this.compiled = null;
        if (B) {
            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 (C, B, A) {
        return this[C](B, A)
    }, insertFirst: function (B, A, C) {
        return this.doInsert("afterBegin", B, A, C)
    }, insertBefore: function (B, A, C) {
        return this.doInsert("beforeBegin", B, A, C)
    }, insertAfter: function (B, A, C) {
        return this.doInsert("afterEnd", B, A, C)
    }, append: function (B, A, C) {
        return this.doInsert("beforeEnd", B, A, C)
    }, doInsert: function (C, E, B, A) {
        E = Ext.getDom(E);
        var D = Ext.DomHelper.insertHtml(C, E, this.applyTemplate(B));
        return A ? Ext.get(D, true) : D
    }, overwrite: function (B, A, C) {
        B = Ext.getDom(B);
        B.innerHTML = this.applyTemplate(A);
        return C ? Ext.get(B.firstChild, true) : B.firstChild
    }
};
Ext.Template.prototype.apply = Ext.Template.prototype.applyTemplate;
Ext.DomHelper.Template = Ext.Template;
Ext.Template.from = function (B, A) {
    B = Ext.getDom(B);
    return new Ext.Template(B.value || B.innerHTML, A || "")
};
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 A = this.events[arguments[0].toLowerCase()];
            if (typeof A == "object") {
                return A.fire.apply(A, Array.prototype.slice.call(arguments, 1))
            }
        }
        return true
    }, filterOptRe: /^(?:scope|delay|buffer|single)$/,
    addListener: function (A, C, B, F) {
        if (typeof A == "object") {
            F = A;
            for (var E in F) {
                if (this.filterOptRe.test(E)) {
                    continue
                }
                if (typeof F[E] == "function") {
                    this.addListener(E, F[E], F.scope, F)
                } else {
                    this.addListener(E, F[E].fn, F[E].scope, F[E])
                }
            }
            return
        }
        F = (!F || typeof F == "boolean") ? {} : F;
        A = A.toLowerCase();
        var D = this.events[A] || true;
        if (typeof D == "boolean") {
            D = new Ext.util.Event(this, A);
            this.events[A] = D
        }
        D.addListener(C, B, F)
    }, removeListener: function (A, C, B) {
        var D = this.events[A.toLowerCase()];
        if (typeof D == "object") {
            D.removeListener(C, B)
        }
    }, purgeListeners: function () {
        for (var A in this.events) {
            if (typeof this.events[A] == "object") {
                this.events[A].clearListeners()
            }
        }
    }, relayEvents: function (F, D) {
        var E = function (G) {
            return function () {
                return this.fireEvent.apply(this, Ext.combine(G, Array.prototype.slice.call(arguments, 0)))
            }
        };
        for (var C = 0, A = D.length; C < A; C++) {
            var B = D[C];
            if (!this.events[B]) {
                this.events[B] = true
            }
            F.on(B, E(B), this)
        }
    }, addEvents: function (D) {
        if (!this.events) {
            this.events = {}
        }
        if (typeof D == "string") {
            for (var C = 0, A = arguments, B; B = A[C]; C++) {
                if (!this.events[A[C]]) {
                    this.events[A[C]] = true
                }
            }
        } else {
            Ext.applyIf(this.events, D)
        }
    }, hasListener: function (A) {
        var B = this.events[A];
        return typeof B == "object" && B.listeners.length > 0
    }, suspendEvents: function () {
        this.eventsSuspended = true
    }, resumeEvents: function () {
        this.eventsSuspended = false
    }, getMethodEvent: function (G) {
        if (!this.methodEvents) {
            this.methodEvents = {}
        }
        var F = this.methodEvents[G];
        if (!F) {
            F = {};
            this.methodEvents[G] = F;
            F.originalFn = this[G];
            F.methodName = G;
            F.before = [];
            F.after = [];
            var C, B, D;
            var E = this;
            var A = function (J, I, H) {
                if ((B = J.apply(I || E, H)) !== undefined) {
                    if (typeof B === "object") {
                        if (B.returnValue !== undefined) {
                            C = B.returnValue
                        } else {
                            C = B
                        }
                        if (B.cancel === true) {
                            D = true
                        }
                    } else {
                        if (B === false) {
                            D = true
                        } else {
                            C = B
                        }
                    }
                }
            };
            this[G] = function () {
                C = B = undefined;
                D = false;
                var I = Array.prototype.slice.call(arguments, 0);
                for (var J = 0, H = F.before.length; J < H; J++) {
                    A(F.before[J].fn, F.before[J].scope, I);
                    if (D) {
                        return C
                    }
                }
                if ((B = F.originalFn.apply(E, I)) !== undefined) {
                    C = B
                }
                for (var J = 0, H = F.after.length; J < H; J++) {
                    A(F.after[J].fn, F.after[J].scope, I);
                    if (D) {
                        return C
                    }
                }
                return C
            }
        }
        return F
    }, beforeMethod: function (D, B, A) {
        var C = this.getMethodEvent(D);
        C.before.push({
            fn: B,
            scope: A
        })
    }, afterMethod: function (D, B, A) {
        var C = this.getMethodEvent(D);
        C.after.push({
            fn: B,
            scope: A
        })
    }, removeMethodListener: function (F, D, C) {
        var E = this.getMethodEvent(F);
        for (var B = 0, A = E.before.length; B < A; B++) {
            if (E.before[B].fn == D && E.before[B].scope == C) {
                E.before.splice(B, 1);
                return
            }
        }
        for (var B = 0, A = E.after.length; B < A; B++) {
            if (E.after[B].fn == D && E.after[B].scope == C) {
                E.after.splice(B, 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 (C, B, A) {
    C.fireEvent = C.fireEvent.createInterceptor(B, A)
};
Ext.util.Observable.releaseCapture = function (A) {
    A.fireEvent = Ext.util.Observable.prototype.fireEvent
};
(function () {
    var B = function (F, G, E) {
        var D = new Ext.util.DelayedTask();
        return function () {
            D.delay(G.buffer, F, E, Array.prototype.slice.call(arguments, 0))
        }
    };
    var C = function (F, G, E, D) {
        return function () {
            G.removeListener(E, D);
            return F.apply(D, arguments)
        }
    };
    var A = function (E, F, D) {
        return function () {
            var G = Array.prototype.slice.call(arguments, 0);
            setTimeout(function () {
                E.apply(D, G)
            }, F.delay || 10)
        }
    };
    Ext.util.Event = function (E, D) {
        this.name = D;
        this.obj = E;
        this.listeners = []
    };
    Ext.util.Event.prototype = {
        addListener: function (G, F, E) {
            F = F || this.obj;
            if (!this.isListening(G, F)) {
                var D = this.createListener(G, F, E);
                if (!this.firing) {
                    this.listeners.push(D)
                } else {
                    this.listeners = this.listeners.slice(0);
                    this.listeners.push(D)
                }
            }
        }, createListener: function (G, F, H) {
            H = H || {};
            F = F || this.obj;
            var D = {
                fn: G,
                scope: F,
                options: H
            };
            var E = G;
            if (H.delay) {
                E = A(E, H, F)
            }
            if (H.single) {
                E = C(E, this, G, F)
            }
            if (H.buffer) {
                E = B(E, H, F)
            }
            D.fireFn = E;
            return D
        }, findListener: function (I, H) {
            H = H || this.obj;
            var F = this.listeners;
            for (var G = 0, D = F.length; G < D; G++) {
                var E = F[G];
                if (E.fn == I && E.scope == H) {
                    return G
                }
            }
            return -1
        }, isListening: function (E, D) {
            return this.findListener(E, D) != -1
        }, removeListener: function (F, E) {
            var D;
            if ((D = this.findListener(F, E)) != -1) {
                if (!this.firing) {
                    this.listeners.splice(D, 1)
                } else {
                    this.listeners = this.listeners.slice(0);
                    this.listeners.splice(D, 1)
                }
                return true
            }
            return false
        }, clearListeners: function () {
            this.listeners = []
        }, fire: function () {
            var F = this.listeners,
                I, D = F.length;
            if (D > 0) {
                this.firing = true;
                var G = Array.prototype.slice.call(arguments, 0);
                for (var H = 0; H < D; H++) {
                    var E = F[H];
                    if (E.fireFn.apply(E.scope || this.obj || window, arguments) === false) {
                        this.firing = false;
                        return false
                    }
                }
                this.firing = false
            }
            return true
        }
    }
})();
Ext.EventManager = function () {
    var T, M, I = false;
    var K, S, C, O;
    var L = Ext.lib.Event;
    var N = Ext.lib.Dom;
    var B = function () {
        if (!I) {
            I = true;
            Ext.isReady = true;
            if (M) {
                clearInterval(M)
            }
            if (Ext.isGecko || Ext.isOpera) {
                document.removeEventListener("DOMContentLoaded", B, false)
            }
            if (Ext.isIE) {
                var D = document.getElementById("ie-deferred-loader");
                if (D) {
                    D.onreadystatechange = null;
                    D.parentNode.removeChild(D)
                }
            }
            if (T) {
                T.fire();
                T.clearListeners()
            }
        }
    };
    var A = function () {
        T = new Ext.util.Event();
        if (Ext.isGecko || Ext.isOpera) {
            document.addEventListener("DOMContentLoaded", B, false)
        } else {
            if (Ext.isIE) {
                document.write("<s" + "cript id=\"ie-deferred-loader\" defer=\"defer\" src=\"/" + "/:\"></s" + "cript>");
                var D = document.getElementById("ie-deferred-loader");
                D.onreadystatechange = function () {
                    if (this.readyState == "complete") {
                        B()
                    }
                }
            } else {
                if (Ext.isSafari) {
                    M = setInterval(function () {
                        var E = document.readyState;
                        if (E == "complete") {
                            B()
                        }
                    }, 10)
                }
            }
        }
        L.on(window, "load", B)
    };
    var R = function (E, U) {
        var D = new Ext.util.DelayedTask(E);
        return function (V) {
            V = new Ext.EventObjectImpl(V);
            D.delay(U.buffer, E, null, [V])
        }
    };
    var P = function (V, U, D, E) {
        return function (W) {
            Ext.EventManager.removeListener(U, D, E);
            V(W)
        }
    };
    var F = function (D, E) {
        return function (U) {
            U = new Ext.EventObjectImpl(U);
            setTimeout(function () {
                D(U)
            }, E.delay || 10)
        }
    };
    var J = function (U, E, D, Y, X) {
        var Z = (!D || typeof D == "boolean") ? {} : D;
        Y = Y || Z.fn;
        X = X || Z.scope;
        var W = Ext.getDom(U);
        if (!W) {
            throw "Error listening for \"" + E + "\". Element \"" + U + "\" doesn't exist."
        }
        var V = function (b) {
            b = Ext.EventObject.setEvent(b);
            var a;
            if (Z.delegate) {
                a = b.getTarget(Z.delegate, W);
                if (!a) {
                    return
                }
            } else {
                a = b.target
            }
            if (Z.stopEvent === true) {
                b.stopEvent()
            }
            if (Z.preventDefault === true) {
                b.preventDefault()
            }
            if (Z.stopPropagation === true) {
                b.stopPropagation()
            }
            if (Z.normalized === false) {
                b = b.browserEvent
            }
            Y.call(X || W, b, a, Z)
        };
        if (Z.delay) {
            V = F(V, Z)
        }
        if (Z.single) {
            V = P(V, W, E, Y)
        }
        if (Z.buffer) {
            V = R(V, Z)
        }
        Y._handlers = Y._handlers || [];
        Y._handlers.push([Ext.id(W), E, V]);
        L.on(W, E, V);
        if (E == "mousewheel" && W.addEventListener) {
            W.addEventListener("DOMMouseScroll", V, false);
            L.on(window, "unload", function () {
                W.removeEventListener("DOMMouseScroll", V, false)
            })
        }
        if (E == "mousedown" && W == document) {
            Ext.EventManager.stoppedMouseDownEvent.addListener(V)
        }
        return V
    };
    var G = function (E, U, Z) {
        var D = Ext.id(E),
            a = Z._handlers,
            X = Z;
        if (a) {
            for (var V = 0, Y = a.length; V < Y; V++) {
                var W = a[V];
                if (W[0] == D && W[1] == U) {
                    X = W[2];
                    a.splice(V, 1);
                    break
                }
            }
        }
        L.un(E, U, X);
        E = Ext.getDom(E);
        if (U == "mousewheel" && E.addEventListener) {
            E.removeEventListener("DOMMouseScroll", X, false)
        }
        if (U == "mousedown" && E == document) {
            Ext.EventManager.stoppedMouseDownEvent.removeListener(X)
        }
    };
    var H = /^(?:scope|delay|buffer|single|stopEvent|preventDefault|stopPropagation|normalized|args|delegate)$/;
    var Q = {
        addListener: function (U, D, W, V, E) {
            if (typeof D == "object") {
                var Y = D;
                for (var X in Y) {
                    if (H.test(X)) {
                        continue
                    }
                    if (typeof Y[X] == "function") {
                        J(U, X, Y, Y[X], Y.scope)
                    } else {
                        J(U, X, Y[X])
                    }
                }
                return
            }
            return J(U, D, E, W, V)
        }, removeListener: function (E, D, U) {
            return G(E, D, U)
        }, onDocumentReady: function (U, E, D) {
            if (I) {
                T.addListener(U, E, D);
                T.fire();
                T.clearListeners();
                return
            }
            if (!T) {
                A()
            }
            T.addListener(U, E, D)
        }, onWindowResize: function (U, E, D) {
            if (!K) {
                K = new Ext.util.Event();
                S = new Ext.util.DelayedTask(function () {
                    K.fire(N.getViewWidth(), N.getViewHeight())
                });
                L.on(window, "resize", this.fireWindowResize, this)
            }
            K.addListener(U, E, D)
        }, fireWindowResize: function () {
            if (K) {
                if ((Ext.isIE || Ext.isAir) && S) {
                    S.delay(50)
                } else {
                    K.fire(N.getViewWidth(), N.getViewHeight())
                }
            }
        }, onTextResize: function (V, U, D) {
            if (!C) {
                C = new Ext.util.Event();
                var E = new Ext.Element(document.createElement("div"));
                E.dom.className = "x-text-resize";
                E.dom.innerHTML = "X";
                E.appendTo(document.body);
                O = E.dom.offsetHeight;
                setInterval(function () {
                    if (E.dom.offsetHeight != O) {
                        C.fire(O, O = E.dom.offsetHeight)
                    }
                }, this.textResizeInterval)
            }
            C.addListener(V, U, D)
        }, removeResizeListener: function (E, D) {
            if (K) {
                K.removeListener(E, D)
            }
        }, fireResize: function () {
            if (K) {
                K.fire(N.getViewWidth(), N.getViewHeight())
            }
        }, ieDeferSrc: false,
        textResizeInterval: 50
    };
    Q.on = Q.addListener;
    Q.un = Q.removeListener;
    Q.stoppedMouseDownEvent = new Ext.util.Event();
    return Q
}();
Ext.onReady = Ext.EventManager.onDocumentReady;
Ext.onReady(function () {
    var B = Ext.getBody();
    if (!B) {
        return
    }
    var A = [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) {
        A.push("ext-mac")
    }
    if (Ext.isLinux) {
        A.push("ext-linux")
    }
    if (Ext.isBorderBox) {
        A.push("ext-border-box")
    }
    if (Ext.isStrict) {
        var C = B.dom.parentNode;
        if (C) {
            C.className += " ext-strict"
        }
    }
    B.addClass(A.join(" "))
});
Ext.EventObject = function () {
    var B = Ext.lib.Event;
    var A = {
        63234: 37,
        63235: 39,
        63232: 38,
        63233: 40,
        63276: 33,
        63277: 34,
        63272: 46,
        63273: 36,
        63275: 35
    };
    var C = 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 (D) {
        if (D) {
            this.setEvent(D.browserEvent || D)
        }
    };
    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 (D) {
            if (D == this || (D && D.browserEvent)) {
                return D
            }
            this.browserEvent = D;
            if (D) {
                this.button = D.button ? C[D.button] : (D.which ? D.which - 1 : -1);
                if (D.type == "click" && this.button == -1) {
                    this.button = 0
                }
                this.type = D.type;
                this.shiftKey = D.shiftKey;
                this.ctrlKey = D.ctrlKey || D.metaKey;
                this.altKey = D.altKey;
                this.keyCode = D.keyCode;
                this.charCode = D.charCode;
                this.target = B.getTarget(D);
                this.xy = B.getXY(D)
            } 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)
                }
                B.stopEvent(this.browserEvent)
            }
        }, preventDefault: function () {
            if (this.browserEvent) {
                B.preventDefault(this.browserEvent)
            }
        }, isNavKeyPress: function () {
            var D = this.keyCode;
            D = Ext.isSafari ? (A[D] || D) : D;
            return (D >= 33 && D <= 40) || D == this.RETURN || D == this.TAB || D == this.ESC
        }, isSpecialKey: function () {
            var D = this.keyCode;
            return (this.type == "keypress" && this.ctrlKey) || D == 9 || D == 13 || D == 40 || D == 27 || (D == 16) || (D == 17) || (D >= 18 && D <= 20) || (D >= 33 && D <= 35) || (D >= 36 && D <= 39) || (D >= 44 && D <= 45)
        }, stopPropagation: function () {
            if (this.browserEvent) {
                if (this.browserEvent.type == "mousedown") {
                    Ext.EventManager.stoppedMouseDownEvent.fire(this)
                }
                B.stopPropagation(this.browserEvent)
            }
        }, getCharCode: function () {
            return this.charCode || this.keyCode
        }, getKey: function () {
            var D = this.keyCode || this.charCode;
            return Ext.isSafari ? (A[D] || D) : D
        }, getPageX: function () {
            return this.xy[0]
        }, getPageY: function () {
            return this.xy[1]
        }, getTime: function () {
            if (this.browserEvent) {
                return B.getTime(this.browserEvent)
            }
            return null
        }, getXY: function () {
            return this.xy
        }, getTarget: function (E, F, D) {
            return E ? Ext.fly(this.target).findParent(E, F, D) : (D ? Ext.get(this.target) : this.target)
        }, getRelatedTarget: function () {
            if (this.browserEvent) {
                return B.getRelatedTarget(this.browserEvent)
            }
            return null
        }, getWheelDelta: function () {
            var D = this.browserEvent;
            var E = 0;
            if (D.wheelDelta) {
                E = D.wheelDelta / 120
            } else {
                if (D.detail) {
                    E = -D.detail / 3
                }
            }
            return E
        }, hasModifier: function () {
            return ((this.ctrlKey || this.altKey) || this.shiftKey) ? true : false
        }, within: function (E, F) {
            var D = this[F ? "getRelatedTarget" : "getTarget"]();
            return D && Ext.fly(E).contains(D)
        }, 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) || 0.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